+ Scroll enables creators to turn their content into interactive, explorable experiences. With Scroll, you can create
+ rich, interactive stories that engage readers, provide a better user experience, and help you stand out from the
+ crowd.
+
+
+
+
How does Scroll work?
+
+ Scroll combines powerful technologies like WebGL and WebRTC to create immersive, interactive experiences. The
+ platform allows you to build 3D environments, add interactivity, and embed content from popular web services to
+ create a unique, engaging experience for your audience.
+
+
+
+
What can I build with Scroll?
+
+ You can build a wide range of experiences with Scroll, from interactive articles to immersive product demos and
+ virtual tours. Scroll is designed to help you create engaging, interactive experiences that elevate your content and
+ captivate your audience.
+
+
+
+### Markmap
+
+#### Referenced File
+
+
+
+
+[](#markmap)markmap
+===================
+
+- beautiful2
+- useful
+- easy
+- interactive
+
+
+
+### Mermaid
+
+```mermaid
+stateDiagram
+ Step --> StepState
+ Step --> CellManager
+ ConstraintBuilder --> CellManager
+ CellManager --> ProofSystem(Halo2)
+ StepState --> ExecutionState
+ StepState --> step_context
+ ExecutionState --> ConstraintBuilder
+ step_context --> ConstraintBuilder
+```
+
+### RPC Table
+
+
\ No newline at end of file
diff --git a/src/content/docs/tr/developers/_images/enforcedTxData.png b/src/content/docs/tr/developers/_images/enforcedTxData.png
new file mode 100644
index 000000000..55b8c612e
Binary files /dev/null and b/src/content/docs/tr/developers/_images/enforcedTxData.png differ
diff --git a/src/content/docs/tr/developers/_images/enforcedTxSepoliascan.png b/src/content/docs/tr/developers/_images/enforcedTxSepoliascan.png
new file mode 100644
index 000000000..c23a1e435
Binary files /dev/null and b/src/content/docs/tr/developers/_images/enforcedTxSepoliascan.png differ
diff --git a/src/content/docs/tr/developers/_images/injectedProviderMM.png b/src/content/docs/tr/developers/_images/injectedProviderMM.png
new file mode 100644
index 000000000..816517512
Binary files /dev/null and b/src/content/docs/tr/developers/_images/injectedProviderMM.png differ
diff --git a/src/content/docs/tr/developers/_images/mmNetworkSelection.png b/src/content/docs/tr/developers/_images/mmNetworkSelection.png
new file mode 100644
index 000000000..e86176f9b
Binary files /dev/null and b/src/content/docs/tr/developers/_images/mmNetworkSelection.png differ
diff --git a/src/content/docs/tr/developers/_images/verify1.png b/src/content/docs/tr/developers/_images/verify1.png
new file mode 100644
index 000000000..b27db86bb
Binary files /dev/null and b/src/content/docs/tr/developers/_images/verify1.png differ
diff --git a/src/content/docs/tr/developers/developer-quickstart.mdx b/src/content/docs/tr/developers/developer-quickstart.mdx
new file mode 100644
index 000000000..1f11d8384
--- /dev/null
+++ b/src/content/docs/tr/developers/developer-quickstart.mdx
@@ -0,0 +1,260 @@
+---
+section: developers
+date: Last Modified
+title: "Geliştirici Hızlı Başlangıcı"
+lang: "tr"
+permalink: "developers/developer-quickstart"
+excerpt: "Scroll Geliştirici Hızlı Başlangıcı, test ağı Ether'i edinmenize, ağınızı yapılandırmanıza ve tüm favori araçlarınıza erişmenize yardımcı olur"
+whatsnext: { "Akıllı Sözleşemenizi Doğrulayın": "/tr/developers/verifying-smart-contracts" }
+---
+
+import Aside from "../../../../components/Aside.astro"
+import ClickToZoom from "../../../../components/ClickToZoom.astro"
+import networkSelection from "./_images/mmNetworkSelection.png"
+import injectedProviderMM from "./_images/injectedProviderMM.png"
+import ToggleElement from "../../../../components/ToggleElement.astro"
+
+Scroll ile akıllı sözleşmeler oluştururken ve test ederken en sevdiğiniz araçlar oldukları gibi çalışırlar.
+
+Scroll, EVM ile bytecode olarak denk olduğu için en sevdiğiniz geliştirici araçlarınızı bir Scroll RPC sağlayıcısına yönlendirmeniz yeterli olacaktır.
+
+Herhangi bir sorunla karşılaşırsanız lütfen [Discord'umuzdan](https://discord.gg/scroll) bize ulaşın.
+
+## Ether Edinme
+
+Scroll yerel para birimi olarak ETH'yi kullanıyor ve bu ETH'ler, ağda akıllı sözleşme dağıtımı ve etkileşimleri için işlem ücretlerini ödemek için gerekli olacak.
+
+Scroll üzerinde inşa etmeye başlamak için Scroll Sepolia test ağımızı kullanarak başlamanızı öneririz. Öncelikle bir miktar test ağı ETH edinmeniz gerekecek. Sepolia'da test token'ları almayla ilgili ipuçları için [Musluk](/tr/user-guide/faucet) sayfasına bakın. Bundan sonra, [Köprü makalesinde](/tr/user-guide/bridge) açıklandığı gibi [Sepolia Köprümüzü](https://sepolia.scroll.io/bridge) kullanarak test ağı ETH'lerinizi Scroll Sepolia Test ağına (Katman 2) aktarabilirsiniz.
+
+Adım adım açıklama için Kullanım Kılavuzunun [Kurulum](/tr/user-guide/setup) sayfasıyla başlayın.
+
+Scroll ana ağında akıllı sözleşme dağıtmak için hazır olduğunuzda, [yerel köprümüzü](https://scroll.io/bridge/) veya 3. taraf köprülerden birini kullanarak ETH üzerinden köprü kurabilirsiniz.
+
+## Ağ Yapılandırması
+
+### Scroll Ana Ağı
+
+Ethereum araçlarınızı Scroll ana ağına yapılandırmak için aşağıdaki tabloyu kullanın.
+
+| Ağ Adı | Scroll | Ethereum Ana Ağı |
+| ------------------ | -------------------------------------------------- | ---------------------------------------------------- |
+| RPC URL'si | [https://rpc.scroll.io/](https://rpc.scroll.io/) | [https://eth.llamarpc.com](https://eth.llamarpc.com) |
+| Zincir Kimliği | 534352 | 1 |
+| Para Birimi Sembolü| ETH | ETH |
+| Blok Gezgini URL'si| [https://scrollscan.com/](https://scrollscan.com/) | [https://etherscan.io](https://etherscan.io) |
+
+
+
Ek Scroll Ana Ağ RPC'leri ve Altyapıları
+ - [Scroll Yerel Köprüsü](https://scroll.io/bridge)
+ - [ChainList.org'daki Scroll RPC Sağlayıcıları](https://chainlist.org/chain/534352)
+ - [ChainList.org'daki Ethereum RPC Sağlayıcıları](https://chainlist.org/chain/1)
+ {/* - Ek Blok Gezginleri:
+ - [Dora](https://www.ondora.xyz/network/scroll/interactions)
+ - [L2Scan](https://scroll.l2scan.co/) */}
+
+
+
+### Scroll Sepolia Test Ağı
+
+Ethereum araçlarınızı Scroll Sepolia Test ağına yapılandırmak için aşağıdaki tabloyu kullanın.
+
+| Ağ Adı | Scroll Sepolia | Ethereum Sepolia |
+| ------------------ | ----------------------------------------------------------------- | ------------------------------------------------------------ |
+| RPC URL'si | [https://sepolia-rpc.scroll.io/](https://sepolia-rpc.scroll.io/) | [https://rpc2.sepolia.org](https://rpc2.sepolia.org) |
+| Zincir Kimliği | 534351 | 11155111 |
+| Para Birimi Sembolü| ETH | ETH |
+| Blok Gezgini URL'si| [https://sepolia.scrollscan.com](https://sepolia.scrollscan.com/) | [https://sepolia.etherscan.io](https://sepolia.etherscan.io) |
+
+
+
Ek Scroll Sepolia RPC'leri ve Altyapıları
+ - [Scroll Sepolia Yerel Köprüsü](https://sepolia.scroll.io/bridge)
+ - [ChainList.org'daki Scroll Sepolia RPC Sağlayıcıları](https://chainlist.org/chain/534351)
+ - [ChainList.org'daki Ethereum Sepolia RPC Sağlayıcıları](https://chainlist.org/chain/11155111)
+ - Ek Blok Gezginleri:
+ - [Dora](https://www.ondora.xyz/network/scroll-sepolia/interactions)
+ - [L2Scan](https://scroll.l2scan.co/)
+
+
+
+## Araçlarınızı Yapılandırın
+
+
+
+### Hardhat
+
+Hardhat yapılandırma dosyanızı `hardhat.config.ts'yi Scroll Sepolia Test ağı public RPC'sini işaret edecek şekilde değiştirin.
+
+```jsx
+...
+
+const config: HardhatUserConfig = {
+ ...
+ networks: {
+ scrollSepolia: {
+ url: "https://sepolia-rpc.scroll.io/" || "",
+ accounts:
+ process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
+ },
+ },
+};
+
+...
+```
+
+### Foundry
+
+Scroll Sepolia Test ağı Public RPC'sini kullanarak dağıtım yapmak için şunu çalıştırın:
+
+```bash
+forge create ... --rpc-url=https://sepolia-rpc.scroll.io/ --legacy
+```
+
+### Remix Web IDE
+
+Sözleşmelerinizi derledikten sonra Remix kullanarak dağıtım yapmanın en kolay yolu, [Metamask'ı kurmak](/tr/user-guide/setup) ve ardından **Scroll Sepolia Test ağını** seçmektir.
+
+
+
+Şimdi, "Dağıt ve İşlemleri Çalıştır" sekmesinde, "Ortam" açılır menüsünü kullanarak "Enjekte Edilen Sağlayıcı - MetaMask"ı seçin.
+
+
+
+Cüzdanınızı bağlayın ve Scroll Sepolia Test ağını seçin. Hesabınız Remix'te otomatik olarak seçilmelidir ve "Dağıt"a tıklayabilirsiniz.
+
+### Truffle
+
+Zaten bir Truffle ortamı kurulumunuz olduğunu varsayarak Truffle [yapılandırma dosyasına](https://trufflesuite.com/docs/truffle/reference/configuration/), `truffle.js`ye gidin. HDWalletProvider'ı yüklediğinizden emin olun: `npm install @truffle/hdwallet-provider@1.4.0`
+
+```js
+const HDWalletProvider = require("@truffle/hdwallet-provider")
+...
+module.exports = {
+ networks: {
+ scrollSepolia: {
+ provider: () =>
+ new HDWalletProvider(process.env.PRIVATE_KEY, "https://sepolia-rpc.scroll.io/"),
+ network_id: '*',
+ },
+ }
+}
+```
+
+### Brownie
+
+Scroll Sepolia Test ağını eklemek için aşağıdaki komutu çalıştırın:
+
+```bash
+brownie networks add Ethereum scrollSepolia host=https://sepolia-rpc.scroll.io/ chainid=534351
+```
+
+Bunu varsayılan ağınız olarak ayarlamak için proje yapılandırma dosyanıza aşağıdakileri ekleyin:
+
+```yaml
+networks:
+ default: scrollSepolia
+```
+
+Scroll Sepolia Test ağını eklemenin başka bir yolu da bir 'yaml' dosyası oluşturmak ve onu eklemek için bir komut çalıştırmaktır.
+
+'network-config.yaml' adlı bir yaml dosyası örneği vermek gerekirse:
+
+```yaml
+live:
+- name: Ethereum
+ networks:
+ - chainid: 534351
+ explorer: https://sepolia.scrollscan.com/
+ host: https://sepolia-rpc.scroll.io
+ id: scrollSepolia
+ name: Scroll Sepolia Testnet
+```
+
+Scroll Sepolia Test ağını ağ listesine eklemek için aşağıdaki komutu çalıştırın:
+
+```bash
+brownie networks import ./network-config.yaml
+```
+
+Scroll'da dağıtmak için aşağıdaki komutu çalıştırın. Bu örnekte "token.py" akıllı sözleşmeyi dağıtan bir komut dosyasıdır. Bunu kendi komut dosyanızın adıyla değiştirin:
+
+```bash
+brownie run token.py --network scrollSepolia
+```
+
+### ethers.js
+
+Bir 'ethers' komut dosyasında Scroll Sepolia Test ağı sağlayıcısının kurulması:
+
+```jsx
+import { ethers } from "ethers"
+
+const provider = new ethers.providers.JsonRpcProvider("https://sepolia-rpc.scroll.io/")
+```
+
+### scaffold-eth
+
+Scaffold-eth'i kullanarak dağıtım yapmak için hem Hardhat hem de React ayarlarınızı Scroll Sepolia Test ağına yönlendirmeniz gerekir.
+
+#### Hardhat'i Yapılandırma
+
+'packages/hardhat/hardhat.config.js' dosyasına ağın eklenerek varsayılan ağ olarak seçilmesi gerekmektedir.
+
+```jsx
+...
+//
+// Burada dağıtmak istediğiniz ağı seçin:
+//
+const defaultNetwork = "scrollSepolia";
+...
+module.exports = {
+...
+ networks: {
+...
+ scrollSepolia: {
+ url: "https://sepolia-rpc.scroll.io/",
+ accounts: {
+ mnemonic: mnemonic(),
+ },
+ },
+ }
+...
+}
+```
+
+Dağıtım cüzdanına da fon sağladığınızdan emin olun! Cüzdanı oluşturmak için "yarn generate"i, fonlarını kontrol etmek için "yarn account"u çalıştırın. Fonlama sağlandıktan sonra Scroll Sepolia test ağına dağıtmak için `yarn deploy --network ScrollSepolia` komutunu çalıştırın.
+
+
+
+#### Kullanıcı Arayüzü Yapılandırması
+
+Kullanıcı arayüzünüzü yapılandırmak için Scroll Sepolia Test ağını bir ağ seçeneği olarak eklemeniz ve ardından bunu varsayılan olarak seçmeniz gerekir.
+
+Ağı eklemek için 'packages/react-app/src/constants.js' dosyasını değiştirin.
+
+```jsx
+...
+export const NETWORKS = {
+...
+ scrollSepolia: {
+ name: "scrollSepolia",
+ color: "#e9d0b8",
+ chainId: 534351,
+ rpcUrl: "https://sepolia-rpc.scroll.io/",
+ blockExplorer: "https://sepolia.scrollscan.com",
+ },
+...
+}
+```
+
+Daha sonra, 'packages/react-app/src/App.jsx' bölümünde değişiklik yapın
+
+```jsx
+...
+/// 📡 Sözleşmeleriniz hangi zincire dağıtıldı?
+const initialNetwork = NETWORKS.scrollSepolia;
+...
+```
diff --git a/src/content/docs/tr/developers/ethereum-and-scroll-differences.mdx b/src/content/docs/tr/developers/ethereum-and-scroll-differences.mdx
new file mode 100644
index 000000000..8ee8844bf
--- /dev/null
+++ b/src/content/docs/tr/developers/ethereum-and-scroll-differences.mdx
@@ -0,0 +1,97 @@
+---
+section: developers
+date: Last Modified
+title: "Ethereum ve Scroll Farkları"
+lang: "tr"
+permalink: "developers/ethereum-and-scroll-differences"
+whatsnext: { "L1 & L2 Köprüleme": "/tr/developers/l1-and-l2-bridging/" }
+excerpt: "Ethereum ana ağının EVM'si ile Scroll'un zkEVM için değiştirmiş olduğu tasarımı arasında farklılık gösteren bir dizi teknik ayrıntı vardır. Aşağıda bu farklılıkları şu anda mevcut oldukları haliyle görebilirsiniz."
+---
+
+import Aside from "../../../../components/Aside.astro"
+
+Ethereum ana ağının EVM'i ile Scroll'un zkEVM için değiştirmiş olduğu tasarımı arasında bir dizi teknik ayrıntı farklılık göstermektedir. Aşağıda Scroll ve Scroll Sepolia'da mevcut olan bu farklılıkları görebilirsiniz.
+
+Açık kaynak katkıda bulunanlar ve altyapı oluşturucular, daha fazla destek için lütfen ekibimizle iletişime geçin.
+
+
+
+## EVM Opcode'ları
+
+| Opcode | Solidity dengi | Scroll Davranışı |
+| --------------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------- |
+| `BLOCKHASH` | `block.blockhash` | Son 256 blok için `keccak(chain_id \|\| block_number)'ı döndürür. |
+| `COINBASE` | `block.coinbase` | Önceden dağıtılan ücret kasası sözleşme adresini döndürür. Bkz. [Scroll Sözleşmeleri](/tr/developers/scroll-contracts). |
+| `DIFFICULTY` / `PREVRANDAO` | `block.difficulty` | 0 değerini döndürür. |
+| `BASEFEE` | `block.basefee` | Devre dışı.[^eip1559] Opcode ile karşılaşılırsa işlem geri alınacaktır. |
+| `SELFDESTRUCT` | `selfdestruct` | Engelli. Opcode ile karşılaşılırsa işlem geri döndürülecektir.[^willadpot] |
+
+[^eip1559]: Şu anda Scroll'da EIP-1559'u devre dışı bıraktık.
+[^willadpot]: Gelecekte Ethereum'un çözümünü benimsemek için değişecek.
+
+## EVM Ön Derlemeleri
+
+'SHA2-256' (adress '0x2'), 'RIPEMD-160' (adress '0x3') ve 'blake2f' (adress '0x9') ön derlemeleri şu anda desteklenmemektedir. Bu ön derlenmiş sözleşmelere yapılan çağrılar geri alınacaktır. Bu üç ön derlemeyi gelecekteki bir hard fork'ta etkinleştirmeyi planlıyoruz.
+
+'Modexp' ön derlemesi destekleniyor ancak yalnızca 32 bytea eşit veya daha küçük boyuttaki girişleri destekliyor (ör. 'u256').
+
+'ecPairing' ön derlemesi destekleniyor, fakat nokta sayısı (kümeler, çiftler) 6 yerine 4 ile sınırlıdır.
+
+Diğer EVM ön derlemelerinin tümü desteklenir: `ecRecover`, `identity`, `ecAdd`, `ecMul`.
+
+## Durum Hesabı
+
+### **İlave Alanlar**
+
+Mevcut `StateAccount` nesnesine iki alan ekledik: `PoseidonCodehash` ve `CodeSize`.
+
+```go
+type StateAccount struct {
+ Nonce uint64
+ Balance *big.Int
+ Root common.Hash // merkle root of the storage trie
+ KeccakCodeHash []byte // still the Keccak codehash
+ // added fields
+ PoseidonCodeHash []byte // the Poseidon codehash
+ CodeSize uint64
+}
+```
+
+### **CodeHash**
+
+Bununla ilgili olarak, her sözleşme bytecode'u için iki tür kod hash'i sağlarız: Keccak hash'i ve Poseidon hash'i.
+
+'KeccakCodeHash', 'EXTCODEHASH' uyumluluğunu korumak için tutulur. Poseidon hash işleminin çok daha verimli olduğu zkEVM'ye yüklenen bytecodeların doğruluğunu doğrulamak için "PoseidonCodeHash" kullanılır.
+
+### CodeSize
+
+'EXTCODESIZE' doğrulanırken tüm sözleşme verilerinin zkEVM'ye yüklenmesi pahalıdır. Bunun yerine sözleşme boyutunu sözleşme oluşturma sırasında depolama alanında saklıyoruz. Bu şekilde kodu yüklememize gerek kalmaz; bu opcode'u doğrulamak için bir depolama kanıtı yeterlidir.
+
+## Blok Zamanı
+
+Scroll, 3 saniyelik sabit bir blok süresini hedefler. Bu, ideal koşullar altında Ethereum'da kullanılan 12 saniyeden daha kısa ve daha tutarlıdır.
+
+Blok süresinin bu şekilde seçilmesinin iki nedeni var:
+
+- Daha hızlı ve sabit blok süresine sahip olmak, daha hızlı geri bildirim ve daha iyi bir kullanıcı deneyimi sağlar.
+- Test ağlarımızdaki zkEVM devrelerini optimize ederken, blok veya parti başına daha küçük bir gas limitini korusak bile, yine de Ethereum'dan daha yüksek verime ulaşabiliriz.
+
+## Gelecekteki EIP'ler
+
+Ethereum tarafından benimsenen tüm yeni EIP'leri yakından takip ediyoruz ve uygun olduğunda bunları benimsiyoruz. Daha fazla ayrıntıyla ilgileniyorsanız, [topluluk forumumuzdan](https://community.scroll.io) veya [Scroll Discord'dan](https://discord.gg/scroll) bize ulaşın.
+
+## İşlem ücretleri
+
+Scroll işlemlerinden alınan ücret iki bölümden oluşur:
+
+- **L2 gaz ücreti:** L1'e benzer şekilde, L2 işlem ücreti miktarı "L2_gas_price * L2_gas_used" değerine eşittir ve aşağıdaki maliyetleri kapsar:
+ - L2 sıralayıcı yürütme ve depolama maliyeti
+ - L1'de geçerlilik kanıtı doğrulama ve sonuçlandırma maliyeti
+ - Kanıtlayıcı maliyeti
+- **L1 veri ücreti:** L2 gaz ücretine ek olarak ek ücret. L1 veri ücreti yalnızca L2 tarafından başlatılan işlemlerden alınır, L1 tarafından başlatılan işlemlerden alınmaz. Ücret, veri kullanılabilirliği için L1'e veri gönderme maliyetini kapsar. Tx verilerini L1'e yuvarladığımız için L1 rollup ücreti, tx verilerinin boyutuna göre hesaplanır.
+
+Daha fazla bilgi için, bkz. [Scroll'da İşlem Ücretleri](/tr/developers/transaction-fees-on-scroll).
+
+---
diff --git a/src/content/docs/tr/developers/guides/bridge-erc20-through-the-custom-gateway.mdx b/src/content/docs/tr/developers/guides/bridge-erc20-through-the-custom-gateway.mdx
new file mode 100644
index 000000000..58c8239c0
--- /dev/null
+++ b/src/content/docs/tr/developers/guides/bridge-erc20-through-the-custom-gateway.mdx
@@ -0,0 +1,452 @@
+---
+section: developers
+date: Last Modified
+title: "Özel Ağ Geçidi üzerinden ERC20 köprüleyin"
+lang: "tr"
+permalink: "developers/guides/bridge-erc20-through-the-custom-gateway"
+excerpt: "Bu kılavuz, Özel Ağ Geçidini kullanarak özel işlevlere ihtiyaç duyan ERC20'ler için Scroll köprüsünün nasıl kullanılacağını açıklayacaktır."
+---
+
+
+import Aside from "../../../../../components/Aside.astro"
+
+
+Bu kılavuz, Özel Ağ Geçidini kullanarak özel işlevlere ihtiyaç duyan ERC20'ler için Scroll köprüsünün nasıl kullanılacağını açıklayacaktır.
+
+
+
+
+
+## 1. Adım: Sepolia'da bir token başlatın
+
+
+Öncelikle köprüleyecek bir tokena ihtiyacımız var. Bir tokenın L2 ile uyumlu olması için belirli bir ERC20 uygulamasına gerek yoktur. Zaten bir tokenınız varsa bu adımı atlayabilirsiniz. Yeni bir token dağıtmak istiyorsanız, başlatıldığında dağıtıcıya 1 milyon token basan basit bir ERC20 tokenının aşağıdaki sözleşmesini kullanın.
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+
+contract L1Token is ERC20 {
+ constructor() ERC20("My Token L1", "MTL1") {
+ _mint(msg.sender, 1_000_000 ether);
+ }
+}
+```
+
+
+## Adım 2: Scroll Sepolia test ağında muadil tokenı başlatın
+
+
+Sıradaki adımda, Sepolia'daki orijinal tokenı temsil edecek olan bir karşılık tokenını Scroll üzerinde başlatacaksınız. Bu token, L1 tokenınınkiyle eşleşmek için özel mantık uygulayabilir hatta L1 tokenının ötesinde ek özellikler ekleyebilir.
+
+
+Bunun çalışması için:
+
+
+- Tokenın köprüyle uyumlu olabilmesi için "IScrollStandardERC20" arayüzünü uygulaması gerekir.
+- Sözleşme, "gateway()" ve "counterpart()" fonksiyonları altında ağ geçidi adresini ve karşılık gelen token adreslerini (yeni başlattığımız L1 token) sağlamalıdır. Ayrıca L2 ağ geçidinin, bir token yatırıldığında ve çekildiğinde 'mint()' ve 'burn()' işlevlerini çağırmasına da izin vermelidir.
+
+
+Aşağıda köprüyle uyumlu bir tokenın tam bir örneği bulunmaktadır. Yapıcıya(constructor) resmi Scroll Özel Ağ Geçidi adresini (`0x058dec71E53079F9ED053F3a0bBca877F6f3eAcf`) ve Sepolia'da oluşturulan tokenın adresini ileteceksiniz.
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@scroll-tech/contracts@0.1.0/libraries/token/IScrollERC20Extension.sol";
+
+
+contract L2Token is ERC20, IScrollERC20Extension {
+ // We store the gateway and the L1 token address to provide the gateway() and counterpart() functions which are needed from the Scroll Standard ERC20 interface
+ address _gateway;
+ address _counterpart;
+
+
+ // In the constructor we pass as parameter the Custom L2 Gateway and the L1 token address as parameters
+ constructor(address gateway_, address counterpart_) ERC20("My Token L2", "MTL2") {
+ _gateway = gateway_;
+ _counterpart = counterpart_;
+ }
+
+
+ function gateway() public view returns (address) {
+ return _gateway;
+ }
+
+
+ function counterpart() external view returns (address) {
+ return _counterpart;
+ }
+
+
+ // We allow minting only to the Gateway so it can mint new tokens when bridged from L1
+ function transferAndCall(address receiver, uint256 amount, bytes calldata data) external returns (bool success) {
+ transfer(receiver, amount);
+ data;
+ return true;
+ }
+
+
+ // We allow minting only to the Gateway so it can mint new tokens when bridged from L1
+ function mint(address _to, uint256 _amount) external onlyGateway {
+ _mint(_to, _amount);
+ }
+
+
+ // Similarly to minting, the Gateway is able to burn tokens when bridged from L2 to L1
+ function burn(address _from, uint256 _amount) external onlyGateway {
+ _burn(_from, _amount);
+ }
+
+
+ modifier onlyGateway() {
+ require(gateway() == _msgSender(), "Ownable: caller is not the gateway");
+ _;
+ }
+}
+```
+
+
+## Adım 3: Token'ı Scroll Köprüsü'ne ekleyin
+
+
+Token'ı Scroll'daki "L2CustomERC20Gateway" sözleşmesine ve L1'deki "L1CustomERC20Gateway" sözleşmesine eklemek için Scroll ekibiyle iletişime geçmeniz gerekiyor. Ayrıca tokenınızı Scroll resmi köprü kullanıcı arayüzüne eklemek için [token listeleri](https://github.com/scroll-tech/token-list) deposundaki talimatları izleyin.
+
+
+## Adım 4: Tokenları yatırın
+
+
+Tokenınız Scroll ekibi tarafından onaylandıktan sonra L1'den token yatırabilirsiniz. Bunu yapmak için öncelikle Sepolia'daki 'L1CustomGateway' sözleşme adresine onay vermeniz gerekir ('0x31C994F2017E71b82fd4D8118F140c81215bbb37'). Ardından, 'L1CustomGateway' sözleşmesindeki 'depositERC20' fonksiyonunu çağırarak tokenları yatırın. Bu, [köprü kullanıcı arayüzümüz](https://scroll.io/bridge), [Etherscan Sepolia](https://sepolia.etherscan.io/address/0x31C994F2017E71b82fd4D8118F140c81215bbb37#writeProxyContract) veya bir akıllı sözleşme kullanılarak yapılabilir.
+
+
+## Adım 5: Tokenları çekin
+
+
+Tokenları L2'den L1'e geri göndermek için benzer adımları izleyeceksiniz. Öncelikle, 'L2CustomGateway' adresine ('0x058dec71E53079F9ED053F3a0bBca877F6f3eAcf') onay verin ve ardından 'L2CustomGateway' sözleşmesinden 'drawERC20'yi çağırarak tokenları çekin.
+
+
+## Alternatif Yaklaşım: Özel bir L1 Ağ Geçidi sözleşmesi başlatın ve ayarlayın
+
+
+Tokenları Scroll'a ve Scroll'dan köprülemek için önerilen yöntem (yukarıda açıklandığı gibi) tokenınızı Scroll resmi köprüsüne eklemektir. Bu yaklaşım, onların daha kolay bulunmasını sağlayacak ve sahipleri için daha güvenli olmalarını sağlayacaktır. Ancak bunun için Scroll ekibinin onayı gereklidir. Resmi onay süreci olmadan özel bir token başlatmak istiyorsanız kendiniz özel bir ağ geçidi oluşturabilirsiniz. Bunu yapmak için L1'de bir "L1CustomERC20Gateway" sözleşmesi ve L2'de bir "L2CustomERC20Gateway" dağıtmanız gerekecektir.
+
+
+### Özel bir L1 Ağ Geçidi başlatın
+
+
+Sepolia'da aşağıdaki sözleşmeyi başlatarak işe koyulalım.
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+
+
+// Although it's possible to use other Solidity versions, we recommend using version 0.8.16 because that's where our contracts were audited
+pragma solidity =0.8.16;
+
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+
+import { IL2ERC20Gateway } from "@scroll-tech/contracts@0.1.0/L2/gateways/IL2ERC20Gateway.sol";
+import { IL1ScrollMessenger } from "@scroll-tech/contracts@0.1.0/L1/IL1ScrollMessenger.sol";
+import { IL1ERC20Gateway } from "@scroll-tech/contracts@0.1.0/L1/gateways/IL1ERC20Gateway.sol";
+
+
+import { ScrollGatewayBase } from "@scroll-tech/contracts@0.1.0/libraries/gateway/ScrollGatewayBase.sol";
+import { L1ERC20Gateway } from "@scroll-tech/contracts@0.1.0/L1/gateways/L1ERC20Gateway.sol";
+
+
+// This contract will be used to send and receive tokens from L2
+contract L1CustomERC20Gateway is L1ERC20Gateway, Ownable {
+ // Tokens must be mapped to "bind" them to a token that represents the original token on the original. This event will be emitted when the token mapping for ERC20 token is updated.
+ event UpdateTokenMapping(address indexed l1Token, address indexed oldL2Token, address indexed newL2Token);
+
+
+ mapping(address => address) public tokenMapping;
+
+
+ constructor() {}
+
+
+ // This function must be called once after both the L1 and L2 contract was deployed
+ function initialize(address _counterpart, address _router, address _messenger) external {
+ require(_router != address(0), "zero router address");
+
+
+ ScrollGatewayBase._initialize(_counterpart, _router, _messenger);
+ }
+
+
+ /// This function returns the address of the token on L2
+ function getL2ERC20Address(address _l1Token) public view override returns (address) {
+ return tokenMapping[_l1Token];
+ }
+
+
+ // Updates the token mapping that "binds" a token with another one on the other chain
+ function updateTokenMapping(address _l1Token, address _l2Token) external onlyOwner {
+ require(_l2Token != address(0), "token address cannot be 0");
+
+
+ address _oldL2Token = tokenMapping[_l1Token];
+ tokenMapping[_l1Token] = _l2Token;
+
+
+ emit UpdateTokenMapping(_l1Token, _oldL2Token, _l2Token);
+ }
+
+
+ // Callback called before a token is withdrawn on L1
+ function _beforeFinalizeWithdrawERC20(
+ address _l1Token,
+ address _l2Token,
+ address,
+ address,
+ uint256,
+ bytes calldata
+ ) internal virtual override {
+ require(msg.value == 0, "nonzero msg.value");
+ require(_l2Token != address(0), "token address cannot be 0");
+ require(_l2Token == tokenMapping[_l1Token], "l2 token mismatch");
+ }
+
+
+ // Token bridged can be "canceled" or dropped. This callback is called before that happens.
+ function _beforeDropMessage(address, address, uint256) internal virtual override {
+ require(msg.value == 0, "nonzero msg.value");
+ }
+
+
+ // Internal function holding the deposit logic
+ function _deposit(
+ address _token,
+ address _to,
+ uint256 _amount,
+ bytes memory _data,
+ uint256 _gasLimit
+ ) internal virtual override nonReentrant {
+ address _l2Token = tokenMapping[_token];
+ require(_l2Token != address(0), "no corresponding l2 token");
+
+
+ // 1. Transfer token into this contract.
+ address _from;
+ (_from, _amount, _data) = _transferERC20In(_token, _amount, _data);
+
+
+ // 2. Generate message passed to L2CustomERC20Gateway.
+ bytes memory _message = abi.encodeCall(
+ IL2ERC20Gateway.finalizeDepositERC20,
+ (_token, _l2Token, _from, _to, _amount, _data)
+ );
+
+
+ // 3. Send message to L1ScrollMessenger.
+ IL1ScrollMessenger(messenger).sendMessage{ value: msg.value }(counterpart, 0, _message, _gasLimit, _from);
+
+
+ emit DepositERC20(_token, _l2Token, _from, _to, _amount, _data);
+ }
+}
+```
+
+
+### Özel bir L2 Ağ Geçidi başlatın
+
+
+Şimdi Scroll'da muadil sözleşmeyi başlatalım.
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+
+
+pragma solidity =0.8.16;
+
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+
+import "@scroll-tech/contracts@0.1.0/L2/gateways/L2ERC20Gateway.sol";
+import { IL2ScrollMessenger } from "@scroll-tech/contracts@0.1.0/L2/IL2ScrollMessenger.sol";
+import { IL1ERC20Gateway } from "@scroll-tech/contracts@0.1.0/L1/gateways/IL1ERC20Gateway.sol";
+import { ScrollGatewayBase } from "@scroll-tech/contracts@0.1.0/libraries/gateway/ScrollGatewayBase.sol";
+import "@scroll-tech/contracts@0.1.0/libraries/token/IScrollERC20Extension.sol";
+
+
+import { IL2ERC20Gateway } from "@scroll-tech/contracts@0.1.0/L2/gateways/IL2ERC20Gateway.sol";
+
+
+// This contract will be used to send and receive tokens from L1
+contract L2CustomERC20Gateway is L2ERC20Gateway, ScrollGatewayBase, Ownable {
+ event UpdateTokenMapping(address indexed l2Token, address indexed oldL1Token, address indexed newL1Token);
+
+
+ // solhint-disable-next-line var-name-mixedcase
+ mapping(address => address) public tokenMapping;
+
+
+ constructor() {}
+
+
+ // Like with the L1 version of the Gateway, this must be called once after both the L1 and L2 gateways are deployed
+ function initialize(address _counterpart, address _router, address _messenger) external {
+ require(_router != address(0), "zero router address");
+
+
+ ScrollGatewayBase._initialize(_counterpart, _router, _messenger);
+ }
+
+
+ /// Returns the address of the token representing the token on L2
+ function getL1ERC20Address(address _l2Token) external view override returns (address) {
+ return tokenMapping[_l2Token];
+ }
+
+
+ // This returns the L2 token address
+ function getL2ERC20Address(address) public pure override returns (address) {
+ revert("unimplemented");
+ }
+
+
+ // This function finalizes the token deposit on L2 when the deposit was not finalized due to not enough gas sent from L1
+ function finalizeDepositERC20(
+ address _l1Token,
+ address _l2Token,
+ address _from,
+ address _to,
+ uint256 _amount,
+ bytes calldata _data
+ ) external payable override onlyCallByCounterpart nonReentrant {
+ require(msg.value == 0, "nonzero msg.value");
+ require(_l1Token != address(0), "token address cannot be 0");
+ require(_l1Token == tokenMapping[_l2Token], "l1 token mismatch");
+
+
+ IScrollERC20Extension(_l2Token).mint(_to, _amount);
+
+
+ _doCallback(_to, _data);
+
+
+ emit FinalizeDepositERC20(_l1Token, _l2Token, _from, _to, _amount, _data);
+ }
+
+
+ // Same as in the L1 version of this contract, this function "binds" a token with a token on the other chain
+ function updateTokenMapping(address _l2Token, address _l1Token) external onlyOwner {
+ require(_l1Token != address(0), "token address cannot be 0");
+
+
+ address _oldL1Token = tokenMapping[_l2Token];
+ tokenMapping[_l2Token] = _l1Token;
+
+
+ emit UpdateTokenMapping(_l2Token, _oldL1Token, _l1Token);
+ }
+
+
+ // Internal function holding the withdraw logic
+ function _withdraw(
+ address _token,
+ address _to,
+ uint256 _amount,
+ bytes memory _data,
+ uint256 _gasLimit
+ ) internal virtual override nonReentrant {
+ address _l1Token = tokenMapping[_token];
+ require(_l1Token != address(0), "no corresponding l1 token");
+
+
+ require(_amount > 0, "withdraw zero amount");
+
+
+ // 1. Extract real sender if this call is from L2GatewayRouter.
+ address _from = msg.sender;
+ if (router == msg.sender) {
+ (_from, _data) = abi.decode(_data, (address, bytes));
+ }
+
+
+ // 2. Burn token.
+ IScrollERC20Extension(_token).burn(_from, _amount);
+
+
+ // 3. Generate message passed to L1StandardERC20Gateway.
+ bytes memory _message = abi.encodeCall(
+ IL1ERC20Gateway.finalizeWithdrawERC20,
+ (_l1Token, _token, _from, _to, _amount, _data)
+ );
+
+
+ // 4. send message to L2ScrollMessenger
+ IL2ScrollMessenger(messenger).sendMessage{ value: msg.value }(counterpart, 0, _message, _gasLimit);
+
+
+ emit WithdrawERC20(_l1Token, _token, _from, _to, _amount, _data);
+ }
+}
+```
+
+
+### Sepolia'da Ağ Geçidi sözleşmenizi kurun
+
+
+Sözleşmeler dağıtıldıktan sonra, sözleşmeleri başlatmak ve bunları karşılık gelen tokenlara ve köprünün diğer tarafındaki ağ geçidine bağlamak için aşağıdaki işlevleri çağırın.
+
+
+İlk olarak, aşağıdaki parametrelerle 'MyL1Gateway' sözleşmesindeki 'initialize' fonksiyonunu çağırın:
+
+
+- `_counterpart`: Scroll'da yeni başlattığımız `MyL2Gateway`in adresi.
+- `_router`: Sepolia'daki `L1GatewayRouter` sözleşmesi olan `0x13FBE0D0e5552b8c9c4AE9e2435F38f37355998a` olarak ayarlayın.
+- `_messenger`: Sepolia'daki `L1ScrollMessenger` sözleşmesi olan `0x50c7d3e7f7c656493D1D76aaa1a836CedfCBB16A` olarak ayarlayın.
+
+
+Özel bir ağ geçidi birden fazla token köprüsüne ev sahipliği yapabilir. Ama biz örneğimizde, 'MyL1Gateway' sözleşmesindeki 'updateTokenMapping''i aşağıdaki parametrelerle çağırarak yalnızca L1Token ve L2Token arasında köprü kurulmasına izin vereceğiz:
+
+
+- `_l1Token`: Daha önce Sepolia'da başlattığımız `L1Token` sözleşmesinin adresi.
+- `_l2Token`: Daha önce Scroll'da başlattığımız `L2Token` sözleşmesinin adresi.
+
+
+### Scroll'da Ağ Geçidi sözleşmenizi kurun
+
+
+Şimdi Scroll zincirine geçelim ve benzer adımları izleyerek `MyL2Gateway`i başlatalım.
+
+
+İlk olarak, `MyL2Gateway`den `initialize` fonksiyonunu çağırın:
+
+
+- `_counterpart`: Sepolia'da yeni başlattığımız `MyL1Gateway`in adresi.
+- `_router`: Scroll'daki `L2GatewayRouter` sözleşmesi olan `0x9aD3c5617eCAa556d6E166787A97081907171230` olarak ayarlayın.
+- `_messenger`: Scroll'daki `L2ScrollMessenger` sözleşmesi olan `0xBa50f5340FB9F3Bd074bD638c9BE13eCB36E603d`yi ayarlayın.
+
+
+Daha sonra, 'MyL2Gateway' sözleşmesinde 'updateTokenMapping'i çağırın:
+
+
+- `_l2Token`: Daha önce Scroll'da başlattığımız `L2Token` sözleşmesinin adresi.
+- `_l1Token`: Daha önce Sepolia'da başlattığımız `L1Token` sözleşmesinin adresi.
+
+
+### Tokenları köprüleme
+
+
+Artık tıpkı resmi Scroll köprüsünde olduğu gibi "MyL1Gateway"den "depositERC20"yi ve "MyL2Gateway"den "withdrawERC20"yi çağırabiliriz.
+
+
+
diff --git a/src/content/docs/tr/developers/guides/contract-deployment-tutorial.mdx b/src/content/docs/tr/developers/guides/contract-deployment-tutorial.mdx
new file mode 100644
index 000000000..fb0e2a2ab
--- /dev/null
+++ b/src/content/docs/tr/developers/guides/contract-deployment-tutorial.mdx
@@ -0,0 +1,108 @@
+---
+section: developers
+date: Last Modified
+title: "Sözleşme Dağıtımı Eğitimi"
+lang: "tr"
+permalink: "developers/guides/contract-deployment-tutorial"
+excerpt: "Scroll Sepolia Test ağı, topluluğun Scroll üzerinde akıllı sözleşmeler dağıtmasına olanak tanır. Bu eğitimde size Scroll Sepolia'da bir sözleşmenin nasıl dağıtılacağını öğreteceğiz."
+whatsnext: { "Scroll Messenger ile Zincirler Arası Etkileşim": "/tr/developers/guides/scroll-messenger-cross-chain-interaction/" }
+---
+
+
+import Aside from "../../../../../components/Aside.astro"
+
+
+Scroll Sepolia Test ağı, herkesin Scroll üzerinde akıllı sözleşme dağıtmasına olanak tanır. Bu eğitimde, Ethereum'da geliştirmeye yönelik ortak araçları kullanarak Scroll Sepolia'da bir sözleşmenin nasıl dağıtılacağını öğreneceksiniz. Bu [demo deposu](https://github.com/scroll-tech/scroll-guides/tree/main/contract-deploy-demo), [Hardhat](https://hardhat.org/) ve [Foundry](https://github.com/foundry-rs/foundry) ile sözleşme dağıtımını gösterir.
+
+
+
+
+
+## Hardhat ile sözleşmeleri dağıtın
+
+
+1. Henüz yapmadıysanız [nodejs](https://nodejs.org/en/download/) ve [yarn](https://classic.yarnpkg.com/lang/en/docs/install) yükleyin .
+2. Depoyu klonlayın ve gereksinimleri yükleyin:
+
+
+ ```shell
+ git clone https://github.com/scroll-tech/scroll-guides.git
+ cd scroll-guides/contract-deploy-demo
+ yarn install
+ ```
+
+
+3. Kök dizinde `.env.example` örneğini takip ederek bir `.env` dosyası oluşturun. `PRIVATE_KEY`i `.env`de kendi hesabınızın özel anahtarıyla değiştirin.
+
+
+4. Sözleşmeyi derlemek için 'yarn compile'ı çalıştırın.
+
+
+5. Sözleşmeyi Scroll Sepolia Test ağında dağıtmak için `yarn deploy:scrollTestnet'i çalıştırın.
+
+
+6. Hardhat testleri için "yarn test"'i çalıştırın.
+
+
+## Foundry ile sözleşmeleri dağıtın
+
+
+1. Depoyu klonlayın:
+
+
+ ```shell
+ git clone https://github.com/scroll-tech/scroll-guides.git
+ cd scroll-guides/contract-deploy-demo
+ ```
+
+
+2. Foundry'yi kurun:
+
+
+ ```shell
+ curl -L https://foundry.paradigm.xyz | bash
+ foundryup
+ ```
+
+
+3. Projeyi oluşturmak için 'forge build'i çalıştırın.
+
+
+4. Foundry ile sözleşmenizi dağıtın:
+
+
+ ```bash
+ forge create --rpc-url https://sepolia-rpc.scroll.io/ \
+ --value \
+ --constructor-args \
+ --private-key \
+ --legacy \
+ contracts/Lock.sol:Lock
+ ```
+
+
+ - ``, sözleşmede kilitlenecek test `ETH` miktarıdır. Bunu "0,0000001ether" gibi küçük bir miktara ayarlamayı deneyin.
+ - ``, sözleşmede kilitlenen fonların çekilmeye hazır olacağı Unix zaman damgasıdır. Bunu gelecekte "1696118400" gibi bir Unix zaman damgasına ayarlamayı deneyin (bu Unix zaman damgası 1 Ekim 2023'e karşılık gelir).
+
+
+ Örneğin:
+
+
+ ```bash
+ forge create --rpc-url https://sepolia-rpc.scroll.io/ \
+ --value 0.00000000002ether \
+ --constructor-args 1696118400 \
+ --private-key 0xabc123abc123abc123abc123abc123abc123abc123abc123abc123abc123abc1 \
+ --legacy contracts/Lock.sol:Lock
+ ```
+
+
+## Sorular ve Geri Bildirim
+
+
+Scroll Sepolia Test ağına katıldığınız ve geliştirdiğiniz için teşekkür ederiz! Herhangi bir sorunla karşılaşırsanız [Discord'umuza](https://discord.gg/scroll) katılın ve "#testnet-devs" kanalından bize sorun.
+
+
+
diff --git a/src/content/docs/tr/developers/guides/estimating-gas-and-tx-fees.mdx b/src/content/docs/tr/developers/guides/estimating-gas-and-tx-fees.mdx
new file mode 100644
index 000000000..53d89b255
--- /dev/null
+++ b/src/content/docs/tr/developers/guides/estimating-gas-and-tx-fees.mdx
@@ -0,0 +1,301 @@
+---
+section: developers
+date: Last Modified
+title: "Gas ve İşlem Ücretlerinin Tahmin Edilmesi"
+lang: "tr"
+permalink: "developers/guides/estimating-gas-and-transaction-fees"
+excerpt: "Scroll bir L2 rollup olduğundan, işlem yaşam döngüsünün bir kısmı güvenlik için bazı verileri L1'e iletir. Bunun bedelini ödemek için tüm işlemlere L1 ücreti adı verilen ek bir ücret uygulanır."
+---
+
+
+import Aside from "../../../../../components/Aside.astro"
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import txFeesProjectStructure from "../../../../../assets/images/developers/txFeesProjectStructure.png"
+
+
+{/* TODO: Update for Sepolia, test and publish to sidebar. */}
+
+
+:::warning[Bu makale güncelliğini yitirmiştir.]
+Bu sayfa güncellenmedi ve en son Scroll Sepolia sürümüne göre test edilmedi. Lütfen dikkatli kullanın.
+:::
+
+
+Since Scroll is an L2 rollup, part of the transaction lifecycle is committing some data to L1 for security. To pay for this, all transaction incurs an additional fee called the _L1 fee_.
+
+
+In this guide, we will go over how to estimate the L1 fee on Scroll and calculate final transaction fee estimations through a hands-on code example you can find [here](https://github.com/scroll-tech/scroll-guides/tree/main/gas-estimation-demo).
+
+
+## The formula
+
+
+In short, the transaction fee on Scroll, at any given moment, can be calculated as
+
+
+```
+totalFee = (l2GasPrice * l2GasUsed) + l1Fee
+```
+
+
+An important distinction we need to make is that `l1Fee` is separated from the `l2Fee`.
+
+
+For a more comprehensive explanation and details on the formula, check the documentation on [how Transaction Fees work on Scroll](../developers/transaction-fees-on-scroll-l2/).
+
+
+## Interfacing with values
+
+
+To fetch these values and calculate the final fee, we’ll interact with Scroll’s public RPC and pre-deployed Smart Contract `L1GasOracle.sol`, deployed at [`0x5300000000000000000000000000000000000002`](https://scrollscan.com/address/0x5300000000000000000000000000000000000002).
+
+
+For our example codebase, we make a Hardhat project and fetch values using the [Ethers.js](https://docs.ethers.org/v6/) library.
+
+
+`l2GasUsed` - We get this using the [estimateGas](https://docs.ethers.org/v6/api/providers/#Provider-estimateGas) method, which queries our RPC with the TX data to get an estimate of the gas to be used.
+
+
+`l2GasPrice` - For this, we’ll use the [getFeeData](https://docs.ethers.org/v6/api/providers/#Provider-getFeeData) method, which will get the current market conditions on the L2
+
+
+The Gas Oracle smart contract exposes multiple key fields we need to figure out the cost of the transaction. `overhead()` , `scalar()` , `l1BaseFee()` and `getL1GasUsed(bytes memory data)`
+
+
+But it also exposes the `getL1Fee(bytes memory data)` function, which abstracts all these complexities and allows us to get the fee in just one function call.
+
+
+## Hands-on example
+
+
+### Project structure
+
+
+First of all, let’s quickly go over the key folders inside our project structure.
+
+
+It’s a standard Hardhat project, but most of our work is inside the *contracts* and _scripts_ folders.
+
+
+
+
+
+
+
+
+### The smart contract
+
+
+First, we need a Smart Contract to interact with to showcase the gas estimation. For that, we’ll create a `ExampleContract.sol`.
+
+
+```solidity
+pragma solidity ^0.8.17;
+
+
+contract ExampleContract {
+ uint public exampleVariable;
+
+
+ function setExampleVariable(uint _exampleVariable) external {
+ exampleVariable = _exampleVariable;
+ }
+}
+```
+
+
+
+
+
+Once deployed, we fill the `EXAMPLE_CONTRACT_ADDRESS` value in our `.env` file. For the example project, it’s already deployed at `TODO: 0xc37ee92c73753B46eB865Ee156d89741ad0a8777` and pre-filled, so nothing has to be done here.
+
+
+### Estimating the fees
+
+
+The central part of the example lives in the `/scripts/gasEstimation.ts` file.
+
+
+We’ll do just four things:
+
+
+1. Create a dummy transaction using the ExampleContract
+2. Estimate the L2 fee of that transaction
+3. Estimate the L1 fee of that transaction
+4. Emit an actual transaction to Scroll and compare the values
+
+
+#### Creating the dummy transaction
+
+
+The goal of this step is to create an **(RLP) Serialized Unsigned Transaction** to be used later on as the parameter for calling the oracle gas estimation method.
+
+
+1. Let’s populate our transaction with the needed values to estimate its cost by calling `buildPopulatedExampleContractTransaction`. This will fill the `data`, `to`, `gasPrice`, `type` and `gasLimit` fields:
+
+
+```typescript
+export async function buildPopulatedExampleContractTransaction(
+ exampleContractAddress: string,
+ newValueToSet: number
+): Promise {
+ const exampleContract = await ethers.getContractAt("ExampleContract", exampleContractAddress)
+
+
+ return exampleContract.setExampleVariable.populateTransaction(newValueToSet)
+}
+```
+
+
+2. Now, let’s trim it down to the basic fields using `buildUnsignedTransaction`. We won’t be signing it.
+
+
+```typescript
+export async function buildUnsignedTransaction(signer: HardhatEthersSigner, populatedTransaction: ContractTransaction): Promise {
+ const nonce = await signer.getNonce();
+
+
+ return {
+ data: populatedTransaction.data,
+ to: populatedTransaction.to,
+ gasPrice: populatedTransaction.gasPrice,
+ type: populatedTransaction.type,
+ gasLimit: populatedTransaction.gasLimit,
+ nonce,
+ };
+```
+
+
+
+
+
+3. With the output of the previous function, we serialize it using `getSerializedTransaction`
+
+
+```typescript
+export function getSerializedTransaction(tx: UnsignedTransaction) {
+ return serialize(tx)
+}
+```
+
+
+#### Estimating the L2 fee
+
+
+This step is pretty standard and the same as on Ethereum. We’ll use the `estimateL2Fee` function which takes the populated transaction as an input and returns an estimate of the total gas it will use by multiplying the current gas price and gas needed to be used.
+
+
+```typescript
+export async function estimateL2Fee(tx: ContractTransaction): Promise {
+ const gasToUse = await ethers.provider.estimateGas(tx)
+ const feeData = await ethers.provider.getFeeData()
+ const gasPrice = feeData.gasPrice
+
+
+ return gasToUse * gasPrice
+}
+```
+
+
+#### Estimating the L1 fee of that transaction
+
+
+This step is very straightforward. Using the output of the `getSerializedTransaction` function, we query the oracle and get the estimated fee in return.
+
+
+```typescript
+export async function estimateL1Fee(
+ gasOraclePrecompileAddress: string,
+ unsignedSerializedTransaction: string
+): Promise {
+ const l1GasOracle = await ethers.getContractAt("IL1GasPriceOracle", gasOraclePrecompileAddress)
+
+
+ return l1GasOracle.getL1Fee(unsignedSerializedTransaction)
+}
+```
+
+
+#### Emitting the transaction and comparing estimated vs actual values
+
+
+**Emitting the transaction**
+
+
+We’ll create a call to our contract using the same values used for the dummy transaction.
+
+
+```typescript
+const tx = await exampleContract.setExampleVariable(newValueToSetOnExampleContract)
+const txReceipt = await tx.wait(5)
+```
+
+
+**Calculating the L2 fee**
+
+
+Using the transaction receipt we can see the amount of gas used by the transaction
+
+
+```typescript
+const l2Fee = txReceipt.gasUsed * txReceipt.gasPrice
+```
+
+
+**Getting the amount used to pay for the L1 fee**
+
+
+To do this, we’ll compare the _balance of the account before_ the transaction execution, the _account balance after_ the execution and then subtract the L2 fee.
+
+
+```typescript
+const totalFee = signerBalanceBefore - signerBalanceAfter
+const l1Fee = totalFee - l2Fee
+```
+
+
+**Comparing the values**
+
+
+Fee markets are constantly moving and unpredictable. Since the values estimated may differ from the actual execution, let’s check how much they differ.
+
+
+We can run all the code that we previously wrote by typing `yarn gas:estimate` command in our [project](https://github.com/scroll-tech/scroll-guides/tree/main/gas-estimation-demo) that will run the [`gasEstimation.ts`](https://github.com/scroll-tech/scroll-guides/blob/main/gas-estimation-demo/scripts/gasEstimation.ts) script and give us the output below:
+
+
+```bash
+Estimated L1 fee (wei): 208705598167252
+Estimated L2 fee (wei): 26416000000
+Estimated total fee (wei): 208732014167252
+
+
+Actual L1 fee (wei): 210830909757550
+Actual L2 fee (wei): 26416000000
+Actual total fee (wei): 210857325757550
+
+
+(actual fee - estimated fee)
+Difference L1 fee (wei): 2125311590298 (1.0183299389002531%)
+Difference L2 fee (wei): 0 (0%)
+Difference total fee (wei): 2125311590298 (1.0182010645453987%)
+```
+
+
+We can see above that the estimated values (in wei) differ by around 1%, but keep in mind that during spikes in gas prices, this difference may increase. Be sure to account for this in your front end for users!
+
+
+
+
+
+
diff --git a/src/content/docs/tr/developers/guides/scroll-messenger-cross-chain-interaction.mdx b/src/content/docs/tr/developers/guides/scroll-messenger-cross-chain-interaction.mdx
new file mode 100644
index 000000000..83e5cd532
--- /dev/null
+++ b/src/content/docs/tr/developers/guides/scroll-messenger-cross-chain-interaction.mdx
@@ -0,0 +1,146 @@
+---
+section: developers
+date: Last Modified
+title: "Scroll Messenger ile Zincirler Arası Etkileşim"
+lang: "tr"
+permalink: "developers/guides/scroll-messenger-cross-chain-interaction"
+whatsnext: { "Özel Ağ Geçidi üzerinden ERC20 köprüleyin": "/tr/developers/guides/bridge-erc20-through-the-custom-gateway" }
+excerpt: "Bu örnekte, Sepolia veya Scroll Sepolia test ağında bir kukla akıllı sözleşme oluşturacağız ve onunla karşı zincirden etkileşime geçeceğiz."
+---
+
+
+import Aside from "../../../../../components/Aside.astro"
+
+
+Bu örnekte, Sepolia veya Scroll üzerinde bir sahte akıllı sözleşme başlatacağız ve onunla karşı zincirden etkileşime geçeceğiz. Hem Sepolia'da hem de Scroll'da dağıtılmış olan "ScrollMessenger"ı kullanacağız.
+
+
+## Sözleşmelerin Dağıtılması
+
+
+### Hedef Akıllı Sözleşme
+
+
+Hedef akıllı sözleşmeyi dağıtarak başlayalım. Bu örnek için Greeter sözleşmesini kullanacağız, ancak siz başka herhangi bir sözleşmeyi kullanabilirsiniz. Sepolia veya Scroll'a dağıtabilirsiniz. Scroll'da L1 ve L2 aynı API'ı kullanır, dolayısıyla karar size bağlıdır.
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+
+// This Greeter contract will be interacted with through the ScrollMessenger across the bridge
+contract Greeter {
+ string public greeting = "Hello World!";
+
+
+ // This function will be called by executeFunctionCrosschain on the Operator Smart Contract
+ function setGreeting(string memory greeting_) public {
+ greeting = greeting_;
+ }
+}
+```
+
+
+Artık setGreeting'i zincirler arası bir şekilde yürüteceğiz.
+
+
+### Operatör Akıllı Sözleşmesi
+
+
+Diğer zincire geçin ve 'GreeterOperator'ı dağıtın. Eğer "Greeter" sözleşmesini L1'de dağıttıysanız, "GreeterOperator"ı L2'de dağıtın veya tam tersini uygulayın.
+
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.16;
+
+
+// The Scroll Messenger interface is the same on both L1 and L2, it allows sending cross-chain transactions
+// Let's import it directly from the Scroll Contracts library
+import "@scroll-tech/contracts@0.1.0/libraries/IScrollMessenger.sol";
+
+
+// The GreeterOperator is capable of executing the Greeter function through the bridge
+contract GreeterOperator {
+ // This function will execute setGreeting on the Greeter contract
+ function executeFunctionCrosschain(
+ address scrollMessengerAddress,
+ address targetAddress,
+ uint256 value,
+ string memory greeting,
+ uint32 gasLimit
+ ) public payable {
+ IScrollMessenger scrollMessenger = IScrollMessenger(scrollMessengerAddress);
+ // sendMessage is able to execute any function by encoding the abi using the encodeWithSignature function
+ scrollMessenger.sendMessage{ value: msg.value }(
+ targetAddress,
+ value,
+ abi.encodeWithSignature("setGreeting(string)", greeting),
+ gasLimit,
+ msg.sender
+ );
+ }
+}
+```
+
+
+## Zincirler Arası Fonksiyon Çağırma
+
+
+Mesajı `executeFunctionCrosschain` komutunu çalıştırıp aşağıdaki parametreleri ileterek iletiyoruz:
+
+
+- `scrollMessengerAddress`: Bu, "GreeterOperator" sözleşmesini nereye uyguladığınıza bağlı olacaktır.
+ - Sepolia'ya dağıttıysanız '0x50c7d3e7f7c656493D1D76aaa1a836CedfCBB16A', Scroll Sepolia'ya dağıttıysanız '0xBa50f5340FB9F3Bd074bD638c9BE13eCB36E603d' adreslerini kullanın.
+- `targetAddress`: Karşı zincirdeki 'Greeter' sözleşmesinin adresi.
+- `value`: Bu durumda '0'dır çünkü 'setGreeting' payable bir fonksiyon değil.
+- `greeting`: Mesaj yoluyla gönderilecek parametredir. `"Bu mesaj zincirler arasıydı!"` olarak ayarlayıp iletmeyi deneyin
+- `gasLimit`:
+ - L1'den L2'ye mesaj gönderiyorsanız '1000000' civarındaki gas limiti fazlasıyla yeterli olacaktır. Bununla birlikte, eğer çok yüksek ayarlarsanız ve "msg.value", "gasLimit" * "baseFee"yi karşılamıyorsa, işlem geri alınacaktır. 'msg.value' gaz ücretinden fazla ise kullanılmayan kısım iade edilecektir.
+ - L2'den L1'e mesaj gönderiyorsanız '0'ı değerini geçirin, çünkü işleminiz L1 üzerinde ek bir işlem yapılarak tamamlanacaktır.
+
+
+### L2'den L1'e gönderirken Mesajı Aktarın
+
+
+L2'den L1'e bir işlem geçtiğinde, L1 üzerinde ek bir "para çekimi gerçekleştirme işlemi" gönderilmelidir. Bunu yapmak için EOA cüzdanından L1 Scroll Messenger sözleşmesindeki 'relayMessageWithProof'u çağırmalısınız.
+
+
+
+
+Doğrudan [Etherscan Sepolia](https://sepolia.etherscan.io/address/0x50c7d3e7f7c656493d1d76aaa1a836cedfcbb16a#writeProxyContract#F3) üzerinden yapabilirsiniz.
+Bunu yapmak için köprülenmiş işlem ve diğer parametreler için bir Merkle dahil olma kanıtını iletmeniz gerekecektir. Bunları Scroll Köprü API'ını kullanarak sorgulayacaksınız.
+
+
+{/* TODO: finish looking into API issues */}
+
+
+API özelliklerini son haline getirmeye çalışıyoruz ancak şimdilik aşağıdaki uç noktayı getirin veya curl'leyin:
+
+
+```bash
+curl "https://sepolia-api-bridge.scroll.io/api/claimable?page_size=10&page=1&address=GREETER_OPERATOR_ADDRESS_ON_L2"
+```
+
+
+'GREETER_OPERATOR_ADDRESS_ON_L2' kısmını L2'de oluşturduğunuz GreeterOperator sözleşmesinin adresiyle değiştirin. [Scroll Messenger](/tr/developers/l1-and-l2-bridging/the-scroll-messenger) makalesinde Para Çekme Gerçekleştirme işlemlerini yürütme hakkında daha fazla bilgi edinin.
+
+
+
+
+
+
+
+
+İşlemi hem L1 hem de L2'de yürütüp onayladıktan sonra, "Greeter" sözleşmesindeki "greeting"in yeni durumu “This message was cross-chain!” olmalıdır. Bir zincirden diğerine mesaj göndermek, işlem zincirinde onaylandıktan sonra yaklaşık 20 dakika sürecektir.
+
+
+Tebrikler, yerel köprümüzü kullanarak bir zincirden diğerine işlem gerçekleştirmiş oldunuz!
+
+
+
diff --git a/src/content/docs/tr/developers/index.mdx b/src/content/docs/tr/developers/index.mdx
new file mode 100644
index 000000000..5f6dc7307
--- /dev/null
+++ b/src/content/docs/tr/developers/index.mdx
@@ -0,0 +1,76 @@
+---
+section: developers
+date: Last Modified
+title: "Scroll Üzerinde Geliştirmek"
+lang: "tr"
+permalink: "developers/"
+excerpt: "Scroll üzerinde inşa etmek tıpkı Ethereum'daki gibi hissettirir, en sevdiğiniz araçları ve sözleşmeleri yanınızda getirebilirsiniz."
+whatsnext: { "Geliştirici Hızlı Başlangıcı": "/tr/developers/developer-quickstart" }
+---
+
+import Aside from "../../../../components/Aside.astro"
+import ToggleElement from "../../../../components/ToggleElement.astro"
+
+**Scroll geliştirici belgelerine hoş geldiniz!**
+
+Scroll, Ethereum üzerine kurulu kendi Katman 2 ağıdır (daha spesifik olarak bir "zero knowledge rollup'ı").
+
+Ethereum üzerinde geliştirme yapma konusunda deneyimliyseniz kodunuz, bağımlılıklarınız ve araçlarınız olduğu gibi Scroll üzerinde çalışabilmektedir. Bunun mümkün olmasının sebebi ağımızın EVM bayt koduyla uyumlu ve tıpkı Ethereum üzerinde geliştirme yapıyormuş gibi bir deneyim sunacak şekilde tasarlanmış olmasıdır.
+
+
+
+## Başlarken
+
+**Scroll üzerinde geliştirme mi yapmak istiyorsunuz?**
+
+- Temel bilgiler için: [Geliştirici Hızlı Başlangıcı](/tr/developers/developer-quickstart) sayfasına göz atın
+- Scroll'da ilk akıllı sözleşmenizin dağıtımını açıklayan bir eğitim için [sözleşme dağıtım eğitimimizi](/tr/developers/guides/contract-deployment-tutorial) okuyun
+- Ayrıca üzerinde geliştirme yapabileceğiniz bir dizi [sözleşme adreslerimiz](/tr/developers/scroll-contracts) var.
+
+## ## Neden Scroll Üzerinde Geliştirilmeli?
+
+
+
Verim – Scroll, Ethereum için daha güvenli blok alanı oluşturur.
+
+ ZK Rollup'lar ağda daha fazla etkinliğe izin vererek kalabalıklığı en aza indirir. Zero knowledge kanıtlarını kullanarak ağın davranışını doğrulayan Ethereum'un güvenliğini devralan Scroll; merkeziyetsizlikten ödün vermeden daha fazla işlem gerçekleştirebilir.
+
+
+
+
+
Maliyet — Scroll, kullanıcıların gaz ücretlerinden tasarruf etmesini sağlar.
+
+ Ethereum'da blok alanı için rekabet, her işlem bir sonraki bloğa dahil olmak için teklif verildiğinden işlem başına daha yüksek maliyetlerle sonuçlanır. Scroll, güvenli blok alanını büyük ölçüde arttırmak ve kullanıcılar için işlem maliyetlerini en aza indirmek için zero knowledge kanıtları ve donanım hızlandırma alanındaki son buluşlardan yararlanıyor.
+
+
+
+
Hız — Scroll, kullanıcılara daha hızlı geri dönüş sağlar.
+
+ Birleşmeden sonra Ethereum blokları her 12 saniyede bir güvenilir bir şekilde onaylanır. Scroll blokları her 3 saniyede bir basılıyor ve daha düşük riskli operasyonlar için, işlemlerin bir bloğa dahil edildikten sonra nihai olduğu varsayılabilir. Bu, sosyal uygulamalarda ve oyun uygulamalarında zincir içi etkileşim için yeni olanaklar açar.
+
+
+
+
Uyum - Scroll, Ethereum'un vizyonuna dayanır.
+
+ Scroll, Ethereum'un vizyonuna dayanıyor. Bizim ilkelerimiz Ethereum'dan ayrışmak değil, onu inşa etmektir. Merkeziyetsiz yönetim, izinsizlik, sansüre karşı direnç ve topluluk sahipliği yaptığımız işin ve oluşturduğumuz yol haritasının temelini oluşturuyor. Açık kaynaklı yazılıma inanıyoruz ve bir gün Ethereum'un kalbi olabilecek zkEVM üzerindeki çalışmalarını desteklemek için Ethereum Vakfı'nın Gizlilik ve Ölçeklendirme Araştırmaları ekibiyle yakın işbirliği içinde çalışıyoruz.
+
+
+ Ayrıca uygulamalar dağıtılırken, ister kamu mallarında, ister temel altyapıda, ister yeni nesil zero knowledge kullanım senaryolarında olsun, etkilerini artırmak için çalıştığımızdan emin olmak için yönetişim DAO'ları ve diğer açık kaynak protokolleriyle de çalışıyoruz.
+
+
+
+
Topluluk — Scroll, kullanıcıları ve geliştiricileri bir araya getirir.
+
+ Açık kaynaklı bir şekilde geliştirmenin ve kullanıcı etkileşimi sağlamanın zorluklarını biliyoruz! Scroll'un gelişen bir kullanıcı ve geliştirici topluluğu var ve test ağımızdaki veya ana ağımızdaki uygulamaları denemek isteyen 500.000'den fazla üyeden oluşan Discord topluluğumuzla, geliştiricileri gerçek dünyadan geri bildirim sağlayabilecek kullanıcılarla buluşturmaktan heyecan duyuyoruz.
+
+
+
+## Bizimle birlikte inşa ettiğiniz için teşekkür ederiz.
+
+Ağa daha fazla entegrasyon ve destek altyapısı getirmek için çabalıyor ve ana ağ sürümümüz için heyecanla çalışıyoruz.
+
+Büyüyen geliştirici topluluğumuza katılın. Bizi [Discord](https://discord.gg/scroll) adresinde bulabilir, [tartışma forumumuza](https://community.scroll.io/) katılabilir veya ilerlememizi [Twitter](https://twitter.com/Scroll_ZKP) üzerinde takip edebilirsiniz.
diff --git a/src/content/docs/tr/developers/l1-and-l2-bridging.mdx b/src/content/docs/tr/developers/l1-and-l2-bridging.mdx
new file mode 100644
index 000000000..0e886cc0f
--- /dev/null
+++ b/src/content/docs/tr/developers/l1-and-l2-bridging.mdx
@@ -0,0 +1,37 @@
+---
+section: developers
+date: Last Modified
+title: "L1 ve L2 Köprüleme"
+lang: "tr"
+permalink: "developers/l1-and-l2-bridging"
+whatsnext: { "ETH ve ERC20 Token Köprüsü": "/tr/developers/l1-and-l2-bridge/eth-and-erc20-token-bridge/" }
+excerpt: "Scroll'un Köprüleme mimarisine genel bakış"
+---
+
+import ClickToZoom from "../../../../components/ClickToZoom.astro"
+import Aside from "../../../../components/Aside.astro"
+import L1GatewayWHITE from "../../../../assets/images/developers/L1GatewayWHITE.png"
+import withdrawWHITE from "../../../../assets/images/developers/withdrawWHITE.png"
+
+Scroll köprüsü, L1 ile L2 arasında ETH, ERC20 tokenleri, NFT'ler ve isteğe bağlı mesajların aktarımını sağlar. Çeşitli dijital varlıkların L1 ve L2 arasında taşınması için güvenli bir mekanizma görevi görür.
+
+ETH ve ERC20 tokenlerinin transferini kolaylaştırmak için Scroll köprüsü Ağ Geçidi Yönlendiricisini kullanır. Bu sözleşme, bu varlıkların L1 ve L2 arasında sorunsuz geçişini sağlayarak kullanıcıların Ethereum tabanlı tokenlerini sorunsuz bir şekilde aktarmalarına olanak tanır.
+
+ERC721 ve ERC1155 Ağ Geçidi, iki ağ arasında değiştirilemez varlıkların aktarımına olanak tanıyarak kullanıcıların NFT'lerini L1 ve L2 arasında taşımasına olanak tanır.
+
+Token transferlerine ek olarak Scroll Messenger sözleşmesi, zincirler arası sözleşme etkileşimine olanak tanır. Bu, bir ağdaki sözleşmelerin Scroll Messenger sözleşmesi aracılığıyla diğer ağdaki sözleşmelerle etkileşime girebileceği anlamına gelir. Bu işlevsellik, merkezi olmayan uygulamaların ve akıllı sözleşmelerin her iki ağda da sorunsuz bir şekilde çalışmasına yönelik olasılıkları genişletir.
+
+## L1 Ağ Geçidi mimarisi
+
+
+
+
+Kullanıcıların Scroll Köprüsü'ne birçok giriş noktası bulunmaktadır. Bu ne yapmak istediğinize ve nasıl yapmak istediğinize bağlı olacaktır. ETH veya ERC20 tokenleri göndermek istiyorsanız 'GatewayRouter'ı kullanmalısınız. NFT göndermek istiyorsanız 'L1ERC721Gateway' veya 'L1ERC1155Gateway' kullanmalısınız. İsteğe bağlı veri göndermek istiyorsanız 'L1ScrollMessenger'ı kullanmalısınız. Tüm ağ geçidi aktarımları, varlıkları zincirler arası göndermek için Scroll Messenger'ı kullanır. Scroll Messenger'ın görevi, işlemleri L2'ye dahil etmek için Mesaj Kuyruğu'na eklemektir.
+
+## L2 Ağ Geçidi mimarisi
+
+
+
+İzinsiz çağrılabilen olası giriş noktalarıyla ilgili olarak, L2 Ağ Geçidi Mimarisi L1'e çok benzemektedir. Aradaki fark, L2'den bir mesaj gönderirken, ‘appendMessage’ fonksiyonunu çağırmakla olur. Bu durumda mesaj, L2MessageQueue'da, yalnızca ekleme yapılabilen bir ikili merkle ağacında (diğer bir deyişle çekim ağacı) saklanır. Blok sonlandırıldığında, yeni merkle yolunun bir kanıtını oluşturacak ve bunu 'L1ScrollMessenger' üzerinde yürütülmek üzere L1geth düğümüne iletecektir. Kesinleşmiş tüm çekim kökleri, onlara karşı kanıtları doğrulayabilmemiz için rollup sözleşmesinde saklanacaktır. Sonraki Scroll sürümlerinde, tüm kullanıcılar işlemi L1'de tamamlayabileceğinden Aktarıcı'ya ihtiyaç duyulmayacak.
+
+Gelecek bölümlerde, yeteneklerini kullanmak için gereken akıllı sözleşme API'si de dahil olmak üzere köprünün teknik yönlerini inceleyeceğiz. Geliştiricilerin ve kullanıcıların bu işlevleri anlamalarına ve uygulamalarına yardımcı olmak için Geliştirici Kılavuzları bölümünde kod örnekleri içeren ayrıntılı kılavuzlar sağlanmaktadır.
\ No newline at end of file
diff --git a/src/content/docs/tr/developers/l1-and-l2-bridging/enforced-transactions.mdx b/src/content/docs/tr/developers/l1-and-l2-bridging/enforced-transactions.mdx
new file mode 100644
index 000000000..c91faaa3f
--- /dev/null
+++ b/src/content/docs/tr/developers/l1-and-l2-bridging/enforced-transactions.mdx
@@ -0,0 +1,57 @@
+---
+section: developers
+date: Last Modified
+title: "Zorunlu işlemler"
+lang: "tr"
+permalink: "developers/l1-and-l2-bridging/enforced-transactions"
+excerpt: "Zorunlu İşlem sözleşmesi L1 ve L2 arasında işlemlerin sendTransaction fonksiyonu ile gönderilmesini sağlar."
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+Scroll'un gelecekteki yükseltmelerinde, Zorunlu İşlem sözleşmesi, **`sendTransaction`** fonksiyonu ile L1 ile L2 arasındaki işlemlerin gönderilmesine olanak tanıyacaktır. Bu sözleşme, bir katmandan diğerine rastgele veri gönderilmesine izin verdiği için Scroll Messenger sözleşmesiyle benzerlikler paylaşıyor. Ancak imzalı işlemlerin aktarılmasına olanak sağlaması ve Scroll üzerinde göndericiyi (CALLER veya msg.sender) alıcı işlemde ayarlama olanağı sağlamasıyla öne çıkmaktadır.
+
+## Zorunlu İşlemler API
+
+Scroll sözleşmesi API dokümanlarının tamamı için lütfen [npm kitaplığını](https://www.npmjs.com/package/@scroll-tech/contracts?activeTab=code) ziyaret edin.
+
+### sendTransaction
+
+```solidity
+function sendTransaction(address _target, uint256 _value, uint256 _gasLimit, bytes calldata _data) public payable;
+```
+
+Bir EOA hesabı göndericisinden L2'ye zorunlu bir işlem ekleyin.
+
+| Parametre | Açıklama |
+| ---------- | ---------------------------------------------------------- |
+| \_target | L2'de çağrılacak hedef sözleşmenin adresi. |
+| \_value | Gönderilecek değer |
+| \_gasLimit | L2'de bu işlem tarafından kullanılabilecek maksimum gaz |
+| \_data | Hedef sözleşmeye iletilen çağrı verileri |
+
+### sendTransaction
+
+```solidity
+function sendTransaction(
+ address _sender,
+ address _target,
+ uint256 _value,
+ uint256 _gasLimit,
+ bytes calldata _data,
+ bytes memory _signature,
+ address _refundAddress
+) public payable;
+```
+
+Gönderenden bir imza aktararak L2'ye zorunlu bir işlem ekleyin.
+
+| Parametre | Açıklama |
+| --------------- | --------------------------------------------------------------- |
+| \_sender | L2'de bu işlemi başlatacak göndericinin adresi |
+| \_target | L2'de çağrılacak hedef sözleşmenin adresi. |
+| \_value | Gönderilecek değer |
+| \_gasLimit | L2'de bu işlem tarafından kullanılabilecek maksimum gaz |
+| \_data | Hedef sözleşmeye iletilen çağrı verileri |
+| \_signature | İşlem imzası. |
+| \_refundAddress | İşlem ücreti fazlasının iade edileceği adres. |
diff --git a/src/content/docs/tr/developers/l1-and-l2-bridging/erc1155-token-bridge.mdx b/src/content/docs/tr/developers/l1-and-l2-bridging/erc1155-token-bridge.mdx
new file mode 100644
index 000000000..2c1a30dc6
--- /dev/null
+++ b/src/content/docs/tr/developers/l1-and-l2-bridging/erc1155-token-bridge.mdx
@@ -0,0 +1,156 @@
+---
+section: developers
+date: Last Modified
+title: "ERC1155 Token Köprüsü"
+lang: "tr"
+permalink: "developers/l1-and-l2-bridging/erc1155-token-bridge"
+whatsnext: { "Scroll Messenger": "/tr/developers/l1-and-l2-bridging/the-scroll-messenger/" }
+excerpt: "L1'den L2'ye ERC1155 köprülenmesi L1ERC1155Gateway aracılığıyla yapılır."
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+## L1'den ERC1155 tokenları yatırın
+
+ERC1155'in L1'den L2'ye köprülenmesi L1ERC1155Gateway aracılığıyla yapılır. ERC721 köprülemeye benzer şekilde, bir yönlendirici kullanmak yerine doğrudan Ağ Geçidi üzerinde 'depositERC1155' fonksiyonunu kullanıyoruz.
+
+
+
+### L2'de ERC1155 tokenı oluşturma
+
+ERC721 köprülemeye benzer şekilde, ERC1155 tokenlerini köprülemek için, "IScrollERC1155" standardıyla uyumlu bir sözleşmenin oluşturulup hem L1 hem de L2'de sırasıyla "L1ERC1155Gateway" ve "L2ERC1155Gateway" üzerinde eşlenmesi gerekir. Bu sözleşmeye, L2'deki Ağ Geçidine bir token yatırıldığında basması ve token çekildiğinde yakması için izin vermelidir.
+
+Aşağıdaki arayüz, L2'de "L2ERC1155Gateway" ile uyumlu ERC1155 tokenlarını dağıtmak için gereken "IScrollERC1155"tir.
+
+```solidity
+interface IScrollERC1155 {
+ /// @notice Return the address of Gateway the token belongs to.
+ function gateway() external view returns (address);
+
+ /// @notice Return the address of counterpart token.
+ function counterpart() external view returns (address);
+
+ /// @notice Mint some token to recipient's account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _to The address of recipient.
+ /// @param _tokenId The token id to mint.
+ /// @param _amount The amount of token to mint.
+ /// @param _data The data passed to recipient
+ function mint(address _to, uint256 _tokenId, uint256 _amount, bytes memory _data) external;
+
+ /// @notice Burn some token from account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _from The address of account to burn token.
+ /// @param _tokenId The token id to burn.
+ /// @param _amount The amount of token to burn.
+ function burn(address _from, uint256 _tokenId, uint256 _amount) external;
+
+ /// @notice Batch mint some token to recipient's account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _to The address of recipient.
+ /// @param _tokenIds The token id to mint.
+ /// @param _amounts The list of corresponding amount of token to mint.
+ /// @param _data The data passed to recipient
+ function batchMint(
+ address _to,
+ uint256[] calldata _tokenIds,
+ uint256[] calldata _amounts,
+ bytes calldata _data
+ ) external;
+
+ /// @notice Batch burn some token from account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _from The address of account to burn token.
+ /// @param _tokenIds The list of token ids to burn.
+ /// @param _amounts The list of corresponding amount of token to burn.
+ function batchBurn(address _from, uint256[] calldata _tokenIds, uint256[] calldata _amounts) external;
+}
+```
+
+### Scroll Köprüsü'ne bir ERC1155 token ekleme
+
+Tüm varlıklar, herhangi bir geliştirici tarafından dağıtılmış Ağ Geçidi sözleşmeleri aracılığıyla güvenli ve izinsiz olarak köprülenebilmektedir. Ancak Scroll aynı zamanda topluluk tarafından oluşturulan tüm NFT'lerin kabul edildiği bir ERC1155 Ağ Geçidi sözleşmesini de yönetmektedir. Scroll tarafından yönetilen Ağ Geçidinin bir parçası olmak, Ağ Geçidi sözleşmelerini dağıtmanıza gerek kalmayacağı ve tokenınızın Scroll kullanıcı arayüzünde görüneceği anlamına gelir. Scroll Ağ Geçidi'nin bir parçası olmak için, tokenı hem L1 hem de L2 Ağ Geçidi sözleşmelerine eklemelisiniz ve bunun için Scroll ekibiyle iletişime geçmelisiniz. Tokenınızı Scroll resmi kullanıcı arayüzüne eklemek için [token listeleri](https://github.com/scroll-tech/token-list) deposundaki talimatları izleyin.
+
+## ERC1155 tokenlarını L2'den çekin
+
+'L2ERC1155Gateway' sözleşmesi L2'den L1'e token göndermek için kullanılır. Köprülemeden önce 'L2ERC1155Gateway' sözleşmesinin token sözleşmesi tarafından onaylanması gerekir. Bu yapıldıktan sonra varlık köprüsünü gerçekleştirmek için "drawERC1155" çağrılabilir.
+
+
+
+
+
+## L1ERC1155Gateway API
+
+Scroll sözleşmesi API dokümantasyonunun tamamı için lütfen [npm kitaplığını](https://www.npmjs.com/package/@scroll-tech/contracts?activeTab=code) ziyaret edin.
+
+### depositERC1155
+
+```solidity
+function depositERC1155(
+ address _token,
+ address _to,
+ uint256 _tokenId,
+ uint256 _amount,
+ uint256 _gasLimit
+) external payable;
+```
+
+L1'den alıcının L2'deki hesabına bir ERC1155 tokenı yatırır.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------- |
+| token | ERC721 token sözleşmesinin L1'deki adresi. |
+| to | Alıcı hesabının L2'deki adresi. |
+| tokenId | Yatırılacak NFT'nin ID'si. |
+| amount | Yatırılacak tokenların miktarı. |
+| gasLimit | L2'deki yatırma işlemini tamamlamak için gereken gaz limiti. Ücretin kullanılmayan kısmı iade edilecektir. |
+
+### updateTokenMapping
+
+```solidity
+function updateTokenMapping(address _l1Token, address _l2Token) external;
+```
+
+ERC1155 token sözleşmesini L1'den L2'ye bağlayan eşlemeyi günceller.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------- |
+| \_l1Token | ERC1155 tokenının L1'deki adresi. |
+| \_l2Token | ERC1155 tokeninin L2'deki karşılık gelen adresi. |
+
+## L2ERC1155Gateway API
+
+### withdrawERC1155
+
+```solidity
+function withdrawERC1155(address token, address to, uint256 tokenId, uint256 amount, uint256 gasLimit) external payable;
+```
+
+L2'den alıcının L1'deki hesabına ERC1155 tokenlarını gönderir.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------------------------------ |
+| token | ERC1155 token sözleşmesinin L2'deki adresi. |
+| to | Alıcı hesabının L1'deki adresi. |
+| tokenId | Gönderilecek NFT ID'si. |
+| amount | Çekilecek tokenların miktarı. |
+| gasLimit | Kullanılmıyor ancak potansiyel ileriye dönük uyumluluk hususları nedeniyle dahil edildi. |
+
+### updateTokenMapping
+
+```solidity
+function updateTokenMapping(address _l1Token, address _l2Token) external;
+```
+
+Bir ERC1155 token sözleşmesini L2'den L1'e bağlayan eşlemeyi günceller.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------- |
+| \_l1Token | ERC1155 tokenının L1'deki adresi |
+| \_l2Token | ERC1155 tokenının L2'deki karşılık gelen adresi. |
diff --git a/src/content/docs/tr/developers/l1-and-l2-bridging/erc721-nft-bridge.mdx b/src/content/docs/tr/developers/l1-and-l2-bridging/erc721-nft-bridge.mdx
new file mode 100644
index 000000000..3f6bec91c
--- /dev/null
+++ b/src/content/docs/tr/developers/l1-and-l2-bridging/erc721-nft-bridge.mdx
@@ -0,0 +1,126 @@
+---
+section: developers
+date: Last Modified
+title: "ERC721 NFT Köprüsü"
+lang: "tr"
+permalink: "developers/l1-and-l2-bridging/erc721-nft-bridge"
+excerpt: "L1'den L2'ye NFT köprüleme, yönlendirici kullanmak yerine L1ERC721Gateway sözleşmesi aracılığıyla yapılır."
+whatsnext: { "ERC1155 Token Köprüsü": "/tr/developers/l1-and-l2-bridging/erc1155-token-bridge/" }
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+## L1'den ERC721 tokenlarını yatırın
+
+L1'den L2'ye NFT köprüleme, yönlendirici kullanmak yerine "L1ERC721Gateway" sözleşmesi aracılığıyla yapılır. ERC20 tokenlarını köprülemeye benzer şekilde, tokenları L2'ye göndermek için "depositERC721" fonksiyonunu kullanırız ve daha sonra L2'de konuşlandırılan "L2ERC721Gateway" sözleşmesindeki "withdrawERC721"i kullanarak bunları L1'e geri alabiliriz.
+
+Köprülemeyi mümkün kılmak için hem L1 hem de L2'deki NFT sözleşmeleri başlatılmalı ve Ağ Geçitleri aracılığıyla bağlanmalıdır. Bu, L1 veya L2'deki bir sözleşmenin eksik olması veya 'updateTokenMapping' fonksiyonu aracılığıyla eşlenmemesi durumunda para yatırma ve çekme işlemlerinin geri alınacağı anlamına gelir.
+
+
+
+### L2'de ScrollERC721 tokenı oluşturma
+
+Bir ERC721 tokenını L2'ye yatırmak için, "IScrollERC721" standardıyla uyumlu bir token sözleşmesinin oluşturulması ve hem L1 hem de L2'de sırasıyla "L1ERC721Gateway" ve "L2ERC721Gateway" üzerinde eşlenmesi gerekir. Bu sözleşme, L2'deki Ağ Geçidine, bir token yatırıldığında basılması ve token geri çekildiğinde yakılması için izin vermelidir.
+
+Aşağıdaki arayüz, L2'de "L2ERC721Gateway" ile uyumlu ERC721 tokenlarını ağa dağıtmak için gereken "IScrollERC721"dir.
+
+```solidity
+interface IScrollERC721 {
+ /// @notice Return the address of Gateway the token belongs to.
+ function gateway() external view returns (address);
+
+ /// @notice Return the address of counterpart token.
+ function counterpart() external view returns (address);
+
+ /// @notice Mint some token to recipient's account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _to The address of recipient.
+ /// @param _tokenId The token id to mint.
+ function mint(address _to, uint256 _tokenId) external;
+
+ /// @notice Burn some token from account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _tokenId The token id to burn.
+ function burn(uint256 _tokenId) external;
+}
+```
+
+### Scroll Köprüsüne ERC721 NFT'leri Ekleme
+
+Tüm varlıklar, dağıtılan Ağ Geçidi sözleşmeleri aracılığıyla herhangi bir geliştirici tarafından güvenli ve izinsiz olarak köprülenebilir. Ancak Scroll aynı zamanda topluluk tarafından oluşturulan tüm NFT'lerin kabul edildiği bir ERC721 Ağ Geçidi sözleşmesini de yönetmektedir. Scroll tarafından yönetilen Ağ Geçidinin bir parçası olmak, Ağ Geçidi sözleşmelerini dağıtmanıza gerek kalmayacağı ve tokenınızın Scroll kullanıcı arayüzünde görüneceği anlamına gelir. Scroll Ağ Geçidi'nin bir parçası olmak için hem L1 hem de L2 Ağ Geçidi sözleşmelerine NFT eklemek üzere Scroll ekibiyle iletişime geçmelisiniz. Bunu yapmak için, Scroll resmi kullanıcı arayüzünde yeni bir token eklemek için [token listeleri](https://github.com/scroll-tech/token-list) deposundaki talimatları izleyin.
+
+## ERC721 tokenları Scroll'dan çekin
+
+L2'den L1'e token göndermek için L2ERC721Gateway sözleşmesi kullanılır. Köprülemeden önce 'L2ERC721Gateway' sözleşmesinin NFT sözleşmesi tarafından onaylanması gerekir. Bu yapıldıktan sonra varlık köprüsünü gerçekleştirmek için "drawERC721" çağrılabilir.
+
+
+
+
+
+## L1ERC721Gateway API
+
+Scroll sözleşmesi API dokümanlarının tamamı için lütfen [npm kitaplığını](https://www.npmjs.com/package/@scroll-tech/contracts?activeTab=code) ziyaret edin.
+
+### depositERC721
+
+```solidity
+function depositERC721(address _token, address _to, uint256 _tokenId, uint256 _gasLimit) external payable;
+```
+
+L1'den, alıcının L2'deki hesabına ERC721 NFT yatırır.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------- |
+| token | ERC721 NFT sözleşmesinin L1'deki adresi. |
+| to | Alıcı hesabının L2'deki adresi. |
+| tokenId | Yatırılacak NFT'nin ID'si. |
+| gasLimit | L2'deki yatırma işlemini tamamlamak için gereken gaz limiti. Ücretin kullanılmayan kısmı iade edilecektir. |
+
+### updateTokenMapping
+
+```solidity
+function updateTokenMapping(address _l1Token, address _l2Token) external;
+```
+
+Bir NFT sözleşmesini L1'den L2'ye bağlayan eşlemeyi günceller.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------ |
+| \_l1Token | ERC721 tokeninin L1'deki adresi. |
+| \_l2Token | ERC721 tokeninin L2'deki karşılık gelen adresi. |
+
+## L2ERC721Gateway API
+
+### withdrawERC721
+
+```solidity
+function withdrawERC721(address _token, address _to, uint256 _tokenId, uint256 _gasLimit) external payable;
+```
+
+L2'den alıcının L1'deki hesabına bir ERC721 NFT gönderir.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------------------------------ |
+| token | ERC721 NFT token sözleşmesinin L2'deki adresi. |
+| to | Alıcı hesabının L1'deki adresi. |
+| tokenId | Gönderilecek NFT ID'si. |
+| gasLimit | Kullanılmıyor ancak potansiyel ileriye dönük uyumluluk hususları nedeniyle dahil edildi. |
+
+### updateTokenMapping
+
+```solidity
+function updateTokenMapping(address _l1Token, address _l2Token) external;
+```
+
+Bir NFT sözleşmesini L2'den L1'e bağlayan eşlemeyi günceller.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------ |
+| \_l2Token | ERC721 tokeninin L2'deki adresi. |
+| \_l1Token | ERC721 tokeninin L1'deki karşılık gelen adresi. |
diff --git a/src/content/docs/tr/developers/l1-and-l2-bridging/eth-and-erc20-token-bridge.mdx b/src/content/docs/tr/developers/l1-and-l2-bridging/eth-and-erc20-token-bridge.mdx
new file mode 100644
index 000000000..a4c32c4ef
--- /dev/null
+++ b/src/content/docs/tr/developers/l1-and-l2-bridging/eth-and-erc20-token-bridge.mdx
@@ -0,0 +1,195 @@
+---
+section: developers
+date: Last Modified
+title: "ETH ve ERC20 Token Köprüsü"
+lang: "tr"
+permalink: "developers/l1-and-l2-bridging/eth-and-erc20-token-bridge"
+whatsnext: { "ERC721 NFT Köprüsü": "/tr/developers/l1-and-l2-bridging/erc721-nft-bridge/" }
+excerpt: "ETH ve ERC20 tokenlerinin sırasıyla depositETH ve depositERC20 fonksiyonlarını kullanılarak L1'den L2'ye köprülenmesine olanak tanıyan Ağ Geçidi Yönlendiricisi."
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+## L1'den ETH ve ERC20 Token Yatırma
+
+Ağ Geçidi Yönlendiricisi, sırasıyla "depositETH" ve "depositERC20" fonksiyonlarını kullanarak ETH ve ERC20 tokenlerinin L1'den L2'ye köprülenmesine olanak tanır. L1'de konuşlandırılmış izinsiz bir köprüdür. ERC20 tokenlerinin L2'de farklı bir adrese sahip olacağına dikkat edin, yeni adresi sorgulamak için 'getL2ERC20Address' işlevini kullanabilirsiniz.
+
+
+
+ERC20 tokenlarını köprülerken doğru Ağ Geçidini seçme konusunda endişelenmenize gerek yok. Bunun nedeni, 'L1GatewayRouter'ın mesajı göndermek için doğru temel giriş noktasını seçeceğidir:
+
+- **`L1StandardERC20Gateway`:** Bu Ağ Geçidi, herhangi bir ERC20 yatırma işlemine izin verir ve L2'de özel mantığa ihtiyaç duymayan bir ERC20 tokenı için L1GatewayRouter tarafından varsayılan olarak seçilecektir. İlk token köprülemesinde L2 üzerinde ScrollStandardERC20'yi uygulayan yeni bir token oluşturulacaktır. Bir tokenı köprülemek için 'L1GatewayRouter'da 'depositERC20' fonksiyonunu çağırın.
+- **`L1CustomERC20Gateway`:** Bu Ağ Geçidi, özel mantığa sahip tokenlar için 'L1GatewayRouter' tarafından seçilecektir. Bir L1/L2 token çiftinin Scroll Özel ERC20 Köprüsü'nde çalışması için L2 token sözleşmesinin 'IScrollStandardERC20'yi uygulaması gerekir. Ek olarak, tokenın "L2CustomERC20Gateway"e "mint" veya "burn" yetkisi vermesi gerekir. Özel bir token'ın nasıl köprüleneceğine ilişkin adım adım bir örnek için [Özel Ağ Geçidi üzerinden ERC20'ye Köprü Oluşturma](/developers/guides/bridge-erc20-through-the-custom-gateway) kılavuzunu ziyaret edin.
+
+Tüm Ağ Geçidi sözleşmeleri mesajı oluşturacak ve L2'ye isteğe bağlı mesajlar gönderebilen 'L1ScrollMessenger'a gönderecektir. 'L1ScrollMessenger' mesajı 'L1MessageQueue'ya iletir. Herhangi bir kullanıcı, L2'de isteğe bağlı verileri yürütmek için doğrudan Messenger'a mesaj gönderebilir. Bu, köprü aracılığıyla L1 üzerinde yapılan bir işlem ile L2 üzerinde herhangi bir fonksiyonu çalıştırabilecekleri anlamına gelir. Bir uygulama doğrudan mevcut token sözleşmelerine mesaj iletebilse de, Ağ Geçidi ayrıntıları soyutlayarak transfer ve çağrı yapmayı basitleştirir.
+
+
+
+L1'de yeni bir blok oluşturulduğunda, Watcher "L1MessageQueue"daki mesajı algılayacak ve bunu, işlemi l2geth düğümü aracılığıyla L2'ye gönderecek olan Aktarıcı hizmetine iletecektir. Son olarak, l2geth düğümü, işlemi L2'de yürütülmek üzere 'L2ScrollMessenger' sözleşmesine iletecektir.
+
+## L2'den ETH ve ERC20 tokenleri çekin
+
+L2 Ağ Geçidi, L1 Ağ Geçidine çok benzer yapıdadır. 'drawETH' ve 'withdrawERC20' fonksiyonlarını kullanarak ETH ve ERC20 tokenlerini L1'e geri çekebiliriz. Sözleşme adresi L2'de dağıtılmıştır. L1'deki token adresini almak için 'getL1ERC20Address'i kullanıyoruz.
+
+
+
+
+
+## L2'de özel mantığa sahip bir ERC20 tokenı oluşturma
+
+Bir tokenın L2'de özel mantığa ihtiyacı varsa, sırasıyla "L1CustomERC20Gateway" ve "L2CustomERC20Gateway" üzerinden köprülenmesi gerekecektir. L2'deki özel tokenın, bir para yatırma işlemi gerçekleştiğinde yeni tokenler basması ve tokenler çekildiğinde yakılması için Ağ Geçidine izin vermesi gerekecektir.
+
+Aşağıdaki arayüz, L2'de "L2CustomERC20Gateway" ile uyumlu token dağıtmak için gereken "IScrollStandardERC20"dir.
+
+```solidity
+interface IScrollStandardERC20 {
+ /// @notice Return the address of Gateway the token belongs to.
+ function gateway() external view returns (address);
+
+ /// @notice Return the address of counterpart token.
+ function counterpart() external view returns (address);
+
+ /// @dev ERC677 Standard, see https://github.com/ethereum/EIPs/issues/677
+ /// Defi can use this method to transfer L1/L2 token to L2/L1,
+ /// and deposit to L2/L1 contract in one transaction
+ function transferAndCall(address receiver, uint256 amount, bytes calldata data) external returns (bool success);
+
+ /// @notice Mint some token to recipient's account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _to The address of recipient.
+ /// @param _amount The amount of token to mint.
+ function mint(address _to, uint256 _amount) external;
+
+ /// @notice Mint some token from account.
+ /// @dev Gateway Utilities, only gateway contract can call
+ /// @param _from The address of account to burn token.
+ /// @param _amount The amount of token to mint.
+ function burn(address _from, uint256 _amount) external;
+}
+```
+
+### Scroll Köprüsü'ne Özel L2 ERC20 tokenı ekleme
+
+Tokenlarınızı, herhangi bir geliştirici tarafından dağıtılmış olan Ağ Geçidi sözleşmeleri aracılığıyla güvenli ve izin gerektirmeyen bir şekilde köprüleyebilirsiniz. Ancak Scroll aynı zamanda bir ERC20 Yönlendiricisi ve topluluk tarafından oluşturulan tüm tokenlerin kabul edildiği bir Ağ Geçidini de yönetir. Scroll tarafından yönetilen Ağ Geçidinin bir parçası olmak, Ağ Geçidi sözleşmelerini dağıtmanıza gerek kalmayacağı ve tokenınızın Scroll kullanıcı arayüzünde görüneceği anlamına gelir. Scroll Ağ Geçidi'nin bir parçası olmak için, tokenı hem L1 hem de L2 köprü sözleşmelerine eklemelisiniz ve bunun için Scroll ekibiyle iletişime geçmelisiniz. Tokenınızı Scroll resmi kullanıcı arayüzüne eklemek için [token listeleri](https://github.com/scroll-tech/token-list) deposundaki talimatları izleyin.
+
+## L1 Ağ Geçidi API'si
+
+Scroll sözleşmesi API dokümantasyonunun tamamı için lütfen [npm kitaplığını](https://www.npmjs.com/package/@scroll-tech/contracts?activeTab=code) ziyaret edin.
+
+### depositETH
+
+```solidity
+function depositETH(address _to, uint256 _amount, uint256 _gasLimit) public payable;
+```
+
+L1'den L2'ye ETH gönderir.
+
+| Parametre | Açıklama |
+| --------- | --------------------------------------------------------------------------------------------------------------------------- |
+| to | Alıcı hesabının L2'deki adresi. |
+| amount | Wei cinsinden aktarılacak miktar. |
+| gasLimit | L2'deki yatırmayı tamamlamak için gereken gaz limiti. İşlemin gerçekleştirilmesi için 170000 yeterli olacaktır ancak kullanılmayan fonlar iade edilir. |
+
+### depositERC20
+
+```solidity
+function depositERC20(address _token, address _to, uint256 _amount, uint256 _gasLimit) payable;
+```
+
+L1'den L2'ye ERC20 token gönderir.
+
+| Parametre | Açıklama |
+| --------- | --------------------------------------------------------------------------------------------------------------------------- |
+| token | L1'deki token adresi. |
+| to | Alıcı hesabının L2'deki adresi. |
+| amount | Wei cinsinden aktarılacak token miktarı. |
+| gasLimit | L2'deki yatırmayı tamamlamak için gereken gaz limiti. Ağ Geçidine bağlı olarak işlemi gerçekleştirmek için 20000 yeterli olacaktır, ancak kullanılmayan fonlar iade edilir. |
+
+### getL2ERC20Address
+
+```solidity
+function getL2ERC20Address(address _l1Token) external view returns (address);
+```
+
+L1 token adresi verildiğinde karşılık gelen L2 token adresini döndürür.
+
+| Parametre | Açıklama |
+| --------- | ------------------------ |
+| \_l1Token | L1 token adresi. |
+
+### updateTokenMapping
+
+```solidity
+function updateTokenMapping(address _l1Token, address _l2Token) external;
+```
+
+Bir ERC20 tokenını L1'den L2'ye bağlayan eşlemeyi günceller.
+
+| Parametre | Açıklama |
+| --------- | ----------------------------------------------- |
+| \_l1Token | ERC20 tokenının L1'deki adresi. |
+| \_l2Token | ERC20 tokenının L2'deki karşılık gelen adresi. |
+
+## L2 Gateway API
+
+### withdrawETH
+
+```solidity
+function withdrawETH(address to, uint256 amount, uint256 gasLimit) external payable;
+```
+
+L2'den L1'e ETH gönderir.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------------------------------------------------------------- |
+| to | Alıcı hesabının L1'deki adresi. |
+| amount | Wei cinsinden aktarılacak miktar. |
+| gasLimit | L1'deki yatırmayı tamamlamak için gereken gaz limiti. İsteğe bağlıdır, ayarlamak istemiyorsanız 0 gönderin. |
+
+### withdrawERC20
+
+```solidity
+function withdrawERC20(address token, address to, uint256 amount, uint256 gasLimit) external payable;
+```
+
+L2'den L1'e ERC20 tokenları gönderir.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------------------------------------------------------------- |
+| token | L2'deki token adresi. |
+| to | Alıcı hesabının L1'deki adresi. |
+| amount | Wei cinsinden aktarılacak token miktarı. |
+| gasLimit | L1'deki yatırmayı tamamlamak için gereken gaz limiti. İsteğe bağlıdır, ayarlamak istemiyorsanız 0 gönderin. |
+
+### getL1ERC20Address
+
+```solidity
+function getL1ERC20Address(address l2Token) external view returns (address);
+```
+
+Bir L2 token adresi verildiğinde karşılık gelen L1 token adresini döndürür.
+
+| Parameter | Description |
+| --------- | ---------------------------- |
+| l2Token | L2 tokenının adresi. |
+
+### updateTokenMapping
+
+```solidity
+function updateTokenMapping(address _l1Token, address _l2Token) external;
+```
+
+ERC20 sözleşmesini L2'den L1'e bağlayan eşlemeyi güncelleyin.
+
+| Parameter | Description |
+| --------- | ----------------------------------------------- |
+| \_l2Token | ERC20 tokeninin L2'deki adresi. |
+| \_l1Token | ERC20 tokeninin L1'deki karşılık gelen adresi. |
diff --git a/src/content/docs/tr/developers/l1-and-l2-bridging/the-scroll-messenger.mdx b/src/content/docs/tr/developers/l1-and-l2-bridging/the-scroll-messenger.mdx
new file mode 100644
index 000000000..a7417bd10
--- /dev/null
+++ b/src/content/docs/tr/developers/l1-and-l2-bridging/the-scroll-messenger.mdx
@@ -0,0 +1,136 @@
+---
+section: developers
+date: Last Modified
+title: "Scroll Messenger"
+lang: "tr"
+permalink: "developers/l1-and-l2-bridging/the-scroll-messenger"
+whatsnext: { "Scroll'da İşlem Ücretleri": "/tr/developers/transaction-fees-on-scroll/" }
+excerpt: "L1 ve L2 arasında herhangi bir mesaj geçişi sağlayan Scroll Messenger belgeleri."
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+Scroll Messenger sözleşmeleri, L1'den L2'ye veya L1'den L2'ye herhangi bir mesajın gönderilmesine izin verir. Bu, başka bir zincirdeki fonksiyonların güvenli ve izin gerektirmeyen bir şekilde yürütülmesine olanak tanır. L1'den L2'ye mesaj göndermek için L1'de dağıtılmış olan 'L1ScrollMessenger' mesajlaşma akıllı sözleşmesini kullanın. L2'den L1'e mesaj göndermek için L2'de dağıtılmış olan 'L2ScrollMessenger' sözleşmesini kullanın.
+
+
+
+## İşlemlerin L1'de sonuçlandırılması
+
+L2'den gelecek tüm işlemlerin, Scroll Messenger sözleşmesindeki 'relayMessageWithProof' fonksiyonu kullanılarak tamamlanması gerekir. Bu sürece "Para Çekimi Gerçekleştirme İşlemi Gönderme" adını veriyoruz ve hem herhangi bir mesaj gönderilmesi hem de varlıkların bir ağ geçidi veya yönlendirici aracılığıyla aktarılması için gereklidir. 'relayMessageWithProof'u kullandığınızda, işleminizin diğer parametrelerle birlikte "para çekme" mesajlarının grubuna dahil olduğunu gösteren bir Merkle katılım kanıtı sağlamanız gerekir. Bu kanıtı ve bu değerleri üretmek yerel olarak ve izinsiz olarak yapılabilir, ancak şu anda bu parametreleri almanın en kolay yolu backend API'lerimiz aracılığıyladır:
+
+- Scroll Sepolia API: https://sepolia-api-bridge.scroll.io/api/
+- Scroll API: https://mainnet-api-bridge.scroll.io/api/
+
+
+
+L2'de orijinal işlemi başlatmaktan sorumlu olan EOA'nın veya sözleşmenin adresini "/claimable" uç noktasına sağlayın. API arka ucu, L1'deki işlemi başarılı bir şekilde sonuçlandırmak için gerekli tüm bilgileri size sağlayacaktır.
+Aşağıdaki örneğe bir göz atın:
+
+```bash
+https://sepolia-api-bridge.scroll.io/api/claimable?address=0x031407eaaffFB4f1EC2c999bE4477E52C81de3c5&page_size=10&page=1
+```
+
+API, işlem verilerinizi aşağıdaki biçimde döndürmelidir:
+
+```json
+{
+ "errcode": 0,
+ "errmsg": "",
+ "data": {
+ "result": [
+ {
+ "hash": "0xa476850306d6ee52b127628ded34dcf2343570873cce9c5383bd497db48d4f9b",
+ "amount": "",
+ "to": "",
+ "isL1": false,
+ "l1Token": "",
+ "l2Token": "",
+ "blockNumber": 748,
+ "blockTimestamp": null,
+ "finalizeTx": {
+ "hash": "",
+ "amount": "",
+ "to": "",
+ "isL1": false,
+ "blockNumber": 0,
+ "blockTimestamp": null
+ },
+ "claimInfo": {
+ "from": "0x031407eaaffFB4f1EC2c999bE4477E52C81de3c5",
+ "to": "0x1039057185CFe192d16c03F5656225821A193FD5",
+ "value": "0",
+ "nonce": "9",
+ "batch_hash": "0x49a18d72dbceeb957f918947b532db452c031f528e7e6bf329007066638c5e50",
+ "message": "0xa413686200000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000005686f6c6973000000000000000000000000000000000000000000000000000000",
+ "proof": "0x69b4ee6cf9a38bed79668ddd347fef2bdff44c3760c9309fa41decfd60202d22ad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb5b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d3079f53171df5c0661d2afe86c4d97b6f34278daf6a0ea9baff5b4fc979d5629a5",
+ "batch_index": "93"
+ },
+ "createdTime": null
+ }
+ ],
+ "total": 1
+ }
+}
+```
+
+Döndürülen 'result' json'unun altındaki 'claimInfo' nesnesi, işleminizi L1'de yürütmek için gereken tüm bilgileri içerir. 'relayMessageWithProof'un ihtiyaç duyduğu parametreler şunlardır: 'from', 'to', 'value', 'nonce', 'message' ve 'proof'. İşleminizi L1'de yürütmek ve sonlandırmak için bunları L1'deki 'relayMessageWithProof' işlevine sağlayın.
+
+
+
+## Messenger API
+
+Scroll sözleşmesi API dokümanlarının tamamı için lütfen [npm kitaplığını](https://www.npmjs.com/package/@scroll-tech/contracts?activeTab=code) ziyaret edin.
+
+### sendMessage
+
+```solidity
+function sendMessage(
+ address target,
+ uint256 value,
+ bytes calldata message,
+ uint256 gasLimit,
+ address refundAddress
+) external payable;
+```
+
+Bir zincirden diğerine herhangi bir veri gönderir. Zincirler arası fonksiyonları yürütmemize olanak tanır.
+
+| Parametre | Açıklama |
+| ------------- | ------------------------------------------------------------------------------------------------------------------- |
+| target | Mesajı alan hesabın adresi. Alıcı bir akıllı sözleşme veya bir EOA cüzdanı olabilir. |
+| value | Hedef sözleşme çağrılırken aktarılan Ether miktarı. |
+| message | Mesajın içeriği. Bu yürütülecek herhangi bir çağrının verileridir. |
+| gasLimit | İlgili zincirdeki mesaj aktarımını tamamlamak için gereken gaz limiti. |
+| refundAddress | İade ücretinin alınacağı hesabın adresi. |
+
+### relayMessageWithProof
+
+```solidity
+function relayMessageWithProof(
+ address from,
+ address to,
+ uint256 value,
+ uint256 nonce,
+ bytes memory message,
+ L2MessageProof memory proof
+) external;
+```
+
+Mesaj kanıtı ile birlikte L2'den L1'e mesaj aktarın.
+
+| Parametre | Açıklama |
+| --------- | ------------------------------------------------------------ |
+| from | Mesajı gönderenin adresi. |
+| to | Mesajın alıcısının adresi. |
+| value | Mesaj çağrısına iletilen msg.value. |
+| nonce | Tekrar saldırısını önlemek için mesajın nonce'ı. |
+| message | Mesajın içeriği. |
+| proof | İşlemin doğruluğunu doğrulamak için kullanılan kanıt. |
diff --git a/src/content/docs/tr/developers/scroll-contracts.mdx b/src/content/docs/tr/developers/scroll-contracts.mdx
new file mode 100644
index 000000000..221ebfb6d
--- /dev/null
+++ b/src/content/docs/tr/developers/scroll-contracts.mdx
@@ -0,0 +1,236 @@
+---
+section: developers
+date: Last Modified
+title: "Scroll Sözleşmeleri"
+lang: "tr"
+permalink: "developers/scroll-contracts"
+whatsnext: { "Ethereum ve Scroll Farkları": "/tr/developers/ethereum-and-scroll-differences" }
+excerpt: "Scroll Sepolia Test ağını kullanmaya başlayabilmeniz gereken ağ bilgileri ve sözleşme adresleri."
+---
+
+import Aside from "../../../../components/Aside.astro"
+import ToggleElement from "../../../../components/ToggleElement.astro"
+
+Bu makalede Scroll'un ve yaygın olarak kullanılan faydalı protokollerin sözleşme adreslerini bulacaksınız. [Scroll Sepolia](#scroll-sepolia-testnet) bilgisi için aşağıdaki bölüme bakın.
+
+## Ağ Bilgisi
+
+Ethereum araçlarınızı Scroll ana ağına yapılandırmak için aşağıdaki tabloyu kullanın.
+
+| Ağ Adı | Scroll | Ethereum Ana ağı |
+| ------------------ | -------------------------------------------------- | ---------------------------------------------------- |
+| RPC URL'si | [https://rpc.scroll.io/](https://rpc.scroll.io/) | [https://eth.llamarpc.com](https://eth.llamarpc.com) |
+| Zincir Kimliği | 534352 | 1 |
+| Para Birimi Sembolü| ETH | ETH |
+| Blok Gezgini URL'si| [https://scrollscan.com/](https://scrollscan.com/) | [https://etherscan.io](https://etherscan.io) |
+
+
+
Ek Scroll Ana Ağ RPC'leri ve Altyapısı
+ - [Scroll Yerel Köprüsü](https://scroll.io/bridge)
+ - [Scroll Rollup Tarayıcısı](https://scroll.io/rollupscan)
+ - [ChainList.org'daki Scroll RPC Sağlayıcıları](https://chainlist.org/chain/534352)
+ - [ChainList.org'daki Ethereum RPC Sağlayıcıları](https://chainlist.org/chain/1)
+ {/* - Ek Blok Gezginleri:
+ - [Dora](https://www.ondora.xyz/network/scroll/interactions)
+ - [L2Scan](https://scroll.l2scan.co/) */}
+
+
+
+## Scroll Sözleşmeleri
+
+### Rollup
+
+- L1 Rollup (Scroll Ağı): [`0xa13BAF47339d63B743e7Da8741db5456DAc1E556`](https://etherscan.io/address/0xa13BAF47339d63B743e7Da8741db5456DAc1E556)
+
+### ETH and ERC20 Köprüsü
+
+- L1 Ağ Geçidi Yönlendiricisi: [`0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6`](https://etherscan.io/address/0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6)
+- L2 Ağ Geçidi Yönlendiricisi: [`0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79`](https://scrollscan.com/address/0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79)
+
+### Gelişmiş Köprü Sözleşmeleri
+
+- Scroll Messenger
+ - L1 Messenger: [`0x6774Bcbd5ceCeF1336b5300fb5186a12DDD8b367`](https://etherscan.io/address/0x6774Bcbd5ceCeF1336b5300fb5186a12DDD8b367)
+ - L2 Messenger: [`0x781e90f1c8Fc4611c9b7497C3B47F99Ef6969CbC`](https://scrollscan.com/address/0x781e90f1c8Fc4611c9b7497C3B47F99Ef6969CbC)
+- ETH Köprüsü
+ - L1 ETH Ağ Geçidi: [`0x7F2b8C31F88B6006c382775eea88297Ec1e3E905`](https://etherscan.io/address/0x7F2b8C31F88B6006c382775eea88297Ec1e3E905)
+ - L2 ETH Ağ Geçidi: [`0x6EA73e05AdC79974B931123675ea8F78FfdacDF0`](https://scrollscan.com/address/0x6EA73e05AdC79974B931123675ea8F78FfdacDF0)
+ - L1 WETH Ağ Geçidi: [`0x7AC440cAe8EB6328de4fA621163a792c1EA9D4fE`](https://etherscan.io/address/0x7AC440cAe8EB6328de4fA621163a792c1EA9D4fE)
+ - L2 WETH Ağ Geçidi: [`0x7003E7B7186f0E6601203b99F7B8DECBfA391cf9`](https://scrollscan.com/address/0x7003E7B7186f0E6601203b99F7B8DECBfA391cf9)
+- ERC20 Köprüsü
+ - L1 ERC20 Standard Ağ Geçidi: [`0xD8A791fE2bE73eb6E6cF1eb0cb3F36adC9B3F8f9`](https://etherscan.io/address/0xD8A791fE2bE73eb6E6cF1eb0cb3F36adC9B3F8f9)
+ - L2 ERC20 Standard Ağ Geçidi: [`0xE2b4795039517653c5Ae8C2A9BFdd783b48f447A`](https://scrollscan.com/address/0xE2b4795039517653c5Ae8C2A9BFdd783b48f447A)
+ - L1 ERC20 Custom Ağ Geçidi: [`0xb2b10a289A229415a124EFDeF310C10cb004B6ff`](https://etherscan.io/address/0xb2b10a289A229415a124EFDeF310C10cb004B6ff)
+ - L2 ERC20 Custom Ağ Geçidi: [`0x64CCBE37c9A82D85A1F2E74649b7A42923067988`](https://scrollscan.com/address/0x64CCBE37c9A82D85A1F2E74649b7A42923067988)
+- ERC721 Köprüsü
+ - L1 ERC721 Ağ Geçidi: [`0x6260aF48e8948617b8FA17F4e5CEa2d21D21554B`](https://etherscan.io/address/0x6260aF48e8948617b8FA17F4e5CEa2d21D21554B)
+ - L2 ERC721 Ağ Geçidi: [`0x7bC08E1c04fb41d75F1410363F0c5746Eae80582`](https://scrollscan.com/address/0x7bC08E1c04fb41d75F1410363F0c5746Eae80582)
+- ERC1155 Köprüsü
+ - L1 ERC1155 Ağ Geçidi: [`0xb94f7F6ABcb811c5Ac709dE14E37590fcCd975B6`](https://etherscan.io/address/0xb94f7F6ABcb811c5Ac709dE14E37590fcCd975B6)
+ - L2 ERC1155 Ağ Geçidi: [`0x62597Cc19703aF10B58feF87B0d5D29eFE263bcc`](https://scrollscan.com/address/0x62597Cc19703aF10B58feF87B0d5D29eFE263bcc)
+- Gas Oracle (Ana ağda konuşlandırıldı)
+ - L2 Gas Oracle (*yakında kullanımdan kaldırılacak*): [`0x987e300fDfb06093859358522a79098848C33852`](https://etherscan.io/address/0x987e300fDfb06093859358522a79098848C33852)
+ - *[Şubat '24 Köprü Yükseltmesi] sonrasında(https://scroll.io/blog/protocol-upgrade-bridging-cost-reduction)*
+ - L2 Message Queue With Gas Price Oracle: [`0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B`](https://etherscan.io/address/0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B)
+
+### L2 Predeploys
+
+- Message Queue: [`0x5300000000000000000000000000000000000000`](https://scrollscan.com/address/0x5300000000000000000000000000000000000000)
+- Gas Price Oracle: [`0x5300000000000000000000000000000000000002`](https://scrollscan.com/address/0x5300000000000000000000000000000000000002)
+- Beyaz Liste: [`0x5300000000000000000000000000000000000003`](https://scrollscan.com/address/0x5300000000000000000000000000000000000003)
+- WETH L2: [`0x5300000000000000000000000000000000000004`](https://scrollscan.com/address/0x5300000000000000000000000000000000000004)
+- İşlem Ücreti Kasası: [`0x5300000000000000000000000000000000000005`](https://scrollscan.com/address/0x5300000000000000000000000000000000000005)
+
+## Scroll Ana ağındaki Protokoller
+
+### Uniswap v3
+
+- Ana Sözleşmeler
+ - Core Factory: [`0x70C62C8b8e801124A4Aa81ce07b637A3e83cb919`](https://scrollscan.com/address/0x70C62C8b8e801124A4Aa81ce07b637A3e83cb919)
+ - NFT Position Manager: [`0xB39002E4033b162fAc607fc3471E205FA2aE5967`](https://scrollscan.com/address/0xB39002E4033b162fAc607fc3471E205FA2aE5967)
+ - Router: [`0xfc30937f5cDe93Df8d48aCAF7e6f5D8D8A31F636`](https://scrollscan.com/address/0xfc30937f5cDe93Df8d48aCAF7e6f5D8D8A31F636)
+- Ek Sözleşmeler
+ - multicall2Address: [`0xC1D2e074C38FdD5CA965000668420C80316F0915`](https://scrollscan.com/address/0xC1D2e074C38FdD5CA965000668420C80316F0915)
+ - proxyAdminAddress: [`0x1E6dcAb806A42055098f23E2B3ac72D6E195F967`](https://scrollscan.com/address/0x1E6dcAb806A42055098f23E2B3ac72D6E195F967)
+ - tickLensAddress: [`0x85780e12e90D2a684eB8E7404c985b5B5c8ce7E9`](https://scrollscan.com/address/0x85780e12e90D2a684eB8E7404c985b5B5c8ce7E9)
+ - nftDescriptorLibraryAddressV1_3_0: [`0xAeE9c206ba89F3DA25EEe4636208519e0B86965B`](https://scrollscan.com/address/0xAeE9c206ba89F3DA25EEe4636208519e0B86965B)
+ - nonfungibleTokenPositionDescriptorAddressV1_3_0: [`0xACcf12204b7591B2ECCEFe737440B0f53748B191`](https://scrollscan.com/address/0xACcf12204b7591B2ECCEFe737440B0f53748B191)
+ - descriptorProxyAddress: [`0x675DD953225D296A44790dC1390a1E7eF378f464`](https://scrollscan.com/address/0x675DD953225D296A44790dC1390a1E7eF378f464)
+ - v3MigratorAddress: [`0xF00577B5Dd0DA227298E954Ed11356F264Cf93d4`](https://scrollscan.com/address/0xF00577B5Dd0DA227298E954Ed11356F264Cf93d4)
+ - v3StakerAddress: [`0xFdFbE973c9ecB036Ecfb7af697FcACe789D3f928`](https://scrollscan.com/address/0xFdFbE973c9ecB036Ecfb7af697FcACe789D3f928)
+ - quoterV2Address: [`0x2566e082Cb1656d22BCbe5644F5b997D194b5299`](https://scrollscan.com/address/0x2566e082Cb1656d22BCbe5644F5b997D194b5299)
+
+#### Ethereum Attestation Service (EAS)
+
+- EAS: [`0xC47300428b6AD2c7D03BB76D05A176058b47E6B0`](https://scrollscan.com/address/0xC47300428b6AD2c7D03BB76D05A176058b47E6B0)
+- SchemaRegistry: [`0xD2CDF46556543316e7D34e8eDc4624e2bB95e3B6`](https://scrollscan.com/address/0xD2CDF46556543316e7D34e8eDc4624e2bB95e3B6)
+- EIP712Proxy: [`0x77b7DA1c40762Cd8AFfE2069b575328EfD4D9801`](https://scrollscan.com/address/0x77b7DA1c40762Cd8AFfE2069b575328EfD4D9801)
+- Indexer: `Not deployed yet`
+
+## Ek Yararlı Sözleşmeler
+
+- Multicall3: [`0xcA11bde05977b3631167028862bE2a173976CA11`](https://scrollscan.com/address/0xcA11bde05977b3631167028862bE2a173976CA11)
+
+## Token'ler
+
+
+
+{" "}
+
+
+
+---
+
+## Scroll Sepolia Test Ağı
+
+### Ağ Bilgisi
+
+Ethereum araçlarınızı Scroll Sepolia Test ağına yapılandırmak için aşağıdaki tabloyu kullanın.
+
+| Ağ Adı | Scroll Sepolia | Ethereum Sepolia |
+| ------------------ | ----------------------------------------------------------------- | ------------------------------------------------------------ |
+| RPC URL'si | [https://sepolia-rpc.scroll.io/](https://sepolia-rpc.scroll.io/) | [https://rpc2.sepolia.org](https://rpc2.sepolia.org) |
+| Zincir Kimliği | 534351 | 11155111 |
+| Para Birimi Sembolü| ETH | ETH |
+| Blok Gezgini URL'si| [https://sepolia.scrollscan.com](https://sepolia.scrollscan.com/) | [https://sepolia.etherscan.io](https://sepolia.etherscan.io) |
+
+
+
Ek Scroll Sepolia RPC'leri ve Altyapısı
+ - [Scroll Sepolia Yerel Köprüsü](https://sepolia.scroll.io/bridge)
+ - [Scroll Sepolia Rollup Tarayıcısı](https://sepolia.scroll.io/rollupscan)
+ - [ChainList.org'daki Sepolia RPC Sağlayıcıları](https://chainlist.org/chain/534351)
+ - [ChainList.org'daki Ethereum Sepolia RPC Sağlayıcıları](https://chainlist.org/chain/11155111)
+ - Ek Blok Gezginleri:
+ - [Dora](https://www.ondora.xyz/network/scroll-sepolia/interactions)
+ - [L2Scan](https://scroll.l2scan.co/)
+
+
+
+### Scroll Sepolia Sözleşmeleri
+
+#### Rollup
+
+- L1 Rollup (Scroll Ağı): [`0x2D567EcE699Eabe5afCd141eDB7A4f2D0D6ce8a0`](https://sepolia.etherscan.io/address/0x2D567EcE699Eabe5afCd141eDB7A4f2D0D6ce8a0)
+
+#### ETH and ERC20 Köprüsü
+
+- L1 Gateway Router: [`0x13FBE0D0e5552b8c9c4AE9e2435F38f37355998a`](https://sepolia.etherscan.io/address/0x13FBE0D0e5552b8c9c4AE9e2435F38f37355998a)
+- L2 Gateway Router: [`0x9aD3c5617eCAa556d6E166787A97081907171230`](https://sepolia.scrollscan.com/address/0x9aD3c5617eCAa556d6E166787A97081907171230)
+
+#### Gelişmiş Köprü Sözleşmeleri
+
+- Scroll Messenger
+ - L1 Messenger: [`0x50c7d3e7f7c656493D1D76aaa1a836CedfCBB16A`](https://sepolia.etherscan.io/address/0x50c7d3e7f7c656493D1D76aaa1a836CedfCBB16A)
+ - L2 Messenger: [`0xBa50f5340FB9F3Bd074bD638c9BE13eCB36E603d`](https://sepolia.scrollscan.com/address/0xBa50f5340FB9F3Bd074bD638c9BE13eCB36E603d)
+- ETH Köprüsü
+ - L1 ETH Ağ Geçidi: [`0x8A54A2347Da2562917304141ab67324615e9866d`](https://sepolia.etherscan.io/address/0x8A54A2347Da2562917304141ab67324615e9866d)
+ - L2 ETH Ağ Geçidi: [`0x91e8ADDFe1358aCa5314c644312d38237fC1101C`](https://sepolia.scrollscan.com/address/0x91e8ADDFe1358aCa5314c644312d38237fC1101C)
+ - L1 WETH Ağ Geçidi: [`0x3dA0BF44814cfC678376b3311838272158211695`](https://sepolia.etherscan.io/address/0x3dA0BF44814cfC678376b3311838272158211695)
+ - L2 WETH Ağ Geçidi: [`0x481B20A927206aF7A754dB8b904B052e2781ea27`](https://sepolia.scrollscan.com/address/0x481B20A927206aF7A754dB8b904B052e2781ea27)
+- ERC20 Köprüsü
+ - L1 ERC20 Standard Ağ Geçidi: [`0x65D123d6389b900d954677c26327bfc1C3e88A13`](https://sepolia.etherscan.io/address/0x65D123d6389b900d954677c26327bfc1C3e88A13)
+ - L2 ERC20 Standard Ağ Geçidi: [`0xaDcA915971A336EA2f5b567e662F5bd74AEf9582`](https://sepolia.scrollscan.com/address/0xaDcA915971A336EA2f5b567e662F5bd74AEf9582)
+ - L1 ERC20 Custom Ağ Geçidi: [`0x31C994F2017E71b82fd4D8118F140c81215bbb37`](https://sepolia.etherscan.io/address/0x31C994F2017E71b82fd4D8118F140c81215bbb37)
+ - L2 ERC20 Custom Ağ Geçidi: [`0x058dec71E53079F9ED053F3a0bBca877F6f3eAcf`](https://sepolia.scrollscan.com/address/0x058dec71E53079F9ED053F3a0bBca877F6f3eAcf)
+- ERC721 Köprüsü
+ - L1 ERC721 Ağ Geçidi: [`0xEF27A5E63aa3f1B8312f744b9b4DcEB910Ba77AC`](https://sepolia.etherscan.io/address/0xEF27A5E63aa3f1B8312f744b9b4DcEB910Ba77AC)
+ - L2 ERC721 Ağ Geçidi: [`0x179B9415194B67DC3c0b8760E075cD4415785c97`](https://sepolia.scrollscan.com/address/0x179B9415194B67DC3c0b8760E075cD4415785c97)
+- ERC1155 Köprüsü
+ - L1 ERC1155 Ağ Geçidi: [`0xa5Df8530766A85936EE3E139dECE3bF081c83146`](https://sepolia.etherscan.io/address/0xa5Df8530766A85936EE3E139dECE3bF081c83146)
+ - L2 ERC1155 Ağ Geçidi: [`0xe17C9b9C66FAF07753cdB04316D09f52144612A5`](https://sepolia.scrollscan.com/address/0xe17C9b9C66FAF07753cdB04316D09f52144612A5)
+- Gas Oracle (Sepolia'da konuşlandırıldı)
+ - L1 Message Queue With Gas Price Oracle: [`0xF0B2293F5D834eAe920c6974D50957A1732de763`](https://sepolia.etherscan.io/address/0xF0B2293F5D834eAe920c6974D50957A1732de763)
+ - L2 Gas Oracle (*deprecated*): [`0x247969F4fad93a33d4826046bc3eAE0D36BdE548`](https://sepolia.etherscan.io/address/0x247969F4fad93a33d4826046bc3eAE0D36BdE548)
+
+#### L2 Predeploys
+
+- Message Queue: [`0x5300000000000000000000000000000000000000`](https://sepolia.scrollscan.com/address/0x5300000000000000000000000000000000000000)
+- Gas Price Oracle: [`0x5300000000000000000000000000000000000002`](https://sepolia.scrollscan.com/address/0x5300000000000000000000000000000000000002)
+- Whitelist: [`0x5300000000000000000000000000000000000003`](https://sepolia.scrollscan.com/address/0x5300000000000000000000000000000000000003)
+- WETH L2: [`0x5300000000000000000000000000000000000004`](https://sepolia.scrollscan.com/address/0x5300000000000000000000000000000000000004)
+- Transaction Fee Vault: [`0x5300000000000000000000000000000000000005`](https://sepolia.scrollscan.com/address/0x5300000000000000000000000000000000000005)
+
+### Protokoller
+
+#### Uniswap v3
+
+- Frontend website: [https://uniswap-showcase.sepolia.scroll.xyz/](https://uniswap-showcase.sepolia.scroll.xyz/)
+- Ana Sözleşmeler
+ - Core Factory: [`0xB856587fe1cbA8600F75F1b1176E44250B11C788`](https://sepolia.scrollscan.com/address/0xB856587fe1cbA8600F75F1b1176E44250B11C788)
+ - NFT Position Manager: [`0xbbAd0e891922A8A4a7e9c39d4cc0559117016fec`](https://sepolia.scrollscan.com/address/0xbbAd0e891922A8A4a7e9c39d4cc0559117016fec)
+ - Router: [`0x17AFD0263D6909Ba1F9a8EAC697f76532365Fb95`](https://sepolia.scrollscan.com/address/0x17AFD0263D6909Ba1F9a8EAC697f76532365Fb95)
+- Ek Sözleşmeler
+ - multicall2Address: [`0x8c181f4B9040F1a2C941EfD3b608712cF86F1957`](https://sepolia.scrollscan.com/address/0x8c181f4B9040F1a2C941EfD3b608712cF86F1957)
+ - proxyAdminAddress: [`0xD4A9910732b6f301F6F210Ebe7a3dBf16d9E9DD4`](https://sepolia.scrollscan.com/address/0xD4A9910732b6f301F6F210Ebe7a3dBf16d9E9DD4)
+ - tickLensAddress: [`0x9804Da978427a49929f2E6Ea32A9594F03f9296e`](https://sepolia.scrollscan.com/address/0x9804Da978427a49929f2E6Ea32A9594F03f9296e)
+ - nftDescriptorLibraryAddressV1_3_0: [`0x45Bd3B62B7A3aA53371c98049b0f7A9C1A4B5a6c`](https://sepolia.scrollscan.com/address/0x45Bd3B62B7A3aA53371c98049b0f7A9C1A4B5a6c)
+ - nonfungibleTokenPositionDescriptorAddressV1_3_0: [`0x24d4E4a572Dc1e0dbF92a0d7768Ac80df516b2C2`](https://sepolia.scrollscan.com/address/0x24d4E4a572Dc1e0dbF92a0d7768Ac80df516b2C2)
+ - descriptorProxyAddress: [`0xa8986417d0EAe50607696b9b0cb7ec5aFBE67765`](https://sepolia.scrollscan.com/address/0xa8986417d0EAe50607696b9b0cb7ec5aFBE67765)
+ - v3MigratorAddress: [`0x38E33D067F03a5cDc02C301b2c306cb0414549Bf`](https://sepolia.scrollscan.com/address/0x38E33D067F03a5cDc02C301b2c306cb0414549Bf)
+ - v3StakerAddress: [`0xe7b82794Cab21e665a3e6f8ea562d392AA6E0619`](https://sepolia.scrollscan.com/address/0xe7b82794Cab21e665a3e6f8ea562d392AA6E0619)
+ - quoterV2Address: [`0xd5dd33650Ef1DC6D23069aEDC8EAE87b0D3619B2`](https://sepolia.scrollscan.com/address/0xd5dd33650Ef1DC6D23069aEDC8EAE87b0D3619B2)
+
+#### Aave
+
+Göz atın [Github gist](https://gist.github.com/dghelm/7fe68f0a524f30846e1142721c081d84).
+
+#### Ethereum Attestation Service (EAS)
+
+- EAS: [`0xaEF4103A04090071165F78D45D83A0C0782c2B2a`](https://sepolia.scrollscan.com/address/0xaEF4103A04090071165F78D45D83A0C0782c2B2a)
+- SchemaRegistry: [`0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797`](https://sepolia.scrollscan.com/address/0x55D26f9ae0203EF95494AE4C170eD35f4Cf77797)
+- EIP712Proxy: [`0xB3574f76b1720E61FdA98702c7016674CD6Eaa7b`](https://sepolia.scrollscan.com/address/0xB3574f76b1720E61FdA98702c7016674CD6Eaa7b)
+- Indexer: [`0x7C2cb1eDC328491da52de2a0afc44D3B0Ae7ee17`](https://sepolia.scrollscan.com/address/0x7C2cb1eDC328491da52de2a0afc44D3B0Ae7ee17)
+
+### Ek Faydalı Sözleşmeler
+
+- Multicall3: [`0xcA11bde05977b3631167028862bE2a173976CA11`](https://sepolia.scrollscan.com/address/0xcA11bde05977b3631167028862bE2a173976CA11)
+
+### Token'lar
+
+
+
+- Gho Token: [`0xD9692f1748aFEe00FACE2da35242417dd05a8615`](https://sepolia.scrollscan.com/address/0xD9692f1748aFEe00FACE2da35242417dd05a8615)
diff --git a/src/content/docs/tr/developers/transaction-fees-on-scroll.mdx b/src/content/docs/tr/developers/transaction-fees-on-scroll.mdx
new file mode 100644
index 000000000..e04f2e722
--- /dev/null
+++ b/src/content/docs/tr/developers/transaction-fees-on-scroll.mdx
@@ -0,0 +1,192 @@
+---
+section: developers
+date: Last Modified
+title: "Scroll'da İşlem Ücretleri"
+lang: "tr"
+permalink: "developers/transaction-fees-on-scroll"
+whatsnext: { "Sözleşme Dağıtımı Eğitimi": "/developers/guides/contract-deployment-tutorial/" }
+excerpt: "Scroll'da L1 ve L2 işlem ücretlerinin nasıl çalıştığını anlayın "
+---
+
+import Aside from "../../../../components/Aside.astro"
+
+## Genel Bakış
+
+Scroll'da işlem ücretleri, destek verdiği katmana (Katman 1) göre oldukça düşüktür. Kullanıcılar ve geliştiriciler için Scroll'daki işlem ücretleri, Ethereum ana ağında olduğuna benzer şekilde çalışır gibi görünür. Mevcut araçlar, cüzdanlar ve kodlar da muhtemelen olduğu gibi çalışacaklardır. Ancak cüzdanda gösterilen işlem ücreti, kullanılan yazılım Scroll'un ücret hesaplamalarından özellikle haberdar olmadığı sürece resmin tamamını içermeyecektir.
+
+L2 rollup'larındaki işlem maliyetleri tasarımları nedeniyle L1'in maliyetlerine bağlıdır. Ethereum'un güvenliğinden yararlanmak için Scroll'un, L1'de veri saklanması ve doğrulanmasında gereken işlem verilerinin ve kanıtların maliyetini de hesaba katması gerekir.
+
+Ethereum ana ağıyla karşılaştırıldığında Scroll, bunu yapmak için işlem ücreti hesaplamasına bazı yeni boyutlar getiriyor. Bir işlemin nihai maliyeti birkaç bölümden oluşur:
+
+- **L2 ücreti**
+ - L1'dekiyle aynı şekilde hesaplanır; "gas_price * gas_used" değerine eşittir
+- **L1 ücreti**
+ - Bu ek ücret, veri kullanılabilirliği için L1'e veri gönderilmesini kapsar. L1 üzerinden başlatılan işlemlerde bu ücret ödenmez.
+ - İşlemin çağrı verilerinin(calldata) boyutuna göre hesaplanır
+ - ETH, ücret karşılığında kullanıcının Scroll'daki bakiyesinden otomatik olarak düşülür
+
+Yüksek düzeyden bakacak olursak; **L2 ücreti** işleminizi L2 sıralayıcısında gerçekleştirmenin maliyetidir, **L1 ücreti** ise bu işlemi L1'de gerçekleştirmenin maliyetidir.
+
+Kısacası, "totalTxFee = l2Fee + l1Fee", tamamı Scroll ağının yerel gas tokenı olan ETH cinsinden ifade edilir.
+
+
+
+## L2 Ücretleri
+
+Scroll'daki işlemler, Ethereum'da olduğu gibi, hesaplamaları yürütme ve ürettikleri verileri saklama masraflarını ödemek zorundadır.
+
+### Yürütme Ücretinin Hesaplanması
+
+L2 yürütme ücreti basittir:
+
+```javascript
+l2TransactionExecutionFee = l2TransactionGasUsed * l2TransactionGasPrice
+```
+
+Toplam ücret, işlemin ne yaptığına ("l2TransactionGasUsed") ve mevcut piyasa koşullarına ("l2TransactionGasPrice") bağlıdır. Kullanıcılar gaz fiyatını belirler ve "gas used", bir Scroll düğümünde "estimateGas" RPC uç noktası çağrılarak değerlendirilir.
+
+Başka bir deyişle, yürütme ücreti tam olarak [EIP1559](https://eips.ethereum.org/EIPS/eip-1559) Ethereum öncesi gibi hesaplanır.
+
+## L1 Ücreti
+
+Her işlemin çağrı verileri Ethereum'a taahhüt edilmelidir, bu da "L1 Ücreti" olarak adlandırılan ek bir işlem ücretine tabi olur. Bunu yapmadan Scroll yalnızca L1 verilerinden yeniden oluşturulamazdı.
+
+İşlemler birer birer gerçekleştirilmez; blok grupları (ve işlem blokları) halinde toplanırlar. Bireysel bir işlemin maliyeti, veri yükündeki sıfırlar ve sıfır olmayan bytelara göre hesaplanır.
+
+### L1 Veri Ücretinin Tahmin Edilmesi
+
+Scroll, önceden konuşlandırılmış bir "L1GasPriceOracle"a sahiptir ve hem Scroll hem de Scroll Sepolia'da ([`0x5300000000000000000000000000000000000000002`](https://sepolia-blockscout.scroll.io/address/0x530000000000000000000000000000000000000002) adresinden erişilebilir durumdadır). Belirli bir işlemin ham verileri için L1 veri ücretini tahmin etmek için bir "getL1Fee" yöntemi sağlar.
+
+```solidity
+function getL1Fee(bytes memory _data) external view override returns (uint256);
+```
+
+
+
+### Gaz Oracle'ı ile L1 Veri Ücretinin Hesaplanması
+
+Bahsedildiği gibi, 'L1GasPriceOracle' verilen ham işlem verilerine göre L1 gaz ücretini tahmin etmek için kullanılır. Bu, Scroll tarafından çalıştırılan bir aktarıcı tarafından güncellenen bir **push oracle**'dır.
+
+İstenecek verinin ücreti birden fazla faktöre bağlıdır:
+
+- İmzalı RLP kodlu bir işlemin "sıfırları" ve "sıfır olmayan" byteları
+- `l1BaseFee` - L1'deki mevcut taban ücret
+- "overhead" - Bir veri taahhüdü işleminin ek gaz yükü
+- `scalingFactor` - Fiyat artışlarını hesaba katmak için kullanılan bir ölçeklendirme faktörü
+- `PRECISION` - Nihai ücreti ölçeklendirmek için kullanılan bir sabit
+
+L1 veri ücretini hesaplamak için aşağıdaki adımlar gerçekleştirilir:
+
+1. 'L1GasPriceOracle' sözleşmesindeki 'l1BaseFee', 'overhead' ve 'scalar' adlı üç alanı oku. Sözleşmedeki bu alanlara ilişkin yuvalar şunlardır:
+
+ | Alan | Slot |
+ | --------- | ---- |
+ | l1BaseFee | 1 |
+ | overhead | 2 |
+ | scalar | 3 |
+
+2. İşlemdeki sıfır byteları ve sıfır olmayan byteları say.
+3. `TX_DATA_ZERO_GAS = 4`, `TX_DATA_NON_ZERO_GAS = 16`[^eip-2028] ve `PRECISION = 1e9`'i göz önüne alarak L1 veri ücretini hesapla:
+
+ ```javascript
+ l1Gas = zeros * TX_DATA_ZERO_GAS + (nonzeros + 4) * TX_DATA_NON_ZERO_GAS
+ l1GasFee = ((l1Gas + overhead) * l1BaseFee * scalar) / PRECISION
+ ```
+
+ RLP kodlu işlemdeki byte sayısını depolamak için sıfır olmayan bytelarda ek 4 byte ayırırız.
+
+[^eip-2028]: Daha fazla bilgi için bkz. [EIP-2028](https://eips.ethereum.org/EIPS/eip-2028).
+
+### L1GasPriceOracle API
+
+#### overhead
+
+```solidity
+function overhead() external view returns (uint256);
+```
+
+Geçerli L1 ücreti gaz yükünü döndürür
+
+#### scalar
+
+```solidity
+function scalar() external view returns (uint256);
+```
+
+Geçerli l1 ücret skaler değerini döndürür
+
+#### l1BaseFee
+
+```solidity
+function l1BaseFee() external view returns (uint256);
+```
+
+Bilinen en son l1 taban ücretini döndürür
+
+#### getL1Fee
+
+```solidity
+function getL1Fee(bytes memory data) external view returns (uint256);
+```
+
+RLP kodlu giriş işleminin(input) boyutuna, mevcut L1 taban ücretine ve çeşitli dinamik parametrelere göre L1 kısmının ücretini hesaplar.
+
+**Döndürür:** İşlem için ödenmesi gereken L1 ücreti
+
+| Parametre | Açıklama |
+| --------- | ----------------------------------------------------------- |
+| data | L1 ücretini almak için kullanılan, imzalanmış tamamen RLP kodlu işlem. |
+
+#### getL1GasUsed
+
+```solidity
+function getL1GasUsed(bytes memory data) external view returns (uint256);
+```
+
+Bir işlem için kullanılan L1 gazının miktarını hesaplar. İşlemin ve durum köklerinin L1'e kaydedilmesine ilişkin işlem başına gaz ek yükünü temsil eden ek yükü ekler. Giriş işleminin imzası olmadığı gerçeğini hesaba katarak 74 bytelık dolgu ekler.
+
+**Döndürür:** İşlemi yayınlamak için kullanılan L1 gazı miktarı.
+
+| Parametre | Açıklama |
+| --------- | ----------------------------------------------------------- |
+| data | L1 ücretini almak için kullanılan, imzalanmış tamamen RLP kodlu işlem. |
+
+## L1 Kaynaklı İşlemler
+
+L1'den L2'ye mesajlaşırken kullanıcı L1'deki tüm işlem ücretlerini öder. Kullanıcı L1'in kendi gaz ücretini öder ancak bu sebepten Scroll'a L1 Veri Ücreti ödemesine gerek yoktur. Fakat L1 işlemlerinde L2 Yürütme Ücretlerinin hesaba katılması ve ne kadar L2 gazı ödeyeceklerini bilmeleri gerekecek.
+
+L1'deki sözleşmeler, belirli bir işlem için gaz ücretini almak üzere L1'e dağıtılmış L2 Gaz Fiyatı Oracle sözleşmesini kullanabilir. Oracle aynı zamanda mevcut l2BaseFee'yi ve belirli bir gas limiti için tahmini alanlar arası(cross-domain) mesaj ücretini de sağlar.
+
+Ana ağda, "L2GasPriceOracle" [`0x987e300fDfb06093859358522a79098848C33852`](https://etherscan.io/address/0x987e300fDfb06093859358522a79098848C33852) adresinde konuşlandırılır.
+
+Sepolia'da, son versiyona yükseltilmiş bir "L1MessageQueueWithGasPriceOracle" kullanılmalı ve [`0xF0B2293F5D834eAe920c6974D50957A1732de763`](https://sepolia.etherscan.io/address/0xF0B2293F5D834eAe920c6974D50957A1732de763) adresine dağıtılmalıdır.
+
+Sisteminiz zincir dışı mekanizmaları destekliyorsa, belirli bir işlem için gerekli gaza ilişkin bir tahmin almak üzere herhangi bir Scroll RPC düğümünde "eth_estimateGas" ve "eth_gasPrice"ı da çağırabilirsiniz.
+
+
+{/* TODO: Add full documentation of key methods */}
+
+## Gelecek Yol Haritası
+
+Şu anda, L1'de kanıt üretimi için gereken hesaplama ve kanıt doğrulaması için gereken gas, Scroll ve çeşitli kanıtlama ortakları tarafından karşılanmaktadır. L2 Gaz Fiyatına bir taban değer belirlenerek kısmen halledilmiştir.
+
+Kanıtlayıcı ağı merkeziyetsizleştikçe, sistemin sürdürülebilir ve ölçeklenebilir olması için kanıt oluşturmaya yönelik teşviklerin protokole dahil edilmesi gerekecektir.
+
+Nihai gaz maliyetinin kanıt üretme maliyetini net bir şekilde içermesini bekliyoruz. Daha fazla protokol optimizasyonu ile her kanıtta birçok işlem kapsandığından kullanıcı için bu maliyet minimum düzeyde olacaktır.
diff --git a/src/content/docs/tr/developers/verifying-smart-contracts.mdx b/src/content/docs/tr/developers/verifying-smart-contracts.mdx
new file mode 100644
index 000000000..b6e53a64a
--- /dev/null
+++ b/src/content/docs/tr/developers/verifying-smart-contracts.mdx
@@ -0,0 +1,128 @@
+---
+section: developers
+date: Last Modified
+title: "Akıllı Sözleşmeleri Doğrulama"
+lang: "tr"
+permalink: "developers/verifying-smart-contracts"
+whatsnext: { "Scroll Sözleşmeleri": "/tr/developers/scroll-contracts" }
+excerpt: "Scroll destekli geliştirici araçlarıyla akıllı sözleşmelerinizi kolayca doğrulayın"
+---
+
+import Aside from "../../../../components/Aside.astro"
+import ClickToZoom from "../../../../components/ClickToZoom.astro"
+import verify1 from "./_images/verify1.png"
+import CodeSample from "../../../../components/CodeSample/CodeSample.astro"
+
+Akıllı sözleşmelerinizi dağıttıktan sonra kodunuzu bir blok gezgininde doğrulamanız önemlidir. Bu, geliştirici araçlarını veya web kullanıcı arayüzlerini kullanarak otomatik bir şekilde yapılabilir.
+
+## Geliştirici Araçlarını Kullanma
+
+Çoğu akıllı sözleşme aracı, sözleşmelerinizi Etherscan'de kolayca doğrulamak için eklentilere sahiptir. Blockscout, Etherscan'in sözleşme doğrulama API'lerini destekler; dolayısıyla bu araçları, bu blok kaşiflerinden herhangi birinin API'lerini kullanarak kullanmak kolaydır.
+
+| Ağ | Scroll | Scroll Sepolia |
+| ---------- | -------------------------------- | ---------------------------------------- |
+| Scrollscan | https://api.scrollscan.com/api | https://api-sepolia.scrollscan.com/api |
+| Blockscout | https://blockscout.scroll.io/api | https://sepolia-blockscout.scroll.io/api |
+
+
+
+### Hardhat
+
+'hardhat.config.ts'yi Scroll'un RPC'sine ve blok gezgini API'sine işaret edecek şekilde değiştirin. Blockscout için sahte bir "apiKey" değeri gereklidir, ancak bu değer için herhangi bir değer işe yarar. Scrollscan için kendi API anahtarınızı kullanın.
+
+Örneğin Blockscout'ta Scroll Sepolia kullanıyorsanız yapılandırmanız şu şekilde görünecektir:
+```javascript
+...
+
+const config: HardhatUserConfig = {
+ ...
+ networks: {
+ scrollSepolia: {
+ url: 'https://sepolia-rpc.scroll.io' || '',
+ accounts:
+ process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [],
+ },
+ },
+ etherscan: {
+ apiKey: {
+ scrollSepolia: 'abc',
+ },
+ customChains: [
+ {
+ network: 'scrollSepolia',
+ chainId: 534351,
+ urls: {
+ apiURL: 'https://sepolia-blockscout.scroll.io/api',
+ browserURL: 'https://sepolia-blockscout.scroll.io/',
+ },
+ },
+ ],
+ },
+}
+
+...
+```
+
+Artık aşağıdaki komutu çalıştırarak akıllı sözleşmeyi doğrulayabilirsiniz.
+
+```solidity
+npx hardhat verify --network scrollSepolia
+```
+
+Örneğin, yapıcıda iki uint parametresi alan bir akıllı sözleşme şu şekilde görünmelidir:
+
+```solidity
+npx hardhat verify --network scrollSepolia 0xD9880690bd717189cC3Fbe7B9020F27fae7Ac76F 123 456
+```
+
+
+
+### Foundry
+
+Foundry'yi kullanırken "verify-contract" komutu sözleşmelerin doğrulanması sürecinin otomatikleştirilmesine yardımcı olur. Sözleşmenizde yapıcı argümanlar varsa, bunları ABI kodlu biçimde `--constructor-args` seçeneğiyle belirtebilirsiniz. Örneğin, kurucunuz iki "uint256" değişkeni alıyorsa:
+```bash
+ --constructor-args $(cast abi-encode "constructor(uint256,uint256)" 0 7)
+```
+
+Belirleyebileceğiniz diğer seçenekler için [Foundry belgelerine](https://book.getfoundry.sh/reference/forge/forge-verify-contract) bakın.
+
+
+#### Scrollscan
+
+```bash
+forge verify-contract \
+ --verifier-url https://api-sepolia.scrollscan.com/api \
+ --etherscan-api-key \
+ --constructor-args
+```
+
+
+#### Blockscout
+
+Doğrulama sağlayıcısını "blockscout" olarak belirtin.
+
+##### Scroll
+```bash
+forge verify-contract \
+ --verifier-url https://blockscout.scroll.io/api\? \
+ --verifier blockscout \
+ --constructor-args
+```
+
+##### Scroll Sepolia
+```bash
+forge verify-contract \
+ --verifier-url https://sepolia-blockscout.scroll.io/api\? \
+ --verifier blockscout \
+ --constructor-args
+```
+
+
\ No newline at end of file
diff --git a/src/content/docs/tr/getting-started/overview.md b/src/content/docs/tr/getting-started/overview.md
new file mode 100644
index 000000000..644d0a643
--- /dev/null
+++ b/src/content/docs/tr/getting-started/overview.md
@@ -0,0 +1,39 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Scroll'a Genel Bakış"
+lang: "tr"
+permalink: "docs/conceptual-overview/"
+excerpt: "ZK Rollups and Scroll"
+whatsnext: { "Kullanıcı kılavuzu": "/tr/user-guide/", "Scroll üzerinde geliştirmek": "/tr/developers/" }
+---
+
+#### Scroll Dokümantasyonu'na hoş geldiniz!
+
+Scroll, Ethereum için güvenlik odaklı bir ölçeklenebilirlik çözümüdür; ölçekleme tasarımındaki ve zero knowledge kanıtlarındaki yenilikleri kullanarak Ethereum üzerinde yeni bir katman oluşturmayı hedeflemektedir. Scroll ağı, Ethereum'un tek başına olduğundan daha erişilebilirdir, daha duyarlıdır ve aynı anda daha fazla kullanıcıyı destekleyebilir. Eğer daha önce Ethereum üzerinde bir uygulama kullandıysanız veya geliştirdiyseniz, Scroll'da kendinizi evinizde hissedeceksiniz.
+
+Scroll'u kullanmadan önce Scroll Sepolia test ağını ücretsiz varlıklarla denemek ister misiniz? [Kullanıcı kılavuzumuza](/tr/user-guide/) göz atın.
+
+## Scroll ne inşa ediyor?
+
+Scroll, Ethereum'u ölçeklendirmek için teknoloji geliştiriyor.
+
+Ethereum, merkeziyetsiz uygulamaları desteklemek konusunda önde gelen blokzinciri ağı olmasına rağmen, popülerliği daha yüksek maliyetleri de beraberinde getiriyor ve bu durum gelecek kullanıcılar ve geliştiriciler için bir engel oluşturuyor.
+
+Zero knowledge kanıtları alanındaki öncü araştırmalardan yararlanarak, Scroll, Ethereum üzerinde bir Katman 2 rollup ağı inşa ediyor. Ethereum topluluğundaki diğer kişilerle açık kaynaklı işbirliği içinde olan ekip, tıpkı Ethereum gibi davranan ağdaki tüm faaliyetlerin Ethereum üzerindeki akıllı sözleşmelerle güvence altına alınmasına olanak tanıyan bir "zkEVM" oluşturdu. Ağ, tüm işlemleri Ethereum'da yayınlar ve zkEVM, Scroll ağının Ethereum kurallarına uyduğuna dair kriptografik "kanıtlar" oluşturur ve yayınlar.
+
+Sonuç olarak, Ethereum'daki akıllı sözleşmeler Scroll'daki her işlemin bu kanıtlar için geçerli olduğunu doğrular ve ağı inanılmaz bir güvenliğe, merkeziyetsizliğe ve sansür direncine kavuşturur. Ethereum için bu düzeyde güvenlik ve ölçeklenebilirlik yalnızca zero knowledge kriptografisi, blokzincir protokol tasarımı ve donanım hızlandırmadaki son gelişmelerle mümkün olabilir.
+
+Daha fazla bilgi için mimarimiz hakkında bilgi almak için [Scroll Mimarisi](/tr/technology/) sayfasına bakın.
+
+## Scroll'u şu anda kullanabilir miyim?
+
+Scroll ana ağı Ethereum üzerinde aktif! Ayrıca, Ethereum Sepolia üzerinde çalışan Scroll Sepolia test ağımız da bulunuyor. [Kapsamlı bir kılavuzumuz](/tr/user-guide/) olsa da, Ethereum'u kullanmaya aşina iseniz, birkaç dakika içinde başlayabilirsiniz:
+
+- [Köprü](https://scroll.io/bridge) sayfamızı veya [Scroll Sepolia Köprüsü](https://sepolia.scroll.io/bridge) sayfamızı ziyaret edin ve cüzdanınızı bağlayın.
+- Ethereum ana ağından Scroll'a token gönderin. (veya bir Scroll Sepolia [musluğu](/tr/user-guide/faucet) kullanın)
+- Scroll Sepolia test ağı dApp'lerini deneyin, örneğin [Uniswap Vitrini](http://uniswap-showcase.sepolia.scroll.xyz/) veya [Aave](https://app.aave.com/) -- Scroll Sepolia Ağı'nı seçtiğinizden emin olun!
+
+## Scroll ne yönde ilerliyor?
+
+Scroll ana ağımızı Ethereum üzerinde yayınladık, ancak hala daha yapılacak çok iş buluyor. Sırada yığının her bileşenini merkeziyetsizleştirmek var. Güncel kalmak için [bloğumuza](https://scroll.io/blog) göz atın, [Discord](https://discord.gg/scroll) veya [Twitter](https://twitter.com/scroll_zkp) hesaplarımızı takip edin.
diff --git a/src/content/docs/tr/learn/index.mdx b/src/content/docs/tr/learn/index.mdx
new file mode 100644
index 000000000..e1adb6972
--- /dev/null
+++ b/src/content/docs/tr/learn/index.mdx
@@ -0,0 +1,30 @@
+---
+section: learn
+title: "Öğren"
+lang: "tr"
+permalink: "learn/"
+excerpt: "Ethereum ölçeklenebilirliği ve zero knowledge kanıtları hakkında daha fazlasını öğrenin."
+---
+
+import NavCard from "../../../../components/NavCard.astro"
+import TechnologySvg from "../../../../assets/svgs/home/home-technology.svg?raw"
+import LearnSvg from "../../../../assets/svgs/home/home-learn.svg?raw"
+
+Scroll, blokzincir protokolleri ve zero knowledge kriptografisinden araştırma ve mühendislik çalışmalarını bir araya getiriyor. Daha derinlemesine bilgi için okumaya devam edin ve ek kaynaklara göz atın.
+
+Belirli bir konunun da ele alınmasını mı istiyorsunuz? Github repo'muzda bir [issue](https://github.com/scroll-tech/scroll-documentation/issues/new?assignees=&labels=new+content%2Ctriage&projects=&template=new_content.yml&title=%5BNew+Content%5D%3A+%3Cyour-title-here%3E) oluşturun.
+
+
+
+
+
diff --git a/src/content/docs/tr/learn/intro-to-rollups.md b/src/content/docs/tr/learn/intro-to-rollups.md
new file mode 100644
index 000000000..91e13c157
--- /dev/null
+++ b/src/content/docs/tr/learn/intro-to-rollups.md
@@ -0,0 +1,51 @@
+---
+section: learn
+date: Last Modified
+title: "Rollup'lara Giriş"
+lang: "tr"
+permalink: "learn/intro-to-rollups"
+excerpt: "Rolluplar, Ethereum ekosistemindeki en yaygın ikinci katman ölçekleme çözümüdür."
+whatsnext: { "Scroll Rollup Süreci": "/tr/technology/chain/rollup" }
+---
+
+## Rollup nedir?
+
+Rolluplar, Ethereum ekosistemindeki en yaygın katman 2 ölçeklenme çözümüdür ve Ethereum yol haritasının [merkezi bir parçası](https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698) olarak görülmektedir.
+
+Bir rollup, işlem gruplarını zincir dışında işler (yani katman 1'de değil) ve ardından ortaya çıkan verileri zincir üstünde yayınlar (yani katman 1'de).
+
+Her işlemin yürütülmesi zincir-dışı olarak gerçekleştirilir ve bu işlemlerin katman 1 düğümleri tarafından yeniden yürütülmesi gerekmez. Bu da, katman 1'in merkeziyetsizini etkilemeden yüksek işlem hızına olanak tanır.
+
+Bir rollup'un güvenli olması için, zincir-dışı hesaplamanın (işlemlerin işlenmesi) doğru bir şekilde gerçekleştirildiğini kanıtlaması gerekir. Zincir dışı hesaplamanın geçerliliğini kanıtlamanın iki temel mekanizması vardır: geçerlilik kanıtları(validity proofs) ve dolandırıcılık kanıtları(fraud proofs).
+
+## Optimistic rollup nedir?
+
+Bir optimistic rollup, yaptığı hesaplamaların geçerliliğini savunmak için dolandırıcılık kanıtlarını kullanan bir rollup'tır.
+
+Dolandırıcılık kanıtları, kullanıcıların L2'de gerçekleştirilen herhangi bir hesaplamanın geçersizliğini sorgulamasına ve kanıtlamasına olanak tanıyan bir mekanizmadır. Bir dolandırıcılık kanıtı başarıyla gönderildiğinde, L2 bir önceki bir duruma geri döndürülebilir ve geçersiz hesaplama düzeltilebilir. Dolandırıcılık kanıtları, en az bir dürüst tarafın L2 işlemlerinin doğru bir şekilde yürütüldüğünü kontrol etmesine dayanır.
+
+## ZK rollup nedir?
+
+Bir ZK rollup, yaptığı hesaplamaların geçerliliğini savunmak için geçerlilik kanıtlarını kullanan bir rollup'tır.
+
+Bir ZK rollup, bir işlem grubunu yürüttüğünde ve sonucu L1'e gönderdiğinde, aynı zamanda bir geçerlilik kanıtı da gönderir. Bu matematiksel kanıt, sonuç ile işlem grubunun doğru bir şekilde yürütülmesiyle ortaya çıkan durumun, aynı olduğunu kanıtlar.
+
+Bugünlerde birden çok türde ZK rollup bulunuyor, bunlar genel olarak zkVM'ler (zk Sanal Makineler) veya zkEVM'ler (zk Ethereum Sanal Makineleri) olarak tanımlanıyor.
+
+zkVM'ler, ZK devreleriyle iyi çalışacak şekilde temelden tasarlanmıştır ve bir zkEVM'e kıyasla farklı geliştirme iş akışları gerektirir. Bunlara örnek olarak Starkware ve Aztec verilebilir.
+
+zkEVM'ler, EVM'i taklit etmek üzere tasarlanmıştır. İki ana türü vardır: bytecode uyumlu ve dil uyumlu. Bytecode uyumlu zkEVM'ler, EVM'i çok düşük seviyede taklit eder ve Ethereum Katman 1'e kıyasla neredeyse aynı geliştirme ve kullanıcı deneyimi sağlar. Dil uyumlu zkEVM'ler, Solidity ve diğer yüksek seviye dilleri farklı bytecode'lara derler; bu da iş akışında değişikliklere neden olabilir. zkSync, en popüler dil uyumlu zkEVM'dir.
+
+Scroll, bytecode uyumlu bir yapıya sahiptir. Bu yaklaşımın seçilmesinin bazı faydaları vardır:
+
+- Solidity, Vyper ve Huff doğrudan kullanıma hazır.
+- Yeniden kod denetimine gerek yok
+- Varolan geliştirme araçlarının çoğu devralınır
+- Ethereum ile neredeyse aynı kullanıcı deneyimi ve geliştirici deneyimi sağlar
+
+Scroll'un yaklaşımına ilişkin daha fazla ayrıntı Teknoloji bölümünde bulunabilir.
+
+## Daha fazla okumak için
+
+- [Rollup'lar Hakkında Eksik Bir Kılavuz](https://vitalik.ca/general/2021/01/05/rollup.html) - Vitalik Buterin
+- [Ölçeklenme](https://ethereum.org/en/developers/docs/scaling/) - Ethereum Dokümanları
diff --git a/src/content/docs/tr/learn/the-scalability-problem.md b/src/content/docs/tr/learn/the-scalability-problem.md
new file mode 100644
index 000000000..2ad2bb976
--- /dev/null
+++ b/src/content/docs/tr/learn/the-scalability-problem.md
@@ -0,0 +1,27 @@
+---
+section: learn
+date: Last Modified
+title: "Ölçeklenebilirlik Sorunu"
+lang: "tr"
+permalink: "learn/intro-to-rollups"
+excerpt: "Ethereum'ın güçlü merkeziyetsizliği ve güvenliği, ölçeklenebilirliğini feda etmesiyle sağlanır: Katılan tüm düğümlerin ağa ayak uydurabilmesini sağlamak için ağın işlem kapasitesi sınırlıdır. Bu sınır sonuçta kullanıcılar için daha yüksek maliyetlere ve gecikmelere neden olur."
+whatsnext: { "Rollup'lara Giriş": "/tr/learn/intro-to-rollups" }
+---
+
+## Ethereum’un ölçeklenme sorunu
+
+[Ethereum](https://ethereum.org/en/developers/docs/intro-to-ethereum/#what-is-ethereum) genel amaçlı bir blokzincirdir ve [akıllı kontratların](https://ethereum.org/en/developers/docs/intro-to-ethereum/#what-are-smart-contracts) dağıtımını ve yürütülmesini destekler.
+
+Ethereum'un tanımlayıcı özelliklerinden biri, güvenliğe ve merkeziyetsizliğe olan sarsılmaz bağlılığıdır. Ethereum, dünyanın her yerindeki bilgisayarların ([Raspberry Pi](https://ethereum-on-arm-documentation.readthedocs.io/) gibi ucuz bilgisayarların bile) ağa katılarak, blokzincirin yerel kopyalarını çalıştırabilecek ve yeni işlemleri işleyebilecek şekilde tasarlanmıştır.
+
+Ancak Ethereum'un güçlü merkeziyetsizliği ve güvenliği, ölçeklenebilirlikten ödün verme pahasına gelir: katılan tüm düğümlerin ağa ayak uydurabilmesini sağlamak için ağın verimi sınırlıdır. Bu durum, kullanıcılar için daha yüksek maliyetler ve gecikmeler anlamına gelir.
+
+## Ölçeklenme çözümleri
+
+Ethereum'un ölçeklenme çözümleri, merkeziyetsizlikten veya güvenlikten ödün vermeden ağın verimini artırmayı amaçlıyor.
+
+Ana olarak iki tür ölçeklenme çözümü vardır: katman 1 ölçeklenme çözümleri ve katman 2 ölçeklenme çözümleri.
+
+**Katman 1** (veya **L1**) ölçeklenme çözümleri, doğrudan Ethereum blokzincirinde değişiklikler yaparak ağı ölçeklendirmeye çalışır. Buradaki “katman 1” terimi ana Ethereum blokzincirini ifade etmektedir. Genel olarak, verimi artıran ve aynı zamanda yüksek düzeyde güvenlik ve merkeziyetsizliği koruyan katman 1 ölçeklenme çözümlerini tasarlamak çok zordur. Bu nedenle son zamanlardaki ölçeklenme çabaları 1. katman çözümlerinden 2. katman çözümlerine doğru kaymıştır.
+
+**Katman 2** (veya **L2**) ölçeklenme çözümleri, Ethereum katman 1'in **üstünde** yaşayan ağlardır; bunlar esasen, temeldeki Ethereum blokzincirine bir şekilde "sabitlenmiş" ayrı blokzincirlerdir. Bu katman 2 ağları, aynı sınırlamalara tabi olmadıkları için genellikle işlemleri temel katman 1 ağından daha yüksek bir hızda işleyebilir. "Sabitleme" mekanizmasının özellikleri çeşitli katman 2'ler arasında farklılık gösterebilir. Bu mekanizma, katman 2 ağının, Ethereum katman 1'in güçlü güvenlik ve merkeziyetsiz özelliklerini miras almasını sağlar.
diff --git a/src/content/docs/tr/learn/zero-knowledge/additional-zk-learning-resources.md b/src/content/docs/tr/learn/zero-knowledge/additional-zk-learning-resources.md
new file mode 100644
index 000000000..2c8022e1a
--- /dev/null
+++ b/src/content/docs/tr/learn/zero-knowledge/additional-zk-learning-resources.md
@@ -0,0 +1,26 @@
+---
+section: learn
+date: Last Modified
+title: "Ek ZK Öğrenme Kaynakları"
+lang: "tr"
+permalink: "learn/zero-knowledge/additional-zk-learning-resources"
+excerpt: "ZK'nin derinliklerine dalmak mı istiyorsunuz? İşte favori kaynaklarımızdan bazıları."
+---
+
+ZK'nin derinliklerine dalmak mı istiyorsunuz? İşte favori kaynaklarımızdan bazıları.
+
+## Video
+
+- [ZK Beyaz Tahta Oturumları](https://youtube.com/playlist?list=PLj80z0cJm8QErn3akRcqvxUsyXWC81OGq)
+ - Bu beyaz tahta oturumları ZK hakkında bilgi edinmek için harika bir yoldur. Dan Boneh'in ilk üç dersi, sonraki derslerin üzerine inşa edildiği, daha yeni gelişmeleri tartışan harika bir temel anlayış sağlıyor.
+- [Zero Knowledge Kanıtı MOOC](https://youtube.com/playlist?list=PLS01nW3Rtgor_yJmQsGBZAg5XM4TSGpPs)
+ - İlk prensiplerden modern endüstri konularına kadar zero knowledge kanıtlarını kapsayan bir MOOC(Massive Open Online Courses).
+- [9. BIU Kriptografi Kış Okulu - Zero Knowledge](https://youtube.com/playlist?list=PL8Vt-7cSFnw29cLUVqAIuMlg1QJ-szV0K)
+ - Bu dersler zero knowledge'ın teorik temellerini oluşturur; akademisyenleri ve matematiksel olgunluğa sahip izleyicileri hedefler.
+- [ZK Sempozyumu](https://www.youtube.com/playlist?list=PLrzRr7okCcmbAlgYpuFjzUJv8tAyowDQY)
+ - Zero knowledge alanındaki en iyi araştırmacıların ve ürün geliştiricilerin bazılarının uygulamalı ve teorik sunumlarının bir karışımı.
+
+## Yazı
+
+- [Kanıtlar, Argümanlar ve Zero Knowledge](https://people.cs.georgetown.edu/jthaler/ProofsArgsAndZK.html) - Justin Thaler
+ - Zero knowledge teorisi üzerine kapsamlı bir ders kitabı.
diff --git a/src/content/docs/tr/learn/zero-knowledge/introduction-to-zero-knowledge.mdx b/src/content/docs/tr/learn/zero-knowledge/introduction-to-zero-knowledge.mdx
new file mode 100644
index 000000000..2404d5d48
--- /dev/null
+++ b/src/content/docs/tr/learn/zero-knowledge/introduction-to-zero-knowledge.mdx
@@ -0,0 +1,73 @@
+---
+section: learn
+date: Last Modified
+title: "Zero Knowledge'a Giriş"
+lang: "en"
+permalink: "learn/zero-knowledge/introduction-to-zero-knowledge"
+whatsnext: { "Polynomial Commitment Schemes": "/learn/zero-knowledge/polynomial-commitment-schemes" }
+excerpt: 'Over the past decade, a field of cryptography called "zero knowledge" has been rapidly advancing. It promises new ways to build applications and enables protocols to increase efficiency, security, and privacy.'
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+Son on yılda, "zero knowledge" olarak adlandırılan kriptografi alanı hızla ilerlemektedir. Zero knowledge, uygulama oluşturmanın yeni yollarını vaat ediyor ve protokollerin verimliliği, güvenliği ve gizliliği artırmasını sağlıyor.
+
+Zero knowledge kanıtları alanını bu kadar heyecan verici kılan şeyin ne olduğuna ve mühendislerin hangi sorunları çözmesine yardımcı olduğuna bakalım.
+
+## Güven Gerektirmeyen Blokzincirler ve Doğrulanabilirlik
+
+Blokzincirler genellikle kullanıcılar tarafından gönderilen işlemleri işleyerek çalışır. Bu işlemler genellikle blokzincirin gerçekleştirmesi için bazı hesaplamaları tetikler.
+
+Blokzincirin güven gerektirmemesi (yani bireysel bir tarafa güvenmeye bağlı olmaması) için ağdaki katılımcıların işlemlerin geçerli olduğunu ve sonuçta ortaya çıkan hesaplamaların doğru şekilde yapıldığını doğrulaması gerekir.
+
+İşlemin geçerli olduğunu doğrulamak için genellikle dijital imza doğrulaması gerekir; bu, işlemin bildirilen göndericisinin gerçekten işlemin yazarı olduğunu doğrular. Bir işlemin hesaplamasının doğru bir şekilde gerçekleştirildiğinin doğrulanması genellikle işlemin yerel olarak yeniden yürütülmesini gerektirir.
+
+## Doğrulanabilirliğe İlişkin Sınırlamalar
+
+Her bir işlemi doğrulamaya yönelik bu metodoloji, bir katılımcının hesaplamayı yeniden çalıştıramadığı durumlarda bozulur. Bir katılımcı birkaç nedenden dolayı hesaplamayı yeniden gerçekleştiremeyebilir: (1) belirli verilerin kullanıma sunulmaması gerekebilir (gizlilik nedenleriyle) veya (2) belirli bir veri için çok pahalı olabilir. Katılımcı bilgisayarın tüm işlemleri yeniden yürütmesi - bu ikinci neden, özellikle saniyede çok sayıda işlem gerçekleştiren yüksek verimli blokzincirler söz konusu olduğunda geçerlidir.
+
+## Zero Knowledge Kanıtlarının Gücü
+
+Zero knowledge kanıtları (ZKP'ler) bu sınırlamaların üstesinden gelme gücüne sahiptir.
+
+ZKP'ler, (1) hesaplamada kullanılan hassas verilerin gizliliğini korurken ve (2) doğrulamanın, hesaplamanın yeniden yürütülmesinden önemli ölçüde daha ucuz olmasını sağlayarak katılımcıların bir hesaplamanın sonuçlarını doğrulamasına olanak tanır. ZKP'lerin bu iki özelliğine sırasıyla **zero knowledge** ve **özlülük** denir.
+
+ZKP'lerin yukarıdaki özellikleri, güven gerektirmeyen blokzincirlerin doğrulanabilirliği bağlamında son derece faydalıdır. ZKP'ler olmadan katılımcıların her işlemin sonuç hesaplamasını yeniden yürütmesi gerekir. Bu, tüm katılımcıların her hesaplamada kullanılan tüm (potansiyel olarak hassas) verileri görmesini gerektirir ve aynı zamanda tüm sistemin verimini de sınırlar. ZKP'lerle bir taraf hesaplamayı gerçekleştirebilir ve ardından hesaplamanın doğru yapıldığına dair bir kanıt oluşturabilir. Diğer katılımcılar, hesaplamayı kendileri yeniden yürütmek yerine, _kanıtın geçerli olduğunu doğrulayarak_ hesaplamanın doğru şekilde yapıldığını doğrulayabilirler. Kanıtın doğrulanması (1) orijinal hesaplamada kullanılan hassas veriler hakkında bilgi sızdırmaz ve (2) hesaplama açısından orijinal hesaplamanın tekrar gerçekleştirilmesinden büyük oranda daha ucuzdur. Bu iki özellik, güven gerektirmeyen blokzincirler için gizlilik ve ölçeklenebilirlik sağlama potansiyeline sahiptir.
+
+## Devreler, Kanıtlar ve Doğrulayıcılar
+
+Pratikte ZKP'lerin bir sisteme uygulanması oldukça karmaşık olabilir, ancak yüksek düzeyde zero knowledge kanıtlarının birkaç bileşene sahip olduğunu anlamak isteyeceksiniz: bir devre, bir kanıt ve bir doğrulayıcı.
+
+Devre, giriş verilerini alan ve giriş verilerinin karşılaması gereken bazı "kısıtlamalara" göre giriş verilerinin geçerli olduğunu ileri süren bir programdır. Giriş verileri genel (herkes tarafından bilinir), özel (yalnızca kanıtlayan tarafından bilinir) veya karışık (bazı girişler genel, bazıları özel) olabilir.
+
+Bir girişin devreyi karşıladığını iddia eden bir kanıt üretilebilir. Kanıt, özel girdiler hakkında hiçbir bilgi ortaya çıkarmaz ve boyutu oldukça küçüktür.
+
+Doğrulayıcı, (1) kanıtın geçerli olup olmadığını, (2) kanıtın devre tarafından ortaya konan kısıtlamalarla eşleştiğini (ve sadece sahte bir kanıt olmadığını) ve (3) kanıtı oluşturmak için kullanılan genel girdilerin denetleyici tarafından kullanılanlarla eşleştiğini kontrol edebilir. Kanıt, doğrulayıcı tarafından kullanılanlarla eşleşir. Doğrulayıcı tarafından gerçekleştirilen bu kontrolün genellikle ucuz bir hesaplama olduğunu unutmayın.
+
+
+
+### Devreler, Kanıt ve Doğrulayıcılar — bir örnek
+
+Örnek olarak Sudoku'yu ele alalım. Diyelim ki bir Sudoku bulmacası var ve Alice Bob'a bulmacanın çözümünü bildiğini kanıtlamak istiyor ancak çözümün ne olduğunu açıklamak istemiyor.
+
+Bu durumda, söz konusu bulmaca genel bir girdi olacaktır (hem Alice hem de Bob bunu biliyor) ve çözüm de özel bir girdi olacaktır (Alice bunu biliyor ancak bunu Bob'tan gizli tutacak). **Devre** bu girdilerin her ikisini de alır ve çözümü standart yöntemle, satır satır, sütun sütun vb. kontrol ederek çözümün doğru olduğunu iddia eder. Bu devre, özel girdi çözümünün gerçekten genel girdi bulmacası için geçerli bir çözüm olduğunu "kısıtlar" ve yalnızca çözüm kontrolü geçtiğinde yalnızca "doğrulanır".
+
+Daha sonra Alice'in belirli bir bulmaca için devreyi karşılayan bir girdiyi (genel girdi) bildiğini belirten bir **kanıt** oluşturulabilir.
+
+Kanıt, bulmacayla birlikte Bob'a iletilebilir; o da daha sonra kanıtın geçerli olup olmadığını değerlendirmek için Sudoku kontrol devresine karşılık gelen bir **doğrulayıcı** kullanabilir ve böylece Alice gerçekten bulmacanın çözümünü bilir. . İşin kritik tarafı Bob, Alice'in çözümü hakkında herhangi bir bilgi sahibi değil ama yine de Alice'in geçerli bir çözüm bildiğini doğrulayabiliyor!
+
+## Zero Knowledge Kanıtları ve Blokzincirler
+
+ZKP'lerdeki son gelişmelerin temel motivasyonlarından biri, bunun blokzincirlere uygulanmasıdır. Merkezi olmayan blokzincirlerin karşılaştığı en önemli zorluklardan ikisi gizlilik ve ölçeklenebilirliktir; tüm veriler halka açıktır ve ağdaki her düğüm, ağdaki her hesaplamayı yeniden çalıştırmak zorundadır. ZKP'ler bu iki zorluğun da çözülmesine yardımcı olabilir.
+
+Gizliliği koruyan uygulamalar oluşturmak için ZKP'lerin zero knowledge özelliğini kullanan çeşitli projeler olsa da, biz Scroll olarak Ethereum'u ölçeklendirmek için ZKP'lerin yalnızca kısa ve öz özelliğini kullanıyoruz.
+
+## Scroll ve Zero Knowledge Kanıtları
+
+Scroll'a güç veren fikir oldukça basit. Peki ya Ethereum'un başka bir versiyonunun tüm hesaplamalarını doğrulamak için bir Ethereum akıllı sözleşmesi kullanabilseydik? Ethereum Sanal Makinesine ("EVM") daha hızlı ve daha ucuz erişim sağlayan başka bir ağ çalıştırabiliriz ve Ethereum'un kendisi de tüm hesaplamaların doğrulanması ve bu diğer ağın EVM kurallarını ihlal etmediğinden emin olmak için gereken güvenliği sağlayacaktır.
+
+Öğrenme ve Teknoloji bölümlerinin geri kalanı bunun nasıl çalıştığını daha ayrıntılı olarak ele alıyor ancak basit bir düzeyde, zero knowledge'ın bir devre, kanıt ve doğrulayıcıya sahip olmaya bağlı olduğunu unutmayın.
+
+Bizim yapımızda, devre (aslında bir devreler kümesi), zincir durumuna göre girdi işlemlerinin işlenmesi için kabul edilebilir davranışı "kısıtlamak" amacıyla EVM kurallarını kodlar. Bu "zkEVM"yi kullanan bir GPU ağı, işlemleri bir dizi blok için alır ve bir kanıt oluşturur. Ethereum'a dönersek, akıllı bir sözleşme, bir dizi işlem için bu kanıtın akıllı sözleşmede yer alan devreyle eşleştiğini doğrular. Eğer öyleyse, bu işlemler "kesinleşmiş" olarak değerlendirilebilir, ağ ileriye doğru hareket eder ve biz de Ethereum'u büyütmek için hızlı, güvenli ve uygun fiyatlı blok alanı yaratmış oluruz.
\ No newline at end of file
diff --git a/src/content/docs/tr/learn/zero-knowledge/kzg-commitment-scheme.md b/src/content/docs/tr/learn/zero-knowledge/kzg-commitment-scheme.md
new file mode 100644
index 000000000..4ecd927ce
--- /dev/null
+++ b/src/content/docs/tr/learn/zero-knowledge/kzg-commitment-scheme.md
@@ -0,0 +1,70 @@
+---
+section: learn
+date: Last Modified
+title: "KZG Taahhüt Şeması"
+lang: "tr"
+permalink: "learn/zero-knowledge/kzg-commitment-scheme"
+excerpt: "KZG, Ethereum'un Proto-Danksharding'inde kullanılır ve ayrıca Scroll'un kanıt sisteminde de kullanılır. Bu makale KZG taahhüt planına genel bir bakış sunacaktır."
+whatsnext: { "Ek Kaynaklar": "/tr/learn/zero-knowledge/additional-zk-learning-resources" }
+---
+
+En yaygın kullanılan polinom taahhüt planlarından biri KZG taahhüt şemasıdır. Plan ilk olarak 2010 yılında Kate, Zaverucha ve Goldberg tarafından [yayınlanmıştır](https://www.iacr.org/archive/asiacrypt2010/6477178/6477178.pdf).
+
+KZG, Ethereum'un [Proto-Danksharding'inde](https://notes.ethereum.org/@vbuterin/proto_danksharding_faq) ve ayrıca Scroll'un kanıt sisteminde kullanılır.
+
+Bu makale KZG taahhüt planına genel bir bakış sunacaktır.
+
+## Ön bilgiler ve notasyon
+
+Polinom taahhüt şemalarının önermesini hatırlayın. Taahhüt etmek istediğimiz bazı $P(x)$ polinomumuz var. Polinomun derecesinin $l$'dan küçük olduğunu varsayacağız.
+
+KZG taahhütleri [eliptik eğri eşleştirmelerine](https://vitalik.ca/general/2017/01/14/exploring_ecp.html) dayanmaktadır. $\mathbb{G}_1$ ve $\mathbb{G}_2$ $p$ düzeyinde iki eliptik eğri grubu olsun ve önemsiz olmayan bir [çift doğrusal eşleme](https://en.wikipedia.org/wiki/Bilinear_map) olsun. $e: \mathbb{G}_1 \times \mathbb{G}_2 \rightarrow \mathbb{G}_T$. $g$, $\mathbb{G}_1$ oluşturucusu olsun ve $h$, $\mathbb{G}_2$ oluşturucusu olsun. $[x]_1 := x \cdot g$ ve $[x]_2 := x \cdot h$ gösterimini kullanacağız, burada $x \in \mathbb{F}_p$.
+
+## 1. Güvenilir kurulum
+
+Herhangi bir KZG taahhüdünü hesaplamadan önce tek seferlik güvenilir kurulum gerçekleştirilmelidir. Güvenilir kurulum tamamlandıktan sonra, istenildiği kadar farklı polinomun kaydedilmesi ve ortaya çıkarılması için yeniden kullanılabilir. Güvenilir kurulum şu şekilde çalışır:
+
+- Rastgele bir alan öğesi seçin $\tau \in \mathbb{F}_p$
+- $l \in \mathbb{Z}$ taahhüt etmek istediğimiz polinomların maksimum derecesi olsun
+ - Güvenilir kurulum yalnızca $\leq l$ derecesindeki polinomlara yönelik taahhütleri etkinleştirir
+- $([\tau^0]_1,[\tau^1]_1,[\tau^{2}]_1\ldots,[\tau^{l}]_1)$ ve $([\tau]_2)$ hesaplayın ve bu değerleri herkese açık olarak yayınlayın.
+
+$\tau$'ın açıklanmaması gerektiğini unutmayın; bu, kurulumun gizli bir parametresidir ve güvenilir kurulum töreni tamamlandıktan sonra kimsenin değerini anlayamaması için atılmalıdır.
+
+[Çok taraflı hesaplamayı](https://en.wikipedia.org/wiki/Secure_multi-party_computation) (MPC) kullanarak, zayıf güven varsayımlarıyla (N'den 1'i güven varsayımı) güvenilir kurulum törenleri yürütmenin yerleşik yöntemleri vardır. Güvenilir kurulumların nasıl çalıştığı hakkında daha fazla bilgi için Vitalik'in bu [yazısına](https://vitalik.ca/general/2022/03/14/trustedsetup.html) bakın.
+
+## 2. Bir polinoma bağlı kalmak
+
+- Bir $P(x) = \sum_{i=0}^{l} p_i x^i$ polinomu verildiğinde
+- Taahhüdü hesaplayın ve çıktısını alın $c = [P(\tau)]_1$
+ - Her ne kadar taahhüt eden $P(\tau)$'ı doğrudan hesaplayamasa da ($\tau$'ı bilmediğinden), güvenilir kurulumun çıktısını kullanarak bunu hesaplayabilir:
+ - $[P(\tau)]_1 = [\sum_{i=0}^{l} p*i \tau^i]\_1 = \sum*{i=0}^{l} p_i [\tau^i]\_1$
+
+## 3. Bir değerlendirmeyi kanıtlayın
+
+- Bir değerlendirme verildiğinde $P(a) = b$
+- $\pi = [Q(\tau)]_1$ kanıtını hesaplayın ve çıktısını alın
+ - Burada $Q(x) := \frac{P(x)-b}{x-a}$
+ - Buna “bölüm polinomu” denir. Böyle bir $Q(x)$'ın ancak ve ancak $P(a) = b$ olması durumunda var olduğuna dikkat edin. Dolayısıyla bu bölüm polinomunun varlığı değerlendirmenin bir kanıtıdır.
+
+## 4. Değerlendirme kanıtını doğrulayın
+
+- $c = [P(\tau)]_1$ taahhüdü, $P(a) = b$ değerlendirmesi ve $\pi = [Q(\tau)]_1$ kanıtı verildiğinde
+- $e(\pi, [\tau - a]_2) = e(c - [b]_1, h)$ olduğunu doğrulayın
+ - Bazı cebir çalışmaları bunun, bölüm polinomunun $\tau$'da doğru şekilde oluşturulduğunu kontrol etmeye eşdeğer olduğunu gösterir: $Q(\tau) = \frac{P(\tau) -b}{\tau-a}$
+ $$
+ \begin{align*}
+ & e(\pi, [\tau - a]_2) = e(c - [b]_1, h) \\ \iff
+ & e([Q(\tau)]_1, [\tau -a]_2) = e([P(\tau)]_1 - [b]_1, h) \\ \iff
+ & Q(\tau) \cdot (\tau - a) \cdot e(g, h) = (P(\tau)-b) \cdot e(g,h) \\ \iff
+ & Q(\tau) \cdot (\tau -a) = P(\tau) - b
+ \end{align*}
+ $$
+ - Çift doğrusal eşleme $e$, gizli kurulum parametresi $\tau$'ı bilmeden bu özelliği kontrol etmemizi sağlar.
+- Bu doğrulama tamamlandıktan sonra, bölüm polinomunun doğru şekilde oluşturulduğu ve dolayısıyla değerlendirmenin (çok yüksek olasılıkla) doğru olduğu sonucuna varabiliriz.
+
+## Daha fazla bilgi edin
+
+- [https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html](https://dankradfeist.de/ethereum/2020/06/16/kate-polynomial-commitments.html)
+- [https://alinush.github.io/2020/05/06/kzg-polynomial-commitments.html](https://alinush.github.io/2020/05/06/kzg-polynomial-commitments.html)
+- [https://www.iacr.org/archive/asiacrypt2010/6477178/6477178.pdf](https://www.iacr.org/archive/asiacrypt2010/6477178/6477178.pdf)
diff --git a/src/content/docs/tr/learn/zero-knowledge/polynomial-commitment-schemes.md b/src/content/docs/tr/learn/zero-knowledge/polynomial-commitment-schemes.md
new file mode 100644
index 000000000..54523a174
--- /dev/null
+++ b/src/content/docs/tr/learn/zero-knowledge/polynomial-commitment-schemes.md
@@ -0,0 +1,35 @@
+---
+section: learn
+date: Last Modified
+title: "Polinom Taahhüt Şemaları"
+lang: "tr"
+permalink: "learn/zero-knowledge/polynomial-commitment-schemes"
+excerpt: "Polinom taahhüt şemaları zero knowledge kanıt sisteminin temel yapı taşıdır"
+whatsnext: { "KZG Taahhüt Şeması": "/tr/learn/zero-knowledge/kzg-commitment-scheme" }
+---
+
+Polinom taahhüt şemaları, zero knowledge kanıtlama sistemlerinin (ve diğer şifreleme protokollerinin) temel yapı taşıdır.
+
+Adından da anlaşılacağı gibi polinom taahhüt şemaları, taahhüt edilecek nesnenin bir polinom olduğu taahhüt şemalarıdır. Bu şemaların ayrıca polinomun değerlendirmesinin yalnızca polinomun taahhüdüne erişimle doğrulanabileceği özel bir özelliği vardır.
+
+## Taahhüt planları
+
+**[Taahhüt şeması](https://en.wikipedia.org/wiki/Commitment_scheme)** iki tarafı içeren bir kriptografik ilkeldir: _committer_ ve _verifier_. Taahhüt eden kişi, $c$ taahhüdünü hesaplayıp bunu doğrulayıcıya açıklayarak $v$ değerini taahhüt eder. Daha sonraki bir zamanda taahhüt eden kişi orijinal değeri ortaya çıkarabilir ve doğrulayıcı da taahhüdün bu açıklanan değere karşılık geldiğini doğrulayabilir.
+
+Güvenli taahhüt planlarının iki özelliği vardır:
+
+1. **Bağlayıcı olma**: $c$ taahhüdünü yayınladıktan sonra, taahhüt eden kişi $v$'den farklı olan ve aynı zamanda $c$'ye karşılık gelen başka bir $v'$ değeri bulamamalıdır. Yani, $c$ taahhüdü, taahhüt edeni orijinal $v$ değerine bağlar.
+2. **Gizleme**: Doğrulayıcı, $c$ taahhüdünden orijinal $v$ değeri hakkında herhangi bir bilgi öğrenememelidir. Yani, $c$ taahhüdü, orijinal $v$ değeri hakkındaki tüm bilgileri gizler.
+
+## Polinom taahhüt şemaları
+
+**Polinom taahhüt şeması**, taahhüt eden kişinin $c$ taahhüdünü hesaplayarak $P(x)$ polinomunu taahhüt ettiği bir taahhüt şemasıdır. Normal taahhüt planlarında olduğu gibi, taahhüt eden kişi daha sonra orijinal polinomu ortaya çıkarabilir ve doğrulayıcı, taahhüdün ortaya çıkan polinoma karşılık gelip gelmediğini kontrol edebilir. Bununla birlikte, polinom taahhüt şemalarının ek bir özelliği vardır: taahhüt eden, polinomun kendisini açıklamadan taahhüt edilen polinomun belirli değerlendirmelerini kanıtlayabilir. Örneğin, taahhüt eden $P(a) = b$ olduğunu kanıtlayabilir ve doğrulayıcı böyle bir kanıtı yalnızca $c$ taahhüdünü kullanarak doğrulayabilir.
+
+Polinom taahhüt şemaları zero knowledge uygulamaları için son derece faydalıdır. Bir kanıtlayıcı, temeldeki polinomu açıklamadan, belirli özellikleri (örneğin, belirli bir $(a,b)$ noktasından geçtiğini) karşılayan bazı polinomları bildiğini kanıtlamak için böyle bir şema kullanabilir.
+
+Polinom şemalarının faydalı olmasının bir başka nedeni de, $c$ taahhüdünün genellikle temsil ettiği polinomdan çok daha küçük olmasıdır ve dolayısıyla $P(x)$ polinomunun **sıkıştırılması** olarak düşünülebilir. Sıkıştırmanın büyüklüğü özel şemaya bağlıdır. Örneğin, KZG polinom taahhüt şemasında, keyfi derecede büyük dereceli bir polinom, tek bir grup elemanından oluşan bir taahhüt halinde sıkıştırılabilir.
+
+## Daha fazla bilgi edin
+
+- [https://en.wikipedia.org/wiki/Commitment_scheme](https://en.wikipedia.org/wiki/Commitment_scheme)
+- [https://learn.0xparc.org/materials/halo2/miscellaneous/polynomial-commitment](https://learn.0xparc.org/materials/halo2/miscellaneous/polynomial-commitment)
diff --git a/src/content/docs/tr/technology/_images/L1-to-L2.png b/src/content/docs/tr/technology/_images/L1-to-L2.png
new file mode 100644
index 000000000..89d140909
Binary files /dev/null and b/src/content/docs/tr/technology/_images/L1-to-L2.png differ
diff --git a/src/content/docs/tr/technology/_images/L2-to-L1.png b/src/content/docs/tr/technology/_images/L2-to-L1.png
new file mode 100644
index 000000000..0e8cbbf87
Binary files /dev/null and b/src/content/docs/tr/technology/_images/L2-to-L1.png differ
diff --git a/src/content/docs/tr/technology/_images/arch.png b/src/content/docs/tr/technology/_images/arch.png
new file mode 100644
index 000000000..7c0b2db02
Binary files /dev/null and b/src/content/docs/tr/technology/_images/arch.png differ
diff --git a/src/content/docs/tr/technology/_images/batching.png b/src/content/docs/tr/technology/_images/batching.png
new file mode 100644
index 000000000..a101859bb
Binary files /dev/null and b/src/content/docs/tr/technology/_images/batching.png differ
diff --git a/src/content/docs/tr/technology/_images/deposit.png b/src/content/docs/tr/technology/_images/deposit.png
new file mode 100644
index 000000000..1ba61ec9c
Binary files /dev/null and b/src/content/docs/tr/technology/_images/deposit.png differ
diff --git a/src/content/docs/tr/technology/_images/rollup.png b/src/content/docs/tr/technology/_images/rollup.png
new file mode 100644
index 000000000..345826c28
Binary files /dev/null and b/src/content/docs/tr/technology/_images/rollup.png differ
diff --git a/src/content/docs/tr/technology/_images/withdraw-trie.png b/src/content/docs/tr/technology/_images/withdraw-trie.png
new file mode 100644
index 000000000..fe602e973
Binary files /dev/null and b/src/content/docs/tr/technology/_images/withdraw-trie.png differ
diff --git a/src/content/docs/tr/technology/_images/withdraw.png b/src/content/docs/tr/technology/_images/withdraw.png
new file mode 100644
index 000000000..faecae833
Binary files /dev/null and b/src/content/docs/tr/technology/_images/withdraw.png differ
diff --git a/src/content/docs/tr/technology/_images/zkevm1.png b/src/content/docs/tr/technology/_images/zkevm1.png
new file mode 100644
index 000000000..39f45db33
Binary files /dev/null and b/src/content/docs/tr/technology/_images/zkevm1.png differ
diff --git a/src/content/docs/tr/technology/_images/zkevm2.png b/src/content/docs/tr/technology/_images/zkevm2.png
new file mode 100644
index 000000000..4e5ff8a2a
Binary files /dev/null and b/src/content/docs/tr/technology/_images/zkevm2.png differ
diff --git a/src/content/docs/tr/technology/_images/zkevm3.png b/src/content/docs/tr/technology/_images/zkevm3.png
new file mode 100644
index 000000000..31e268f23
Binary files /dev/null and b/src/content/docs/tr/technology/_images/zkevm3.png differ
diff --git a/src/content/docs/tr/technology/_images/zktrie-arch.png b/src/content/docs/tr/technology/_images/zktrie-arch.png
new file mode 100644
index 000000000..38f74e6f8
Binary files /dev/null and b/src/content/docs/tr/technology/_images/zktrie-arch.png differ
diff --git a/src/content/docs/tr/technology/_images/zktrie-deletion.png b/src/content/docs/tr/technology/_images/zktrie-deletion.png
new file mode 100644
index 000000000..c47fc7267
Binary files /dev/null and b/src/content/docs/tr/technology/_images/zktrie-deletion.png differ
diff --git a/src/content/docs/tr/technology/_images/zktrie-insertion.png b/src/content/docs/tr/technology/_images/zktrie-insertion.png
new file mode 100644
index 000000000..da0ae521a
Binary files /dev/null and b/src/content/docs/tr/technology/_images/zktrie-insertion.png differ
diff --git a/src/content/docs/tr/technology/bridge/cross-domain-messaging.mdx b/src/content/docs/tr/technology/bridge/cross-domain-messaging.mdx
new file mode 100644
index 000000000..17f0a3c5f
--- /dev/null
+++ b/src/content/docs/tr/technology/bridge/cross-domain-messaging.mdx
@@ -0,0 +1,247 @@
+---
+section: technology
+date: Last Modified
+title: "Alanlar Arası Mesajlaşma"
+lang: "tr"
+permalink: "technology/bridge/cross-domain-messaging"
+whatsnext: { "Yatırma Ağ Geçitleri": "/tr/technology/bridge/deposit-gateways/" }
+---
+
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import Aside from "../../../../../components/Aside.astro"
+import ToggleElement from "../../../../../components/ToggleElement.astro"
+
+import L1ToL2 from "../_images/L1-to-L2.png"
+import L2ToL1 from "../_images/L2-to-L1.png"
+import WithdrawTrie from "../_images/withdraw-trie.png"
+
+Scroll, token transferlerine olanak tanıyan ve dapp'lerin L1 ile L2 arasında iletişim kurmasına izin veren rastgele bir mesaj geçiş köprüsüne sahiptir. Bu, L1'deki dapp'lerin L2'deki sözleşme fonksiyonlarını tetikleyebileceği veya bunun tersi anlamına gelir. Yazının devamında mesajların L1 ile L2 arasında nasıl iletildiğini açıklayacağız.
+
+## L1'den L2'ye Mesaj Gönderme
+
+
+
+L1'den L2'ye mesaj göndermenin iki temel yaklaşımı vardır: `L1ScrollMessenger` aracılığıyla rastgele mesajlar göndermek ve `EnforcedTxGateway` aracılığıyla zorunlu işlemleri göndermek. Her iki yaklaşım da kullanıcıların L1'de bir L2 işlemi başlatmasına ve L2'de isteğe bağlı kontrat çağırmasına olanak tanır. Rastgele mesajlar için, L2 işlemlerinin göndereni `L1ScrollMessenger` adresidir. Zorunlu işlemlerde, L2 göndereni harici sahipli bir hesaptır (EOA). Ek olarak, kullanıcıların ETH ve ERC-20, ERC-677, ERC-721 ve ERC-1155 dahil diğer standart tokenleri yatırmalarını kolaylaştırmak için çeşitli standart token ağ geçitleri sağlıyoruz. Temelde, bu ağ geçitleri, token depozitolarını bir mesaja kodlar ve bunu 'L1ScrollMessenger' sözleşmesi aracılığıyla L2'deki muadillerine gönderir. L1 token ağ geçitleri hakkında daha fazla ayrıntıyı [Para Yatırma Ağ Geçitleri](/tr/teknoloji/bridge/deposit-gateways) bölümünde bulabilirsiniz.
+
+
+
+Şekil 1'de gösterildiği gibi, hem rastgele mesajlar hem de zorunlu işlemler `L1MessageQueue` kontratında saklanan mesaj sırasına eklenir. `L1MessageQueue` sözleşmesi, isteğe bağlı mesajların ve zorunlu işlemlerin eklenmesi için sırasıyla `appendCrossDomainMessage` ve `appendEnforcedTransaction` olmak üzere iki fonksiyon sağlar.
+
+```solidity
+/// @notice Append an arbitrary L1-to-L2 message into this contract.
+/// @param target The target address on L2.
+/// @param gasLimit The maximum gas can be used for this transaction on L2.
+/// @param data The calldata of the L1-initiated transaction.
+function appendCrossDomainMessage(
+ address target,
+ uint256 gasLimit,
+ bytes calldata data
+) external;
+
+/// @notice Append an enforced transaction to this contract.
+/// @param sender The sender address of this transaction.
+/// @param target The target address of this transaction.
+/// @param value The value to be transferred on L2.
+/// @param gasLimit The maximum gas should be used for this transaction on L2.
+/// @param data The calldata of the L1-initiated transaction.
+function appendEnforcedTransaction(
+ address sender,
+ address target,
+ uint256 value,
+ uint256 gasLimit,
+ bytes calldata data
+) external;
+```
+
+Her iki fonksiyon da Scroll zincirinde tanıtılan yeni bir işlem türü `L1MessageTx` ile L1 tarafından başlatılan bir işlem oluşturur ve işlem hash değerini hesaplar (daha fazla ayrıntı için [L1 Mesaj İşlemi](/tr/technology/chain/transactions#l1-message-transaction) bölümüne bakın ). `L1MessageQueue` daha sonra işlem hash'ini mesaj kuyruğuna ekler ve `QueueTransaction(sender, target, value, queueIndex, gasLimit, calldata)` olayını yayar. L1 mesaj işlemlerini oluştururken `appendCrossDomainMessage` ve `appendEnforcedTransaction` arasındaki fark şudur:
+
+- `appendCrossDomainMessage` yalnızca `L1ScrollMessenger` tarafından çağrılabilir ve işlemi gönderen olarak `L1ScrollMessenger`ın adresi olacak olan `msg.sender`ın [takma adresini](#address-alias) kullanır.
+- `appendEnforcedTransaction` yalnızca `EnforcedTxGateway` tarafından çağrılabilir ve işlem göndereni olarak fonksiyon parametresindeki `sender`ı kullanır. Bu, kullanıcıların doğrudan L1 köprüsü aracılığıyla L2 hesaplarından ETH çekilmesini veya aktarılmasını zorunlu kılmasına olanak tanır.
+
+İşlem L1'de başarıyla yürütüldükten sonra, `L1MessageQueue` sözleşmesini izleyen Scroll sıralayıcıdaki izleyici, L1 bloklarından yeni `QueueTransaction` olaylarını toplar. Sıralayıcı daha sonra olay başına yeni bir `L1MessageTx` işlemi oluşturur ve bunları yerel L1 işlem kuyruğuna ekler. Yeni bir L2 bloğu oluştururken sıralayıcı, hem L1 işlem kuyruğundan hem de L2 mempool'dan işlemleri içerir. L1 mesaj işlemlerinin, `L1MessageQueue` sözleşmesindeki L1 mesaj kuyruğu sırasına göre sırayla dahil edilmesi gerektiğini unutmayın. L2 bloklarında her zaman önce `L1MessageTx` işlemleri gelir, ardından L2 işlemleri gelir. Şu anda, bir L2 bloğundaki `L1MessageTx` işlemlerinin sayısını `NumL1MessagesPerBlock` (şu anda 10'a ayarlı) ile sınırlandırıyoruz.
+
+Daha sonra, `L1ScrollMessenger` yoluyla rastgele mesajların gönderilmesi ve `EnforcedTxGateway` aracılığıyla zorunlu işlemlerin gönderilmesine ilişkin spesifik süreci daha da detaylandıracağız.
+
+### Keyfi Mesajlar Göndermek
+
+`L1ScrollMessenger` sözleşmesi, rastgele mesajlar göndermek için iki `sendMessage` fonksiyonu sağlar. Tek fark, ikincisinin, kullanıcıların ücret iadesi alabilmek için gönderici adresi dışında bir iade adresi belirtmesine olanak sağlamasıdır.
+
+
+
sendMessage function signatures
+```solidity
+/// @param target The target address on L2.
+/// @param value The value to deposit to L2 from `msg.value`.
+/// @param message The message passed to target contract.
+/// @param gasLimit The maximum gas can be used for this transaction on L2.
+function sendMessage(
+ address target,
+ uint256 value,
+ bytes memory message,
+ uint256 gasLimit
+) external payable;
+
+/// @param target The target address on L2.
+/// @param value The value to deposit to L2 from `msg.value`.
+/// @param message The message passed to target contract.
+/// @param gasLimit The maximum gas can be used for this transaction on L2.
+/// @param refundAddress The address to refund excessive fee on L1.
+function sendMessage(
+ address target,
+ uint256 value,
+ bytes calldata message,
+ uint256 gasLimit,
+ address refundAddress
+) external payable;
+````
+
+
+
+Her iki fonksiyon da kullanıcıların L2'de karşılık gelen `L1MessageTx` işlemi için bir gas limiti sağlamasını ve L1'de gas limiti miktarına göre hesaplanan [mesaj aktarma ücretini](#message-relay-fee) ön ödemesini gerektirir. Ücret, L1'deki bir `feeVault` kontratına tahsil edilir. Kullanıcının L1'deki mesajı için doğru gas limitini ayarlamaması nedeniyle L2'de işlemin başarısız olması durumunda, kullanıcı aynı mesajı daha yüksek bir gas limitiyle tekrar oynatabilir. Daha fazla ayrıntıyı [Başarısız mesajları yeniden deneme](#retrying-failed-messages) bölümünde bulabilirsiniz, ancak bu ücretlerin kullanılmayan kısmı kullanıcıya iade edildiğinden, gas limitini fazla tahmin etmenin herhangi bir cezası yoktur.
+
+`sendMessage` fonksiyonları, argümanları alanlar arası bir mesaja kodlar (aşağıdaki ilgili kodu içeren bölüme bakın), burada nonce mesajı, L1 mesaj kuyruğunun bir sonraki kuyruk indeksidir. Kodlanan veriler daha sonra L2'de yürütülen `L1MessageTx` işleminde çağrı verileri olarak kullanılır. Bu tür etki alanları arası mesajların her zaman L2'deki `L2ScrollMessenger` sözleşmesinin `relayMessage` işlevini çağırdığını unutmayın.
+
+```solidity
+abi.encodeWithSignature(
+ "relayMessage(address,address,uint256,uint256,bytes)",
+ _sender,
+ _target,
+ _value,
+ _messageNonce,
+ _message
+)
+````
+
+Yatırılan `value` tutarının ETH'i `L1ScrollMessenger` kontratında kilitlenir. Mesajdaki ETH miktarının mesaj aktarma ücretini ve yatırılan tutarı karşılayamaması durumunda işlem geri çevrilecektir. `L1ScrollMessenger` sözleşmesi, fazla tutarı belirtilen `refundAddress`e veya işlemi gönderene aksi takdirde iade edecektir. Son olarak, `L1ScrollMessenger`, alanlar arası mesajı `appendCrossDomainMessage` yöntemi aracılığıyla `L1MessageQueue`ya ekler.
+
+### Zorunlu İşlemler Gönderme
+
+
+
+`EnforcedTxGateway` kontratı, zorunlu bir işlemi göndermek için iki `sendTransaction` fonksiyonu sağlar. Birinci fonksiyonda oluşturulan `L1MessageTx` işleminin göndericisi işlemin göndericisidir. Öte yandan, ikinci fonksiyon, `L1MessageTx` işleminin göndericisi olarak iletilen `sender` adresini kullanır. Bu, üçüncü bir tarafın kullanıcı adına zorunlu bir işlem göndermesine ve geçiş ücretini ödemesine olanak tanır. İkinci fonksiyonun, oluşturulan `L1MessageTx` işleminin `sender` adresiyle eşleşen geçerli bir imzasının sağlanmasını gerektirdiğini unutmayın. Her iki `sendTransaction` işlevi de gönderenin bir EOA hesabı olmasını zorunlu kılar.
+
+
+
sendTransaction function signatures
+
+```solidity
+/// @param target The target address on L2.
+/// @param value The value to withdraw from the `tx.origin` address on L2.
+/// @param gasLimit The maximum gas can be used for this transaction on L2.
+/// @param data The calldata passed to target contract.
+function sendTransaction(
+ address target,
+ uint256 value,
+ uint256 gasLimit,
+ bytes calldata data
+) external payable;
+
+/// @param sender The sender address who will initiate this transaction on L2.
+/// @param target The target address on L2.
+/// @param value The value to withdraw from the `sender` address on L2.
+/// @param gasLimit The maximum gas can be used for this transaction on L2.
+/// @param data The calldata passed to target contract.
+/// @param signature The signature for the corresponding `L1MessageTx` transaction.
+/// @param refundAddress The address to refund excessive fee on L1.
+function sendTransaction(
+ address sender,
+ address target,
+ uint256 value,
+ uint256 gasLimit,
+ bytes calldata data,
+ bytes memory signature,
+ address refundAddress
+) external payable;
+```
+
+
+
+Rastgele mesaj aktarımına benzer şekilde, `sendTransaction` mesaj aktarma ücretini keser ve bunu L1 `feeVault` hesabına aktarır. Ancak önemli bir fark, işleve iletilen `value`nun, L1'deki değil, L2'deki gönderen hesabından aktarılacak ETH miktarını göstermesidir. Bu nedenle, `msg.value`nun yalnızca [mesaj aktarma ücretini](#message-relay-fee) kapsaması gerekir. Mesajdaki ETH miktarı ücreti karşılayamıyorsa işlem başarısız olacaktır. Fazla ücret, ilk fonksiyonda işlemi gönderene, ikinci fonksiyonda ise `refundAddress`e iade edilir. Son olarak, `EnforcedTxGateway`, işlemi mesaj kuyruğuna eklemek için `L1MessageQueue.appendEnforcedTransaction`ı çağırır.
+
+### Başarısız Mesajları Yeniden Denemek
+
+Yetersiz gas nedeniyle L2'de bir `L1MessageTx` işlemi başarısız olursa, kullanıcılar mesajı daha yüksek bir gas limitiyle tekrarlayabilir. `L1ScrollMessenger`, kullanıcıların önceki başarısız mesajla aynı bilgiyi daha yüksek gas limitiyle göndermesine olanak tanıyan `replayMessage` yöntemini sağlar. Bu mesaj L2'de yeni bir `L1MessageTx` işlemi haline gelecektir. L2'de zaten işlendiğinden, önceki başarısız işlem için gas ücretini iade etmeyeceğimizi unutmayın.
+
+
+
replayMessage function signature
+
+```solidity
+/// @param from The address of the sender of the message.
+/// @param to The address of the recipient of the message.
+/// @param value The msg.value passed to the message call.
+/// @param queueIndex The queue index for the message to replay.
+/// @param message The content of the message.
+/// @param newGasLimit New gas limit to be used for this message.
+/// @param refundAddress The address of account who will receive the refunded fee.
+function replayMessage(
+ address from,
+ address to,
+ uint256 value,
+ uint256 queueIndex,
+ bytes memory message,
+ uint32 newGasLimit,
+ address refundAddress
+) external payable;
+```
+
+
+
+`L2ScrollMessenger` sözleşmesi, L2'ye başarılı bir şekilde iletilen tüm L1 mesajlarını kaydettiği için, orijinal mesajın başarılı olması halinde, tekrarlanan mesajın işlemi L2'de geri alınacaktır.
+
+### Mesaj Aktarma Ücreti
+
+L1'de konuşlandırılan `L2GasPriceOracle` sözleşmesi, gas limiti dikkate alınarak bir mesajın aktarma ücretini hesaplar. Bu sözleşme, şu anda Scroll tarafından çalıştırılan özel bir aktarıcı tarafından güncellenen `l2BaseFee`yi kendi depolama alanında saklar. L1'den L2'ye mesaj geçiş ücreti `gasLimit * l2BaseFee`dir.
+
+
+
+### Adres Takma Adı
+
+`CREATE` opcode'unun davranışı nedeniyle, birisinin L1 ve L2'de aynı adreste ancak farklı bytecode'uyla bir sözleşme dağıtması mümkündür. Kötü niyetli kullanıcıların bundan faydalanmasını önlemek için, mesajı gönderen L1'de bir sözleşme olduğunda köprü bir adres takma adı uygular. L1 mesaj işleminin takma adı olan gönderen adresi `l1_contract_address + offset`tir; burada `offset`, `0x1111000000000000000000000000000000001111`dir.
+
+## L2'den L1'e Mesaj Gönderme
+
+
+
+L2'de kullanıcılar, tokenlerini çekmek ve L1 sözleşmelerini çağırmak için `L2ScrollMessenger` aracılığıyla isteğe bağlı mesajlar gönderebilir. L1'e benzer şekilde, token çekimlerini başlatmayı kolaylaştırmak için birkaç standart token ağ geçidi oluşturduk. L2 token ağ geçitleri hakkında daha fazla ayrıntı için lütfen [Geri Çekme Ağ Geçitleri](/tr/technology/bridge/withdraw-gateways).
+
+`L2ScrollMessenger` sözleşmesi aynı zamanda bir `sendMessage` fonksiyonu da sağlar. `L1ScrollMessenger.sendMessage`dan farkı, L1 üzerindeki para çekme işleminin kullanıcılar tarafından gönderilmesi ve işlem ücretinin doğrudan L1 üzerinden ödenmesi nedeniyle fonksiyonda `gasLimit` parametresinin dikkate alınmamasıdır. Bu nedenle, `sendMessage` işlevi `msg.value`nun `value` parametresine eşit olmasını gerektirir. Fonksiyon, bağımsız değişkenleri, [`L1ScrollMessenger`](#sending-arbitrary-messages) ile aynı şemayı izleyerek alanlar arası bir mesaja kodlar.
+
+
+
sendMessage function signatures
+
+```solidity
+/// @param target The target address on L1.
+/// @param value The value to withdraw to L1 from `msg.value`.
+/// @param message The message passed to target contract.
+/// @param _gasLimit Ignored in the L2ScrollMessenger because the withdrawal execution on L1 is done by the user.
+function sendMessage(
+ address target,
+ uint256 value,
+ bytes memory message,
+ uint256 _gasLimit
+) external payable;
+```
+
+
+
+Daha sonra, alanlar arası mesaj hash'i, `appendMessage` işlevi çağrılarak `L2MessageQueue`ya eklenir. `L2MessageQueue` kontratı, yalnızca eklenen bir Merkle ağacı olan [Withdraw Trie](#withdraw-trie)'yi korur. Kuyruğa her yeni mesaj eklendiğinde, sözleşme onu Withdraw Trie'sine ekler ve trie'nin kök hash'ini günceller.
+
+Kullanıcıların L2'den L1'e mesajlarını içeren işlem kümesi L1 rollup sözleşmesinde sonlandırıldıktan sonra, kullanıcıların L1'de para çekme işlemini gerçekleştiren `L1ScrollMessenger` sözleşmesindeki `relayMessageWithProof` yöntemini çağırmak için ilgili _Execute Withdrawal_ işlemlerini göndermeleri gerekir. Merkle kanıtları sayesinde L1'de para çekme işlemlerinin sonuçlandırılması güvensizdir (trustless) ve kullanıcı tarafından veya kullanıcı adına üçüncü bir kişi tarafından yapılabilir.
+
+Bir para çekme MIP'si oluşturmayı kolaylaştırmak için Scroll, Bridge History API adı verilen bir hizmet sağlar. Köprü Geçmişi API'si, `L2ScrollMessenger`dan yayılan `SentMessage` olaylarını izler ve dahili olarak bir Geri Çekme Trie'sini korur. Her para çekme mesajı için sürekli olarak Merkle kanıtları üretir. Kullanıcılar ve üçüncü taraf hizmetleri, _Execute Withdrawal_ işlemlerine dahil etmek için Bridge History API'sinden Merkle kanıtlarını sorgulayabilir.
+
+Gerçekleştirilen para çekme işlemlerinin kullanıcılar tarafından veya bir üçüncü taraf hizmeti tarafından gönderilebileceğini unutmayın.
+
+### Withdraw Trie
+
+
+
+Withdraw Trie yoğun bir ikili Merkle ağacıdır. Bir yaprak düğümün hash değeri, mesaj hashinde miras alınırken, yaprak olmayan bir düğümün hashi, iki çocuğunun birleştirilmiş hashlerinin Keccak hash özetidir. Geri Çekme Trie'sinin derinliği, trie'ye eklenen mesaj sayısına bağlı olarak dinamik olarak artar.
+
+Şekil 3(a), tam 3 katmanlı Withdraw Trie denemesinin bir örneğini göstermektedir. Yaprak sayısı ikili ağacın tamamını doyuramadığında, yaprak düğümlerini Şekil 3(b) ve 3(c)'de gösterildiği gibi hash değeri 0 ile doldururuz. Tamamlanmamış bir Withdraw Trie'sine yeni bir mesaj eklerken, doldurma düğümü daha sonra gerçek mesaj hash'ini içeren yeni bir yaprak düğümle değiştirilecektir.
\ No newline at end of file
diff --git a/src/content/docs/tr/technology/bridge/deposit-gateways.mdx b/src/content/docs/tr/technology/bridge/deposit-gateways.mdx
new file mode 100644
index 000000000..9ae15ff09
--- /dev/null
+++ b/src/content/docs/tr/technology/bridge/deposit-gateways.mdx
@@ -0,0 +1,183 @@
+---
+section: technology
+date: Last Modified
+title: "Yatırım Ağ Geçitleri"
+lang: "tr"
+permalink: "technology/bridge/deposit-gateways"
+whatsnext: { "Yatırım Ağ Geçitleri": "/tr/technology/bridge/withdraw-gateways/" }
+---
+
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import DepositWorkflow from "../_images/deposit.png"
+
+Bu belge, kullanıcıların ve geliştiricilerin L1'den L2'ye token yatırmak için ağ geçitlerini nasıl kullanabileceğini açıklamaktadır. Aşağıdaki tabloda listelenen, standart tokenler için çeşitli ağ geçitleri ve L1'de bir ağ geçidi yönlendiricisi (gateway router) sağlıyoruz.
+
+| Gateway Kontratı | Açıklama |
+| ------------------------ | ---------------------------------------------------------------------------- |
+| `L1GatewayRouter` | Ağ geçidi yönlendiricisi, ETH ve ERC20 tokenlarının yatırılmasını destekler. |
+| `L1ETHGateway` | ETH yatırmak için ağ geçidi. |
+| `L1StandardERC20Gateway` | Standart ERC20 token yatırma işlemleri için ağ geçidi. |
+| `L1CustomERC20Gateway` | Özel ERC20 token yatırma işlemleri için ağ geçidi. |
+| `L1WETHGateway` | Wrapped ETH yatırma işlemleri için ağ geçidi. |
+| `L1ERC721Gateway` | ERC-721 token yatırma işlemleri için ağ geçidi. |
+| `L1ERC1155Gateway` | ERC-1155 token yatırma işlemleri için ağ geçidi. |
+
+## Genel Bakış
+
+
+
+Şekilde L1'den L2'ye para yatırma iş akışı gösterilmektedir. Kullanıcılar token yatırma işlemini başlatmak için ağ geçitlerini çağırırlar. Yatırılan değer daha sonra `L1ScrollMessenger` sözleşmesine gönderilen bir mesaja kodlanır ve karşılık gelen L1 tarafından başlatılan işlem `L1MessageQueue`ya eklenir. L2'deki para yatırma işlemlerini tamamlamak için L2 sıralayıcı, yeni L1 işlem olaylarını toplar ve karşılık gelen işlemleri, oluşturduğu L2 bloklarına dahil eder. Sonraki bölümlerde farklı tokenlerin nasıl yatırıldığına ilişkin ayrıntılar açıklanmaktadır. L1'den L2'ye mesaj aktarma iş akışı hakkında daha fazla ayrıntıyı [Alanlar Arası Mesajlaşma](/technology/bridge/cross-domain-messaging#sending-messages-from-l1-to-l2) bölümünde bulabilirsiniz.
+
+## ETH yatırma
+
+Scroll, ETH'i kendi yerel token'ı olarak ele alır. Yerel ETH tokenını basım yapmadan L2 hesaplarına aktarabilmesi için, genesis bloğundaki `L2ScrollMessenger` sözleşmesine yeterli miktarda ETH'i önceden tahsis ediyoruz. ETH yatırma işlemi şu şekilde çalışır;
+
+1. `L1GatewayRouter`, ETH'i L1'den L2'ye yatırmak için üç fonksiyon sağlar. `depositETHAndCall` fonksiyonu, aynı anda ETH'i aktarabilir ve bir kontrat çağrısı (contract call) gerçekleştirebilir.
+
+ ```solidity
+ function depositETH(uint256 _amount, uint256 _gasLimit) external payable;
+
+ function depositETH(address _to, uint256 _amount, uint256 _gasLimit) public payable;
+
+ function depositETHAndCall(
+ address _to,
+ uint256 _amount,
+ bytes calldata _data,
+ uint256 _gasLimit
+ ) external payable;
+ ```
+
+2. Üç `depositETH` fonksiyonunun tümü `L1ETHGateway`i çağırır. `L1ETHGateway`, depozitoyu `L1ScrollMessenger` kontratına gönderilen bir mesaja kodlar.
+
+3. Yatırılan tutarın ETH'i `L1ScrollMessenger` sözleşmesinde kilitlenir. `L1ScrollMessenger`, mesajı `L1MessageQueue` sözleşmesindeki mesaj kuyruğuna ekler.
+
+4. L1'de para yatırma işlemi tamamlandıktan sonra sıralayıcı, yatırmayı tamamlamak ve ETH'i L2'deki alıcı adresine aktarmak için L2 bloğuna karşılık gelen bir L2 işlemini dahil edecektir.
+
+5. L2 işlemi, aktarılan mesajı yürüten `L2ScrollMessenger.relayMessage` işlevini çağırır.
+ ETH yatırma durumunda, `relayMessage` fonksiyonu, ETH'yi L2'deki alıcı hesabına aktarmak için `L2ETHGateway.finalizeDepositETH`i çağırır.
+
+6. Kullanıcı L1'de `depositETHAndCall` çağırırsa, `L2ETHGateway` sözleşmesindeki `finalizeDepositETH`, ek verileri hedef L2 sözleşmesine iletecektir.
+
+## ERC20 Tokenlarını Yatırma
+
+Standart ERC20 tokenleri, özel ERC20 tokenleri ve Wrapped ETH tokeni gibi farklı ERC20 token türlerini birbirine bağlamak için çeşitli ERC20 ağ geçidi sözleşmeleri sağlanmıştır. `L1GatewayRouter`, ERC20 tokenlerinin L1'deki karşılık gelen ERC20 ağ geçidine kanonik eşlemesini kaydeder. `L1GatewayRouter`, özel bir ağ geçidi önceden kurulmadığı sürece yeni ERC20 tokenleri için varsayılan ERC20 ağ geçidi olarak `StandartERC20Gateway`i kullanır.
+
+ERC20 tokenlerinin yatırılması aşağıdaki şekilde çalışır.
+
+1. L1'den L2'ye ERC20 tokenlarını yatırmak için kullanıcılar aşağıda gösterilen `L1GatewayRouter.depositERC20` ve `L1GatewayRouter.depositERC20AndCall`ı kullanabilirler.
+
+ ```solidity
+ function depositERC20(address _token, uint256 _amount, uint256 _gasLimit) external payable;
+
+ function depositERC20(address _token, address _to, uint256 _amount, uint256 _gasLimit) external payable;
+
+ function depositERC20AndCall(
+ address _token,
+ address _to,
+ uint256 _amount,
+ bytes memory _data,
+ uint256 _gasLimit
+ ) public payable;
+ ```
+
+2. ERC20 tokenlerinden ağ geçidine yapılan eşlemeyi temel alarak, `L1GatewayRouter` ilgili ağ geçidini çağırır: `L1StandardERC20Gateway`, `L1CustomERC20Gateway` veya `L1WETHGateway`. Adımların geri kalanı ayrı ayrı açıklanacaktır.
+
+### Standart ERC20 Tokenları
+
+Standart ERC20 tokenleri herhangi bir özel mantık gerektirmeyen tokenlardır. Bu tür tokenler için L2 ERC20 token sözleşmeleri `L2StandardERC20Gateway` tarafından oluşturulur. Standart ERC20 token yatırma işlemi için kalan adımlar şunlardır:
+
+3. `L1StandardERC20Gateway` sözleşmesi, ERC20 tokenlerini göndericiden kendisine aktararak kilitler.
+4. Bu ERC20 tokeni daha önce `L1StandardERC20Gateway` aracılığıyla çekilmemişse, `L1StandardERC20Gateway` deterministik bir L2 ERC20 token adresi hesaplayacak ve token meta verilerini (sembol, ad ve ondalık sayılar) gelecekte L2'daki potansiyel sözleşme dağıtımı (deployment) için mesaja ekleyecektir. L2 token adresi zaten `tokenMapping`de kayıtlıysa, `L1StandardERC20Gateway` eşlemeden L2 token adresini doğrudan yükleyecektir.
+5. 'L1StandardERC20Gateway', token yatırma mesajını kodlar ve mesajı göndermek için 'L1ScrollMessenger'ı çağırır.
+6. İlgili L2 işlemi, L2'deki para yatırma işlemini tamamlamak için `L2ScrollMessenger.relayMessage` fonksiyonunu çağırır. Standart ERC20 token yatırma durumunda ise işlem daha sonra `L2StandardERC20Gateway.finalizeDepositERC20`yi çağırır.
+7. Bu ERC20 token sözleşmesi L2'de konuşlandırılmamışsa, `L2StandardERC20Gateway` mesajdan token metadata'yı çıkaracak ve standart ERC20 tokenını L2'de dağıtmak için `ScrollStandardERC20Factory`yi çağıracaktır.
+8. `L2StandardERC20Gateway`, ilgili L2 ERC20 token sözleşmesindeki mint fonksiyonunu çağırır.
+9. Kullanıcı L1'de `depositERC20AndCall`ı çağırırsa, `L2StandardERC20Gateway` ek verilerle hedef L2 sözleşmesini çağıracaktır.
+
+### Özel ERC20 Tokenları
+
+Standart ERC20 tokenlarıyla karşılaştırıldığında, özel ERC20 tokenlarının L2 sözleşmesi token sahibi tarafından dağıtılır. Özel ERC20 token yatırma işlemi için kalan adımlar şunlardır:
+
+3. 'L1CustomERC20Gateway' sözleşmesi, ERC20 tokenlerini göndericiden kendisine aktararak L1'de kilitler.
+4. 'L1CustomERC20Gateway', 'tokenMapping'de mevcut bir L2 ERC20 token adresini gerektirir. İlgili ERC20 token adresini alır, token yatırma mesajını kodlar ve bunu 'L1ScrollMessenger'a iletir.
+5. İlgili L2 işlemi, L2'deki para yatırma işlemini tamamlamak için 'L2ScrollMessenger.relayMessage' fonksiyonunu çağırır. Özel ERC20 token yatırmaları durumunda, işlem 'L2CustomERC20Gateway.finalizeDepositERC20'yi çağırır.
+6. 'L2CustomERC20Gateway', ilgili L2 ERC20 token sözleşmesindeki mint fonksiyonunu çağırır. L2 ERC20 token sözleşmesinin, 'L2CustomERC20Gateway' sözleşmesine mint izinleri vermesi gerekir.
+7. Kullanıcı L1'de 'depositERC20AndCall'ı çağırırsa, 'L2CustomERC20Gateway' ek verilerle hedef L2 sözleşmesini çağıracaktır.
+
+### WETH Tokeni
+
+L1'de Wrapped ETH tokeni için özel bir ağ geçidi `L1WETHGateway` sağlıyoruz ve ağ geçidi adresini `L1GatewayRouter`a kaydediyoruz. WETH tokeninin yatırılması şu şekilde çalışır.
+
+3. `L1WETHGateway`, WETH tokenlarını göndericiden kendisine aktararak ve WETH tokenını yerel ETH tokenine dönüştürerek kilitler. ETH tokenı ve `msg.value` (geçiş ücretinin ödenmesi için) daha sonra birlikte `L1ScrollMessenger` sözleşmesine gönderilir.
+4. `L1WETHGateway`, token yatırma mesajını kodlar ve bunu `L1ScrollMessenger`a iletir.
+5. İlgili L2 işlemi, L2'deki para yatırma işlemini tamamlamak için `L2ScrollMessenger.relayMessage` işlevini çağırır. WETH tokeni yatırma durumunda, işlem `L2WETHGateway.finalizeDepositERC20`yi çağırır.
+6. `L2WETHGateway`, yatırılan ETH'yi tekrar L2 WETH token'a sarar ve L2'deki alıcı adresine aktarır.
+7. Kullanıcı L1'de `depositERC20AndCall`ı çağırırsa, `L2WETHGateway` ek verilerle hedef L2 sözleşmesini arayacaktır.
+
+## ERC-721/ERC-1155 Tokenlarını Yatırma
+
+ERC-721 veya ERC-1155 tokenlarının yatırılması, ERC20 tokenlerine çok benzer şekilde çalışır. L1'den ERC-721 /ERC-1155 tokenlarını yatırmak için `L1ERC721Gateway` veya `L1ERC1155Gateway` ağ geçitleri kullanılabilir.
+
+```solidity
+function depositERC721(
+ address _token,
+ uint256 _tokenId,
+ uint256 _gasLimit
+) external payable;
+
+function depositERC721(
+ address _token,
+ address _to,
+ uint256 _tokenId,
+ uint256 _gasLimit
+) external payable;
+
+function depositERC1155(
+ address _token,
+ uint256 _tokenId,
+ uint256 _amount,
+ uint256 _gasLimit
+) external payable;
+
+function depositERC1155(
+ address _token,
+ address _to,
+ uint256 _tokenId,
+ uint256 _amount,
+ uint256 _gasLimit
+) external payable;
+```
+
+Büyük miktarda ERC-721 veya ERC-1155 token yatırma işlemini kolaylaştırmak amaçlı, aşağıdaki işlevler aracılığıyla `L1ERC721Gateway` ve `L1ERC1155Gateway` sözleşmesinde toplu para yatırma işlevleri de sağlıyoruz:
+
+```solidity
+function batchDepositERC721(
+ address _token,
+ uint256[] calldata _tokenIds,
+ uint256 _gasLimit
+) external payable;
+
+function batchDepositERC721(
+ address _token,
+ address _to,
+ uint256[] calldata _tokenIds,
+ uint256 _gasLimit
+) external payable;
+
+function batchDepositERC1155(
+ address _token,
+ uint256[] calldata _tokenIds,
+ uint256[] calldata _amounts,
+ uint256 _gasLimit
+) external payable;
+
+function batchDepositERC1155(
+ address _token,
+ address _to,
+ uint256[] calldata _tokenIds,
+ uint256[] calldata _amounts,
+ uint256 _gasLimit
+) external payable;
+```
+
+ERC-721 veya ERC-1155 tokenleri için L2 muadil sözleşmeleri `L2ERC721Gateway` ve `L2ERC1155Gateway`dir. Bunlar L2'deki para yatırma işlemlerini tamamlamak için kullanılır.
\ No newline at end of file
diff --git a/src/content/docs/tr/technology/bridge/withdraw-gateways.mdx b/src/content/docs/tr/technology/bridge/withdraw-gateways.mdx
new file mode 100644
index 000000000..f0e7d0c2e
--- /dev/null
+++ b/src/content/docs/tr/technology/bridge/withdraw-gateways.mdx
@@ -0,0 +1,166 @@
+---
+section: technology
+date: Last Modified
+title: "Çekim Ağ Geçitleri"
+lang: "tr"
+permalink: "technology/bridge/withdraw-gateways"
+whatsnext: { "Sıralayıcı": "/tr/technology/sequencer/execution-node/" }
+---
+
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import Aside from "../../../../../components/Aside.astro"
+import WithdrawWorkflow from "../_images/withdraw.png"
+
+Bu belge, kullanıcıların ve geliştiricilerin, tokenleri L2'den L1'e çekmek için ağ geçitlerini nasıl kullanabileceğini açıklamaktadır. Aşağıdaki tabloda listelenen, standart tokenler için çeşitli ağ geçitleri ve L2'de bir ağ geçidi yönlendiricisi sağlıyoruz.
+
+| Gateway Kontratı | Açıklama |
+| ------------------------ | ---------------------------------------------------------------------------- |
+| `L2GatewayRouter` | Ağ geçidi yönlendiricisi, ETH ve ERC20 tokenlarının yatırılmasını destekler. |
+| `L2ETHGateway` | ETH yatırmak için ağ geçidi. |
+| `L2StandardERC20Gateway` | Standart ERC20 token yatırma işlemleri için ağ geçidi. |
+| `L2CustomERC20Gateway` | Özel ERC20 token yatırma işlemleri için ağ geçidi. |
+| `L2WETHGateway` | Wrapped ETH yatırma işlemleri için ağ geçidi. |
+| `L2ERC721Gateway` | ERC-721 token yatırma işlemleri için ağ geçidi. |
+| `L2ERC1155Gateway` | ERC-1155 token yatırma işlemleri için ağ geçidi. |
+
+## Genel Bakış
+
+
+
+Şekilde L2'den L1'e para çekme iş akışı gösterilmektedir. Kullanıcılar token çekme işlemini başlatmak için ağ geçitlerini ararlar. Geri çekme işlemi `L2ScrollMessenger`a gönderilen bir mesajla kodlanır ve bu mesaj daha sonra `L2MessageQueue`ya eklenir. `L2MessageQueue` bir Withdraw Trie'sini korur ve her yeni mesaj eklendiğinde kökü günceller. Withdraw Trie kökü, L2 durum kökü ile birlikte L1 rollup sözleşmesinde sonlandırılır. Yeni Withdraw Trie kökü L1'de sonlandırıldıktan sonra, kullanıcılar veya üçüncü taraflar Withdraw Trie köküne geçerli bir Merkle Inclusion Kanıtı oluşturabilir ve L1'de çekilmeyi tamamlamak için bir _withdraw execution_ işlemi gönderebilir. L2'den L1'e mesaj aktarma iş akışı hakkında daha fazla ayrıntıyı [Alanlar Arası Mesajlaşma](/technology/bridge/cross-domain-messaging#sending-messages-from-l2-to-l1) bölümünde bulabilirsiniz.
+
+Sonraki bölümlerde farklı tokenlerin nasıl geri çekildiğinin ayrıntıları açıklanmaktadır.
+
+## ETH'i Çekme
+
+ETH tokenının çekilmesi şu şekilde çalışır.
+
+1. `L2GatewayRouter`, ETH'i L2'den L1'e çekmek için üç işlev sağlar. `withdrawETHAndCall` işlevi, aynı anda ETH'i çekebilir ve bir sözleşme çağrısı gerçekleştirebilir.
+
+ ```solidity
+ function withdrawETH(uint256 _amount, uint256 _gasLimit) external payable;
+
+ function withdrawETH(address _to, uint256 _amount, uint256 _gasLimit) public payable;
+
+ function withdrawETHAndCall(
+ address _to,
+ uint256 _amount,
+ bytes calldata _data,
+ uint256 _gasLimit
+ ) external payable;
+ ```
+
+2. `withdrawETHAndCall` işlevleri `L2ETHGateway`i çağırır. `L2ETHGateway`, çekilme mesajını kodlar ve çekilen ETH ile birlikte `L2ScrollMessenger` sözleşmesine gönderir.
+3. Geri çekilen ETH tekrar `L2ScrollMessenger` sözleşmesine kilitlenir. `L2ScrollMessenger`, mesajı `L2MessageQueue` sözleşmesindeki mesaj kuyruğuna ekler.
+4. L1'deki para çekme işlemi, para çekme işlemini tamamlamak için `L1ScrollMessenger.relayMessageWithProof` fonksiyonunu çağırır. ETH'in çekilmesi durumunda, `relayMessageWithProof` fonksiyonu, ETH'i L1'deki alıcı hesabına geri göndermek için `L1ETHGateway.finalizeWithdrawETH`i çağırır.
+5. Kullanıcı L2'de `withdrawETHAndCall` fonksiyonunu çağırırsa, `L1ETHGateway` sözleşmesindeki `finalizeWithdrawETH`, ek verileri hedef L1 sözleşmesine iletecektir.
+
+## ERC20 Tokenlarının Çekilmesi
+
+ERC20 tokenlarının geri çekilmesi şu şekilde çalışır.
+
+1. ERC20 tokenlerini L1'den L2'ye çekmek için kullanıcılar aşağıda gösterilen `L2GatewayRouter.withdrawERC20` ve `L2GatewayRouter.withdrawERC20AndCall`ı kullanabilirler.
+
+ ```solidity
+ function withdrawERC20(address _token, uint256 _amount, uint256 _gasLimit) external payable;
+
+ function withdrawERC20(address _token, address _to, uint256 _amount, uint256 _gasLimit) external payable;
+
+ function withdrawERC20AndCall(
+ address _token,
+ address _to,
+ uint256 _amount,
+ bytes memory _data,
+ uint256 _gasLimit
+ ) public payable;
+ ```
+
+2. ERC20 tokenlerinden ağ geçidine yapılan eşlemeye bağlı olarak, `L2GatewayRouter` ilgili ağ geçidini, `L2StandardERC20Gateway`, `L2CustomERC20Gateway` veya `L2WETHGateway`i çağırır. Adımların geri kalanı ayrı ayrı açıklanacaktır.
+
+### Standart ve Özel ERC20 Tokenları
+
+Standart ve özel ERC20 tokenlarının geri çekilmesi aşağıdaki şekilde gerçekleşir.
+
+3. `L2StandardERC20Gateway` veya `L2CustomERC20Gateway` sözleşmesi, çekilen ERC20 tokenını yakar, çekilme işlemini bir mesaja kodlar ve `L2ScrollMessenger`a gönderir.
+4. L1 para çekme işleminin kendisi, L1'deki para çekme işlemlerini tamamlamak için `L1ScrollMessenger.relayMessageWithProof` fonksiyonunu çağırır. Standart veya özel ERC20 tokenının çekilmesi durumunda, işlem sırasıyla `L1StandardERC20Gateway` veya `L1CustomERC20Gateway` sözleşmesinde `finalizeWithdrawERC20` fonksiyonunu çağırır.
+ - `L1StandardERC20Gateway` sözleşmesinde, eğer bu bir ERC20 tokenının ilk çekilme işlemiyse, `finalizeWithdrawERC20` işlevi, eşlemeyi `tokenMapping`de L1 token adresinden L2 token adresine güncelleyecektir.
+5. L1 ERC20 token ağ geçidi, kilitli ERC20 tokenlarını kendisinden L1'deki alıcı adresine aktararak serbest bırakır.
+6. Kullanıcı L2'de `withdrawERC20AndCall` çağırırsa ağ geçitleri ek verilerle hedef L1 sözleşmesini arayacaktır.
+
+### WETH Tokenı
+
+L2'de Wrapped ETH tokenı için özel bir ağ geçidi `L2WETHGateway` sağlıyoruz ve ağ geçidi adresini `L2GatewayRouter`a kaydediyoruz. WETH tokenının geri çekilmesi şu şekilde çalışır.
+
+3. `L2WETHGateway`, çekilen WETH tokenını kendisine aktarır ve WETH tokenını yerel ETH tokenına dönüştürür. ETH tokenı daha sonra `L2ScrollMessenger` sözleşmesine geri gönderilir.
+4. `L2WETHGateway`, token çekme mesajını kodlar ve bunu `L2ScrollMessenger`a iletir.
+5. L1 para çekme işleminin kendisi, L1'de para çekme işlemini tamamlamak için `L1ScrollMessenger.relayMessageWithProof` fonksiyonunu çağırır. WETH tokenının çekilmesi durumunda, işlem `L1WETHGateway.finalizeWithdrawERC20` çağrısını yapar ve ETH cinsinden çekilen tutarı `L1WETHGateway`e gönderir.
+6. 'L1WETHGateway', çekilen ETH'i tekrar L1 WETH token'a sarar ve L1'deki alıcı adresine aktarır.
+7. Kullanıcı L2'de `withdrawERC20AndCall` fonksiyonunu çağırırsa, `L1WETHGateway` ek verilerle birlikte hedef L1 adresini çağıracaktır.
+
+## ERC-721/ERC-1155 Tokenlarının Geri Çekilmesi
+
+ERC-721 veya ERC-1155 tokenlarının geri çekilmesi, ERC20 tokenlerine çok benzer şekilde çalışır. ERC-721 /ERC-1155 tokenlerini L2'den çekmek için `L2ERC721Gateway` veya `L2ERC1155Gateway` ağ geçidi kullanılabilir.
+
+```solidity
+function withdrawERC721(
+ address _token,
+ uint256 _tokenId,
+ uint256 _gasLimit
+) external payable;
+
+function withdrawERC721(
+ address _token,
+ address _to,
+ uint256 _tokenId,
+ uint256 _gasLimit
+) external payable;
+
+function withdrawERC1155(
+ address _token,
+ uint256 _tokenId,
+ uint256 _amount,
+ uint256 _gasLimit
+) external payable;
+
+function withdrawERC1155(
+ address _token,
+ address _to,
+ uint256 _tokenId,
+ uint256 _amount,
+ uint256 _gasLimit
+) external payable;
+```
+
+Büyük miktarda ERC-721 veya ERC-1155 token çekimini kolaylaştırmak için, aşağıdaki işlevler aracılığıyla `L2ERC721Gateway` ve `L2ERC1155Gateway` sözleşmesinde toplu para çekme işlevleri de sağlıyoruz:
+
+```solidity
+function batchWithdrawERC721(
+ address _token,
+ uint256[] calldata _tokenIds,
+ uint256 _gasLimit
+) external payable;
+
+function batchWithdrawERC721(
+ address _token,
+ address _to,
+ uint256[] calldata _tokenIds,
+ uint256 _gasLimit
+) external payable;
+
+function batchWithdrawERC1155(
+ address _token,
+ uint256[] calldata _tokenIds,
+ uint256[] calldata _amounts,
+ uint256 _gasLimit
+) external payable;
+
+function batchWithdrawERC1155(
+ address _token,
+ address _to,
+ uint256[] calldata _tokenIds,
+ uint256[] calldata _amounts,
+ uint256 _gasLimit
+) external payable;
+```
+
+ERC-721 veya ERC-1155 tokenleri için L1 muadil sözleşmeleri, L1'deki para çekme işlemlerini tamamlamak için `L1ERC721Gateway` ve `L1ERC1155Gateway` sözleşmeleridir.
\ No newline at end of file
diff --git a/src/content/docs/tr/technology/chain/accounts.mdx b/src/content/docs/tr/technology/chain/accounts.mdx
new file mode 100644
index 000000000..64dff72b0
--- /dev/null
+++ b/src/content/docs/tr/technology/chain/accounts.mdx
@@ -0,0 +1,29 @@
+---
+section: technology
+date: Last Modified
+title: "Hesaplar ve Durum"
+lang: "tr"
+permalink: "technology/chain/accounts-and-state"
+whatsnext: { "İşlemler": "/tr/technology/chain/transactions/" }
+---
+
+## Hesaplar
+
+Ethereum'da olduğu gibi Scroll'un da iki hesap türü vardır: Harici sahipli hesap (EOA - Externally-Owned Account) ve akıllı sözleşmeyi ve ek depoları tutan sözleşme hesabı.
+
+Scroll, durum geçişini daha verimli bir şekilde kanıtlamak amacıyla zkEVM devresini kolaylaştırmak için sözleşme bytecode'una ilişkin ek bilgileri hesapta saklar.
+
+Scroll'daki hesap aşağıdaki alanları içerir:
+
+- `nonce`: Gönderenin gönderdiği işlem sayısını gösteren sayaç.
+- `balance`: Hesaptaki 'ETH' tokeninin bakiyesi (wei cinsinden birim).
+- `storageRoot`: Depolama trie'sinin kök hash'i. Scroll, depolama trie'si için [zkTrie](/tr/techology/sequencer/zktrie)'yi kullandığından, "storageRoot", Poseidon hash'ini 256 bitlik bir tamsayıda saklar.
+- `codeHash`: Sözleşme bytecode'unun Keccak hash'i.
+- `PoseidonCodeHash` (**yeni alan**): Sözleşme bytecodu'nun 256 bitlik bir tam sayıdaki Poseidon hash'i.
+- `CodeSize` (**yeni alan**): Sözleşme bytecodu'nun byte cinsinden boyutu.
+
+## Durum
+
+Bir blokzincirin durumu, hesap verilerinin bir koleksiyonudur. _state trie_, hesap verilerini ve bunlara karşılık gelen adresleri bir [Merkle ağacı](https://en.wikipedia.org/wiki/Merkle_tree) veri yapısına kodlar. Ağacın kökü veya blokzincirin durumu, ağaçta bulunan tüm hesap verilerinin kriptografik bir özetidir.
+
+Ethereum, hem durum trie'si hem de depolama trie'si için [Patricia Merkle Trie](https://ethereum.org/en/developers/docs/data-structures-and-encoding/patricia-merkle-trie/) adlı bir veri yapısı kullanır, bu yapı bir akıllı sözleşmede anahtar/değer girişlerini saklar. Scroll'da Patricia Merkle Trie'yi hem durum denemesi hem de depolama denemesi için zkTrie adı verilen daha zk dostu bir veri yapısıyla değiştiriyoruz. Yüksek düzeyde, zkTrie veri yapısı, zk dostu bir hash fonksiyonu olan [Poseidon hashini](https://eprint.iacr.org/2019/458.pdf) içeren seyrek bir ikili Merkle ağacıdır. [zkTrie](/teknoloji/sequencer/zktrie) belgesinde bu veri yapısı hakkında daha fazla detaylı bilgi açıklanmaktadır.
diff --git a/src/content/docs/tr/technology/chain/blocks.mdx b/src/content/docs/tr/technology/chain/blocks.mdx
new file mode 100644
index 000000000..75c36e8d6
--- /dev/null
+++ b/src/content/docs/tr/technology/chain/blocks.mdx
@@ -0,0 +1,39 @@
+---
+section: technology
+date: Last Modified
+title: "Bloklar"
+lang: "tr"
+permalink: "technology/chain/blocks"
+whatsnext: { "Rollup Süreci": "/tr/technology/chain/rollup/" }
+---
+
+Blok, kendinden önceki bloğu devam ettirmeye yönelik işlemlerden ve bağlantılardan oluşan bir koleksiyondur.
+
+## Blok Başlığı
+
+Scroll'daki blok başlığı Ethereum'un yapısını yansıtır. Ancak blok başlığındaki belirli alanlar, aşağıdaki tabloda ayrıntılı olarak belirtildiği gibi, Katman 2 bağlamına uyacak şekilde değiştirilmiştir:
+
+| Alan | Açıklama |
+| ------------------- | ------------------------------------------------------------------ |
+| `parentHash` | Kendinden önceki bloğun hash'i. |
+| `uncleHash` | Her zaman `keccak256(rlp([]))`. |
+| `coinbase` | İşlem ücretleri önceden dağıtılan ücret kasası sözleşme adresi `0x5300000000000000000000000000000000000005`'e tahsil edilir. Çoğu durumda, RPC "madenci" alanı dönüşü sıfır adresidir `0x0000000000000000000000000000000000000000`. |
+| `stateRoot` | Durum trie'sinin kök hash'i. Aynı zamanda Poseidon'dur. |
+| `transactionsRoot ` | İşlem trie'sinin kök hash'i. |
+| `receiptsRoot ` | İşlem makbuzu trie'sinin kök hash'i. |
+| `logsBloom` | Olay kayıtlarını içeren veri yapısı. |
+| `difficulty` | Her zaman 1 veya 2'dir. |
+| `number` | Blok numarası. |
+| `gasLimit` | Blokta izin verilen maksimum gas. |
+| `gasUsed` | Blokta kullanılan gas. |
+| `timestamp` | Blok zaman damgası. |
+| `extraData` | Bloğu imzalayan kişinin imzası ve ardından isteğe bağlı ek veriler. |
+| `mixHash` | Her zaman 0. |
+| `nonce` | Her zaman 0. |
+| `baseFee` | Scroll'da EIP-1559'u etkinleştirmediğimiz için şu anda boş. |
+
+## Blok süresi
+
+Blok süresi ardışık iki blok arasındaki süreyi ifade eder. Scroll'da blok süresi 3 saniyeye ayarlanmıştır. Kısaltılmış blok süresi kullanıcı deneyimini iyileştirir ve Scroll zincirinin ölçeklenebilirliğini artırır.
+
+3 saniyelik blok süresi en iyi çaba esasına göre korunur, protokol tarafından garanti edilmez veya zorunlu kılınmaz.
diff --git a/src/content/docs/tr/technology/chain/differences.mdx b/src/content/docs/tr/technology/chain/differences.mdx
new file mode 100644
index 000000000..42a90c5db
--- /dev/null
+++ b/src/content/docs/tr/technology/chain/differences.mdx
@@ -0,0 +1,46 @@
+---
+section: technology
+date: Last Modified
+title: "Ethereum EVM'inden Farklar"
+lang: "tr"
+permalink: "technology/chain/differences"
+whatsnext: { "Köprü": "/tr/technology/bridge/cross-domain-messaging/" }
+---
+
+## Opcode'lar
+
+| Opcode | Scroll Davranışı |
+| --------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| `BLOCKHASH` | Son 256 blok için `keccak(chain_id \|\| block_number)`nı döndürür. |
+| `COINBASE` | Ücret kasası adresini döndürür (önceden konuşlandırılmış sözleşme `0x5300000000000000000000000000000000000005`). |
+| `DIFFICULTY` / `PREVRANDAO` | Her zaman 0 değerini döndür. |
+| `BASEFEE` | Şu anda EIP-1559'u devre dışı bıraktığımız için devre dışı bırakıldı. Opcode ile karşılaşılırsa işlem geri alınacaktır.|
+| `SELFDESTRUCT` | Devre dışı bırakıldı. Opcode ile karşılaşılırsa işlem geri alınacaktır. |
+
+## Önceden Derlenmiş Sözleşmeler
+
+| Adres | İsim | Scroll Davranışı |
+| ------- | ------------ | ----------------------------------------------------------------------------------------------- |
+| '0x02' | 'SHA2-256' | Şu anda desteklenmiyor. |
+| '0x03' | 'RIPEMD-160' | Şu anda desteklenmiyor. |
+| '0x05' | 'modexp' | B, E, M giriş değerlerini $2^{256}$'dan küçük imzasız tamsayılarla sınırlar. |
+| '0x08' | 'ecPairing' | Girişler hala 6 adet 32 bytelık değerin tam katıdır ancak demet sayısını en fazla 4 ile sınırlandırır.
+| '0x09' | 'blake2f' | Şu anda desteklenmiyor. |
+
+Geriye kalan önceden derlenmiş sözleşmeler Ethereum ile aynı davranışa sahiptir. Ancak bir blok içindeki maksimum kullanımları zkEVM devre kapasitesine bağlı bir limit ile sınırlıdır.
+
+## EIP'ler
+
+Sıralayıcımız başlangıçta Londra çatallanmasına dayalı olarak geliştirildi. Uyumluluğu geliştirmek için Londra çatallanmasındaki bazı EIP'leri devre dışı bıraktık ve Şanghay çatallanmasından birkaç EIP'yi tanıttık.
+
+Londra çatallanmasına kadar devre dışı bırakılan EIP'ler:
+
+- [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559): Ücret piyasası değişikliği ve EIP-1559 işlem türü
+- [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930): İsteğe bağlı erişim listeleri
+- [EIP-3198](https://eips.ethereum.org/EIPS/eip-3198): BASEFEE opcode
+
+Şangay çatallanmasından gelen EIP'ler:
+
+- [EIP-3651](https://eips.ethereum.org/EIPS/eip-3651): Warm `COINBASE'
+- [EIP-3855](https://eips.ethereum.org/EIPS/eip-3855): PUSH0 talimatı
+- [EIP-3860](https://eips.ethereum.org/EIPS/eip-3860): initcode'u sınırlar ve ölçer
diff --git a/src/content/docs/tr/technology/chain/rollup.mdx b/src/content/docs/tr/technology/chain/rollup.mdx
new file mode 100644
index 000000000..4588d62c8
--- /dev/null
+++ b/src/content/docs/tr/technology/chain/rollup.mdx
@@ -0,0 +1,155 @@
+---
+section: technology
+date: Last Modified
+title: "Rollup Süreci"
+lang: "tr"
+permalink: "technology/chain/rollup"
+whatsnext: { "Ethereum EVM'inden Farklar": "/tr/technology/chain/differences/" }
+---
+
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import RollupProcess from "../_images/rollup.png"
+
+Bu belgede Scroll'daki rollup işlemi açıklanmaktadır.
+
+## İş Akışı
+
+
+
+Şekilde rollup iş akışı gösterilmektedir. L2 sıralayıcısı üç modül içerir:
+
+- **Senkronizasyon hizmeti** L1 köprü sözleşmesinden düzenlenen etkinliğe abone olur. L1 gelen kutusuna yeni eklenen mesajları tespit ettiğinde, Senkronizasyon Hizmeti buna göre yeni bir "L1MessageTx" işlemi oluşturacak ve bunu yerel L1 işlem kuyruğuna ekleyecektir.
+- **Mempool** doğrudan L2 sıralayıcısına gönderilen işlemleri toplar.
+- **Yürütücü** hem L1 işlem kuyruğundan hem de L2 mempool'dan işlemleri çeker ve yeni bir L2 bloğu oluşturmak için bunları yürütür.
+
+Rollup düğümü üç modül içerir:
+
+- **Aktarıcı**, veri kullanılabilirliği ve kesinliği için taahhüt işlemlerini ve sonlandırma işlemlerini rollup sözleşmesine gönderir.
+- **Parça Önerici** ve **Yığın Önerici**, [İşlem Toplu İşleme](/tr/technology/chain/transactions#transaction-batching) bölümünde açıklanan kısıtlamalara uygun olarak yeni parçalar ve yeni yığınlar önerir.
+
+Rollup süreci üç aşamaya ayrılabilir: işlemin yürütülmesi, yığın oluşturma ve veri taahhüdü, kanıt oluşturma ve sonuçlandırma.
+
+### Aşama 1. İşlemin Yürütülmesi
+
+1. Kullanıcılar işlemleri L1 köprü sözleşmesine veya L2 sıralayıcılara gönderir.
+2. L2 sıralayıcıdaki Senkronizasyon Hizmeti, köprü sözleşmesinden en son eklenen L1 işlemlerini getirir.
+3. L2 sıralayıcı, L2 blokları oluşturmak için hem L1 mesaj kuyruğundan hem de L2 bellek havuzundan gelen işlemleri işler.
+
+### Aşama 2. Yığın Oluşturma ve Veri Taahhüdü
+
+4. Rollup düğümü en son L2 bloklarını izler ve işlem verilerini getirir.
+5. Kriter ([İşlem Toplu İşleme](/tr/technology/chain/transactions#transaction-batching) bölümünde açıklanan) karşılanırsa, rollup düğümü yeni bir yığın veya parça önerir ve bunu veritabanına yazar. Aksi halde rollup düğümü daha fazla blok veya parça beklemeye devam eder.
+6. Yeni bir yığın oluşturulduktan sonra, rollup aktarıcısı bu yığındaki işlem verilerini toplar ve verilerin kullanılabilirliği için rollup sözleşmesine bir Taahhüt İşlemi gönderir.
+
+### Aşama 3. Kanıt Oluşturma ve Sonlandırma
+
+7. Koordinatör veri tabanından yeni bir parça veya yığını yokladığında:
+ - Yeni bir parça üzerine koordinatör, L2 sıralayıcıdan bu yığındaki tüm blokların yürütme izlerini sorgulayacak ve ardından rastgele seçilen bir zkEVM kanıtlayıcıya bir parça kanıtlama görevi gönderecektir.
+ - Yeni bir yığın üzerine, koordinatör bu yığındaki tüm parçaların parça kanıtlarını veri tabanından toplayacak ve rastgele seçilen bir toplayıcı kanıtlayıcıya bir yığın kanıtlama görevi gönderecektir.
+8. Koordinatör kanıtlayıcıdan parça veya yığın kanıtı aldığında, kanıtı veri tabanına yazacaktır.
+9. Rollup aktarıcısı veri tabanından yeni bir yığın seçtiğinde, kanıtı doğrulamak için rollup sözleşmesine bir Sonlandırma İşlemi gönderecektir.
+
+## Taahhüt İşlemi
+
+Taahhüt İşlemi, veri kullanılabilirliği için blok bilgilerini ve işlem verilerini L1'e gönderir. İşlem, yığın başlığını, parça verilerini ve atlanan L1 mesajının bir bit eşlemini içerir. Üst yığın başlığı, bu yığının bağlandığı önceki yığını belirtir. Üst yığın daha önce işlenmelidir; aksi takdirde işlem geri alınacaktır. Aşağıdaki `commitBatch` işlev imzasına bakın.
+
+```solidity
+function commitBatch(
+ uint8 version,
+ bytes calldata parentBatchHeader,
+ bytes[] memory chunks,
+ bytes calldata skippedL1MessageBitmap
+) external override OnlySequencer
+```
+
+`commitBatch` işlevi üst yığının daha önce taahhüt edildiğini doğruladıktan sonra yığının, yığın başlığını oluşturur ve yığının başlığının hash'ini `ScrollChain` sözleşmesine kaydeder.
+
+```solidity
+mapping(uint256 => bytes32) public committedBatches;
+```
+
+Yığın ve parça verilerinin kodlanması [Codec](#codec) bölümünde açıklanmaktadır. Yığın başlığındaki alanların çoğu, parça verilerinden türetilecek şekilde basittir. Dikkat edilmesi gereken önemli alanlardan biri, geçerlilik kanıtını doğrulamak için kamuya açık girdinin bir parçası haline gelecek olan `dataHash`tır. Bir yığının "n" parça içerdiğini varsayarsak, `dataHash` aşağıdaki şekilde hesaplanır.
+
+```
+batch.dataHash := keccak(chunk[0].dataHash || ... || chunk[n-1].dataHash)
+```
+
+Bir parçanın 'k' blok içerdiğini varsayarsak, onun `dataHash`ı aşağıdaki şekilde hesaplanır:
+
+```
+chunk.dataHash := keccak(blockContext[0] || ... || blockContext[k-1] ||
+ block[0].l1TxHashes || block[0].l2TxHashes || ... ||
+ block[k-1].l1TxHashes || block[k-1].l2TxHashes)
+```
+
+Burada `block.l1TxHashes` bu bloktaki L1 işlemlerinin birleştirilmiş işlem hash'leridir ve `block.l2TxHashes` ise bu bloktaki L2 işlemlerinin birleştirilmiş işlem hash'leridir. L1 işlemlerinin işlem hash'lerinin rollup düğümü tarafından yüklenmediğini, bunun yerine bu blokta yer alan L1 mesajlarının indeks aralığı göz önüne alındığında doğrudan `L1MessageQueue` sözleşmesinden yüklendiğini unutmayın. L2 işlem hash'leri, [`Chunk`](#Chunk-Codec) içindeki `l2Transactions` alanındaki RLP kodlu bytelardan hesaplanır.
+
+Ek olarak, `commitBatch` fonksiyonu atlanan L1 mesajlarının bir bit eşlemini içerir. Ne yazık ki bunun nedeni kanıt taşması sorunudur. Bir L1 mesajına karşılık gelen L1 işlemi devre kapasitesi sınırını aşarsa, bu işlem için geçerli bir kanıt oluşturamayacağız ve dolayısıyla L1'de sonlandıramayız. Scroll, kanıtlama sistemimizde yapılan yükseltmeler yoluyla kanıt taşması sorununu ortadan kaldırmak için aktif olarak çalışıyor.
+
+## Sonlandırma İşlemi
+
+Sonlandırma İşlemi, daha önce taahhüt edilen yığını geçerlilik kanıtıyla sonlandırır. İşlem ayrıca toplu işlemden sonra durum kökünü ve çekilme kökünü de gönderir. İşte `finalizeBatchWithProof`un işlev imzası:
+
+```solidity
+function finalizeBatchWithProof(
+ bytes calldata batchHeader,
+ bytes32 prevStateRoot,
+ bytes32 postStateRoot,
+ bytes32 withdrawRoot,
+ bytes calldata aggrProof
+) external override OnlyProver
+```
+
+finalizeBatchWithProof` işlevi ilk olarak yığının sözleşmede taahhüt edilip edilmediğini doğrular. Daha sonra genel giriş hash'ini aşağıdaki gibi hesaplar
+
+```
+publicInputHash := keccak(chainId || prevStateRoot || postStateRoot || withdrawRoot || batch.dataHash)
+```
+
+Genel giriş hash'i ve geçerlilik kanıtı, plonk sağlamlık doğrulayıcıya gönderilir. Doğrulama başarılı olduktan sonra yeni durum kökü ve çekim kökü `ScrollChain` sözleşmesinde saklanır.
+
+```solidity
+mapping(uint256 => bytes32) public override finalizedStateRoots;
+mapping(uint256 => bytes32) public override withdrawRoots;
+```
+
+Bu aşamada en son sonuçlanan yığının durum kökü güvenilir bir şekilde kullanılabilir ve o yığındaki para çekme işlemleri, para çekme köküne Merkle kanıtı kullanılarak L1 üzerinden gerçekleştirilebilir.
+
+## Codec
+
+Bu bölümde rollup sözleşmesindeki üç veri yapısının codec'i açıklanmaktadır: `BatchHeader`, `Chunk`, ve `BlockContext`.
+
+### `BatchHeader` Codec
+
+| Alan | Bytes | Veri tipi | Offset | Açıklama |
+| ------------------------ | ------- | ----------- | ------ | --------------------------------------------------------------- |
+| `version` | 1 | `uint8` | 0 | Yığın başlık sürümü |
+| `batchIndex` | 8 | `uint64` | 1 | Yığının indeksi |
+| `l1MessagePopped` | 8 | `uint64` | 9 | Yığında açılan L1 mesajlarının sayısı |
+| `totalL1MessagePopped` | 8 | `uint64` | 17 | Yığından sonra açılan toplam L1 mesajlarının sayısı |
+| `dataHash` | 32 | `bytes32` | 25 | Yığının veri hashi |
+| `parentBatchHash` | 32 | `bytes32` | 57 | Üst yığının hashi |
+| `skippedL1MessageBitmap` | dynamic | `uint256[]` | 89 | Yığında hangi L1 mesajlarının atlandığını gösteren bir bit eşlem |
+
+### `Chunk` Codec
+
+| Alan | Bytes | Veri tipi | Offset | Açıklama |
+| ---------------- | ------- | -------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `numBlocks` | 1 | `uint8` | 0 | Parçadaki blok sayısı |
+| `block[0]` | 60 | `BlockContext` | 1 | İlk bloğun blok bilgileri |
+| ... | ... | ... | ... | ... |
+| `block[i]` | 60 | `BlockContext` | `60*i+1` | `i+1`inci bloğun blok bilgisi |
+| ... | ... | ... | ... | ... |
+| `block[n-1]` | 60 | `BlockContext` | `60*n-59` | Son bloğun blok bilgisi |
+| `l2Transactions` | dynamic | `bytes` | `60*n+1` | İmzalarla L2 işlemlerinin birleştirilmiş RLP kodlaması. RLP kodlamasının bayt uzunluğu (`uint32`) her işlemden önce eklenir. |
+
+### `BlockContext` Codec
+
+| Alan | Bytes | Veri tipi | Offset | Açıklama |
+| ----------------- | ----- | --------- | ------ | ----------------------------------------------------------------------------------- |
+| `blockNumber` | 8 | `uint64` | 0 | Blok numarası |
+| `timestamp` | 8 | `uint64` | 8 | Blok zamanı |
+| `baseFee` | 32 | `uint256` | 16 | Bu bloğun taban ücreti. Şu anda her zaman 0'dır çünkü EIP-1559'u devre dışı bırakıyoruz. |
+| `gasLimit` | 8 | `uint64` | 48 | Bu bloğun gaz limiti |
+| `numTransactions` | 2 | `uint16` | 56 | Hem L1 hem de L2 tx'leri dahil olmak üzere bu bloktaki işlem sayısı |
+| `numL1Messages` | 2 | `uint16` | 58 | Bu bloktaki L1 mesajlarının sayısı |
diff --git a/src/content/docs/tr/technology/chain/transactions.mdx b/src/content/docs/tr/technology/chain/transactions.mdx
new file mode 100644
index 000000000..0e09d96e2
--- /dev/null
+++ b/src/content/docs/tr/technology/chain/transactions.mdx
@@ -0,0 +1,91 @@
+---
+section: technology
+date: Last Modified
+title: "İşlemler"
+lang: "tr"
+permalink: "technology/chain/transactions"
+whatsnext: { "Bloklar": "/tr/technology/chain/blocks/" }
+---
+
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import TransactionBatching from "../_images/batching.png"
+
+İşlem, zincir durumuna bir durum geçişini başlatan kriptografik olarak imzalanmış bir mesajdır. Bu, basit bir bakiye transferi veya akıllı bir sözleşmenin başlatılması olabilir ve bu da durumu değiştirmek için bir program yürütür.
+
+## İşlem tipi
+
+Şu anda Scroll üç tür işlemi desteklemektedir.
+
+- EIP-155 Öncesi İşlem: Bu, [Singleton Factory](https://eips.ethereum.org/EIPS/eip-2470) sözleşmesini desteklemek içindir.
+- Eski Tip İşlem (bkz. [EIP-155](https://eips.ethereum.org/EIPS/eip-155))
+- `L1MessageTx` Tipi Belirli İşlem (Tip: `0x7E`): Bu, aşağıda açıklandığı gibi Scroll'da tanıtılan yeni bir [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) işlemidir. Bu işlem tipi L1'de başlatılan işlemler içindir.
+
+Unutmayın ki [EIP-2930](https://eips.ethereum.org/EIPS/eip-2930) ve [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) işlem tipleri şu anda Scroll'da desteklenmemektedir. Scroll gelecekte bu iki işlem türünü geri getirecektir.
+
+### L1 Mesaj İşlemi
+
+L1 tarafından başlatılan işlemler için yeni bir tür işlem olan 'L1MessageTx'i sunuyoruz. Bu tür işlemler L1 köprü sözleşmesinde başlatılır. L1'deki 'L1MessageQueue' sözleşmesine her yeni mesaj eklendiğinde, L2 sıralayıcı, L2 bloklarına dahil edilecek karşılık gelen bir 'L1MessageTx' işlemi yaratacaktır. Kullanıcılar L1'de işlemi gönderdiğinde imza zaten dolaylı olarak doğrulanmış olduğundan, "L1MessageTx" işlemlerinin imzası yoktur.
+
+`L1MessageTx` işlem türü `0x7E` olup, yükü aşağıdaki gibi tanımlanmıştır.
+
+```go
+type L1MessageTx struct {
+ QueueIndex uint64 // The queue index of the message queue in L1 contract
+ Gas uint64 // Gas limit
+ To *common.Address // Cannot be nil, we do not allow contract creation from L1
+ Value *big.Int
+ Data []byte
+ Sender common.Address
+}
+```
+
+'L1MessageTx' işlemlerinin RLP (Recursive Length Prefix) kodlaması, [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718) 'TransactionType || TransactionPayload`; burada 'TransactionType', '0x7E' ve 'TransactionPayload = RLP(L1MessageTx)'dir.
+
+'L1MessageTx' işlemlerinin dikkat çeken iki davranışı:
+
+- İşlemdeki "QueueIndex", "Gönderen" hesabının "Nonce"inden farklı olarak L1 mesaj kuyruğundaki kuyruk indeksidir. Ancak gönderenin "Nonce" değeri işlem sonrasında yine 1 artacaktır.
+- Bu tür işlemlerde [L2 ücreti](/tr/developers/transaction-fees-on-scroll#l2-fee) veya [L1 ücreti](/tr/developers/transaction-fees-on-scroll#l1-fee) ödenmez . Kullanıcılar L1'de işlem gönderdiğinde L2 ücreti zaten ödenir. L1MessageTx işlemlerine ait veriler L1 köprü sözleşmesinde zaten mevcut olduğundan L1 ücreti alınmaz.
+
+## İşlem Yaşam Döngüsü
+
+Scroll'daki işlem yaşam döngüsü aşağıdaki üç aşamayı içerir:
+
+1. **Onaylandı**: Kullanıcılar L1 köprü sözleşmesine veya L2 sıralayıcıya bir işlem gönderir. İşlem yürütülüp L2 bloğuna dahil edildikten sonra 'Onaylandı' olur.
+2. **Taahhüt Edildi**: İşlemler bir gruba dahil edilir ve bu grubun verilerini içeren bir _taahhüt işlemi_ L1'e gönderilir. L1 bloklarında taahhüt işlemi tamamlandıktan sonra bu partideki işlemler 'Taahhüt Edildi' olur.
+3. **Sonlandırıldı**: Bu serinin geçerlilik kanıtı L1'de oluşturulur ve doğrulanır. _Sonlandırma işlemi_ L1'de sonlandırıldıktan sonra, işlemin durumu 'Sonlandırıldı' olur ve Scroll L2 zincirinin kanonik bir parçası haline gelir.
+
+### İşlemlerin Gönderilmesi
+
+Kullanıcıların Scroll'a işlem gönderebilecekleri iki giriş noktası vardır.
+
+İlk olarak kullanıcılar, işlemlerini doğrudan L2 sıralayıcılara gönderebilir. Bunu yapmak için kullanıcıların cüzdanlarını yapılandırmaları ve Scroll RPC uç noktasına bağlanmaları yeterlidir. Sıralayıcı işlemi doğrular ve yerel işlem havuzunda saklar.
+
+İkincisi, mevduat ve icra edilen işlemler L1'den kaynaklanmaktadır. Scroll L1 köprü sözleşmesi, kullanıcılara ve akıllı sözleşmelere L1'den işlem göndermeleri için üç giriş noktası sağlar. Bu üç giriş noktası üzerinden gönderilen tüm mesajlar 'L1MessageQueue' sözleşmesine eklenecektir.
+
+- 'ScrollGatewayRouter' sözleşmesi ve çeşitli standart token ağ geçitleri, kullanıcıların ve sözleşmelerin standart tokenları L2'ye yatırmasına olanak tanır. Daha fazla ayrıntıyı [Yatırma Ağ Geçitleri](/tr/technology/bridge/deposit-gateways) bölümünde bulabilirsiniz.
+- 'L1ScrollMessenger' sözleşmesi, kullanıcıların ve sözleşmelerin L2'ye isteğe bağlı mesajlar göndermesine olanak tanır. Daha fazla ayrıntıyı [Keyfi Mesaj Gönderme](/tr/technology/bridge/cross-domain-messaging#sending-arbitrary-messages) bölümünde bulabilirsiniz.
+- 'EnforcedTxGateway' sözleşmesi, EOA'ların aynı adresten zorunlu bir işlem başlatmasına, tokenleri çekmesine veya L2'deki diğer sözleşmeleri çağırmasına olanak tanır. Daha fazla ayrıntıyı [Zorunlu İşlem Gönderme](/tr/technology/bridge/cross-domain-messaging#sending-enforced-transactions) bölümünde bulabilirsiniz.
+
+Scroll sıralayıcısı periyodik olarak yeni bir madencilik işi başlatır. L1 mesajlarını 'L1MessageQueue' sözleşmesinden ve L2 mempool'daki işlemlerden çeker ve bir bloğu mühürler. Bir işlem L2 bloğuna dahil edildiğinde durumu 'Onaylandı' olur.
+
+### İşlem Verilerinin Taahhüdü
+
+Rollup düğümü, yeni L2 bloklarını toplar, bunları parçalar ve gruplar halinde paketler (daha fazla ayrıntı için [İşlem Yığınları](/tr/technology/chain/transactions#transaction-batching) bölümüne bakın). Periyodik olarak, bir işlem grubunun verilerini L1 "ScrollChain" sözleşmesine gönderen bir _Taahhüt İşlemi_ gönderir. Taahhüt İşlemi L1 bloğunda sonlandırıldıktan sonra bu partideki işlemlerin durumu 'Kaydedildi' olur. Şu anda kullanıcılar, L1 sözleşmesindeki taahhüt edilen verilere dayanarak L2 durumunu kendileri tamamen yeniden yapılandırabilirler.
+
+### İşlemlerin Sonlandırılması
+
+Geçerlilik kanıtı oluşturulduktan sonra rollup düğümü, zincir içi doğrulama için bu gruptan sonra geçerlilik kanıtını ve yeni durum kökünü içeren bir _Sonlandırma İşlemi_ gönderir. Sonlandırma İşlemi başarılı olduğunda ve bir L1 bloğunda onaylandığında, bu gruptaki L2 işlemlerinin durumu 'Sonlandırıldı' olur. Yeni durum kökü üçüncü taraflarca güvenle kullanılabilir.
+
+## İşlem Yığınları
+
+
+
+Scroll'da işlemler birden fazla katman halinde yığın hale getirilir.
+
+1. Bir grup sıralı işlem bir blok halinde paketlenir.
+2. Bir dizi bitişik blok, bir parça halinde gruplandırılır. Parça, zkEVM devresinin kanıt üretimi için temel birimdir.
+3. Bir dizi bitişik parça bir yığın halinde gruplandırılır. Yığın, L1'de veri taahhüdü ve kanıt doğrulama için temel birimdir. Bir yığının kanıtı veya _yığın kanıtı_, bu gruptaki yığın kanıtlarının toplu kanıtıdır.
+
+Bu çok katmanlı gruplandırma şemasının amacı, zincir üstü veri taahhüdü ve kanıt doğrulamanın gas maliyetini azaltmaktır. Bu yaklaşım, sabit devre kapasitesini dikkate alırken L1'deki rollup birimlerinin ayrıntı düzeyini artırır. Sonuç olarak, yığın sözleşmede saklanacak verileri azaltır ve kanıt doğrulama maliyetini daha fazla L2 işlemine göre amorti eder.
+
+Bir parça oluşturulduktan sonra karşılık gelen bir parça kanıtlama görevi oluşturulacak ve bir zkEVM kanıtlayıcıya gönderilecektir. Yeni bir yığın oluşturulduktan sonra birbirini takip eden iki eylem gerçekleşir: (a) rollup düğümü bu yığın işlem verilerini ve blok bilgilerini L1 sözleşmesine gönderir ve (b) yığın kanıtlarını bir araya getirmek için bir parça kanıtlama görevi bir L1 kanıtlama toplayıcısı sözleşmesine gönderilir. Bir parça ve yığın önermeye yönelik standartlar [Rollup Düğümü](/tr/technology/sequencer/rollup-node) kısmında ayrıntılı olarak açıklanmıştır.
diff --git a/src/content/docs/tr/technology/index.mdx b/src/content/docs/tr/technology/index.mdx
new file mode 100644
index 000000000..35a8a43a1
--- /dev/null
+++ b/src/content/docs/tr/technology/index.mdx
@@ -0,0 +1,24 @@
+---
+section: technology
+date: Last Modified
+title: "Scroll Mimarisi"
+lang: "tr"
+permalink: "technology"
+whatsnext:
+ { "Scroll Zinciri": "/tr/technology/chain/accounts", "Köprü": "/tr/technology/bridge/cross-domain-messaging", "Sıralayıcı": "/tr/technology/sequencer/execution-node", "zkEVM": "/tr/technology/zkevm/zkevm-overview" }
+---
+
+import ClickToZoom from "../../../../components/ClickToZoom.astro"
+import Architecture from "./_images/arch.png"
+
+
+
+Yukarıdaki şekilde gösterildiği gibi Scroll zinciri üç katmandan oluşur:
+
+- **Yerleşim Katmanı**: Kanonik Scroll zinciri için veri kullanılabilirliği ve sıralama sağlar, geçerlilik kanıtlarını doğrular ve kullanıcıların ve dapp'lerin Ethereum ile Scroll arasında mesaj ve varlık göndermesine olanak tanır. Uzlaşma Katmanı olarak Ethereum'u kullanıyoruz ve köprü ve rollup sözleşmesini Ethereum'a dağıtıyoruz.
+- **Sıralama Katmanı**: Scroll sıralayıcısına gönderilen işlemleri ve L1 köprü sözleşmesine gönderilen işlemleri yürüten ve L2 blokları üreten bir *Yürütme Düğümü*, ve işlemleri gruplandırıp veri kullanılabilirliği için işlem verileri ve blok bilgisini Ethereum'a gönderen ve kesinlik için geçerlilik kanıtlarını Ethereum'a gönderen bir *Rollup Düğümü* içerir.
+- **Kanıtlama Katmanı**: L2 işlemlerinin doğruluğunu doğrulayan zkEVM geçerlilik kanıtlarını oluşturmaktan sorumlu olan kanıtlayıcılardan oluşan bir havuzdan ve kanıtlayıcılara kanıtlayıcı görevleri gönderen ve kanıtları Rollup Düğümüne ileterek Ethereum'da finalize edecek bir koordinatörden oluşur.
+
+Belgelerin bu bölümü, Scroll protokolü spesifikasyonu, köprüleme protokolü, sıralayıcı ve zkEVM devresi hakkında kapsamlı bilgi sağlar.
+
+*Bu bölümün geri kalanında L1 Ethereum'u, L2 ise Scroll'u ifade edecektir.*
\ No newline at end of file
diff --git a/src/content/docs/tr/technology/overview/scroll-upgrades.mdx b/src/content/docs/tr/technology/overview/scroll-upgrades.mdx
new file mode 100644
index 000000000..9af00ea4e
--- /dev/null
+++ b/src/content/docs/tr/technology/overview/scroll-upgrades.mdx
@@ -0,0 +1,90 @@
+---
+section: technology
+date: Last Modified
+title: "Scroll Yükseltmeleri"
+lang: "tr"
+permalink: "technology/overview/scroll-upgrades"
+---
+
+Ekip Scroll'un yol haritası üzerinde ilerlemeye devam ettikçe, Scroll ağını yeni özellikler ve iyileştirmeler içerecek şekilde yükselteceğiz.
+
+Aşağıdaki sözleşmeler, yükseltmeleri başlatmak ve iki haftalık zaman kilitleme süresinden sonra yükseltmeleri yürütmek için kullanılır:
+
+| Kontrat | Ağ | Adres |
+| ------------------------ | ------- | - |
+| L1 Scroll Multisig | Ethereum| [`0xEfc9D1096fb65c832207E5e7F13C2D1102244dbe`](https://etherscan.io/address/0xEfc9D1096fb65c832207E5e7F13C2D1102244dbe)|
+| L1 Timelock | Ethereum| [`0x1A658B88fD0a3c82fa1a0609fCDbD32e7dd4aB9C`](https://etherscan.io/address/0x1A658B88fD0a3c82fa1a0609fCDbD32e7dd4aB9C)|
+| L2 Scroll Multisig | Scroll| [`0xEfc9D1096fb65c832207E5e7F13C2D1102244dbe`](https://scrollscan.com/address/0xEfc9D1096fb65c832207E5e7F13C2D1102244dbe)|
+| L2 Timelock | Scroll | [`0xf6069DB81239E5194bb53f83aF564d282357bc99`](https://scrollscan.com/address/0xf6069DB81239E5194bb53f83aF564d282357bc99)|
+
+## Şubat 2024 Köprü Yükseltmesi
+
+### Genel Bakış
+
+Köprüleme maliyetlerini azaltmak için köprü ve rollup sözleşme paketimizde çeşitli gas optimizasyonları uyguladık. Kullanılan optimizasyon teknikleri aşağıdakileri içerir:
+
+- Artık bazı tamamlayıcı sözleşme adreslerini depolamak için depolama değişkenleri yerine sabitleri kullanacağız. Bu değerlerin (neredeyse) asla değişmemesi gerektiğinden bu mümkündür. Bu değişiklikle birkaç depolama yükleme işleminden tasarruf edebiliriz.
+- `L1MessageQueue`daki içsel gas tahminini, kesin bir hesaplama yerine basit bir üst sınır kullanacak şekilde güncelledik. Çoğu köprü işlemi için iki sonuç benzer olacaktır ancak yeni uygulama önemli ölçüde daha ucuzdur.
+- Bir sözleşmeden diğerine çağrı maliyetlerinden tasarruf etmek için iki sözleşme `L1MessageQueue` ve `L2GasPriceOracle`yı birleştirdik.
+
+### Zaman çizelgesi
+
+
+- **Scroll Sepolia:**
+- Ağ Yükseltmesi: 19 Ocak 2024
+- **Scroll Ana Ağ:**
+- Yükseltme Başlatma: 7 Şubat 2024
+- Zaman Kilidinin Tamamlanması ve Yükseltilmesi: 21 Şubat 2024
+
+
+### Teknik detaylar
+
+#### Kod Değişiklikleri
+- [Köprü Maliyet Optimizasyonu](https://github.com/scroll-tech/scroll/pull/1011)
+- [Denetim Düzeltmeleri](https://github.com/scroll-tech/scroll/pulls?q=OZ+is%3Apr+created%3A2024-01-27..2024-02-10)
+- [Önceden dağıtılan sürüm](https://github.com/scroll-tech/scroll/tree/ff380141a8cbcc214dc65f17ffa44faf4be646b6) ('ff380141a8cbcc214dc65f17ffa44faf4be646b6' işlemini gerçekleştirin)
+- [Sürüm dağıtıldı](https://github.com/scroll-tech/scroll/tree/6030927680a92d0285c2c13e6bb27ed27d1f32d1) ('6030927680a92d0285c2c13e6bb27ed27d1f32d1' işlemini gerçekleştirin)
+
+#### Denetimler
+
+- [OpenZeppelin](https://blog.openzeppelin.com/scroll-bridge-gas-optimizations-audit)
+
+#### Değişiklik Listesi
+
+**L1 sözleşmelerindeki değişiklikler:**
+
+- `ScrollChain`de, `messageQueue` ve `verifier`ı `immutable` yaptık.
+- `L1ScrollMessenger`da, `counterpart`, `rollup`, ve `messageQueue`yu `immutable` yaptık.
+- Tüm token ağ geçitlerinde, `counterpart`, `router`, ve `messenger`ı `immutable` yaptık.
+- `L1MessageQueue` ve `L2GasPriceOracle`ı tek bir `L1MessageQueueWithGasPriceOracle` sözleşmesinde birleştirdik (önceki `L1MessageQueue` ile aynı adrese konuşlandırıldı). Bu sözleşmede ayrıca `messenger` ve `scrollChain`i `değişmez` olarak değiştiriyoruz ve `calculateIntrinsicGasFee`yi basitleştiriyoruz.
+
+**L2 sözleşmelerindeki değişiklikler:**
+
+- `L2ScrollMessenger`da `counterpart`ı `immutable` olacak şekilde değiştirdik.
+- Tüm token ağ geçitlerinde, `counterpart`, `router`, ve `messenger`ı to `immutable` olacak şekilde değiştirdik.
+
+**Etkilenen sözleşmeler:**
+
+- **L1:** `L1MessageQueue`, `L2GasPriceOracle`, `ScrollChain`, `L1WETHGateway`, `L1StandardERC20Gateway`, `L1GatewayRouter`, `L1ScrollMessenger`, `L1CustomERC20Gateway`, `L1ERC721Gateway`, `L1ERC1155Gateway`.
+- **L2:** `L2ScrollMessenger`, `L2WETHGateway`, `L2StandardERC20Gateway`, `L2GatewayRouter`, `L2CustomERC20Gateway`, `L2ERC721Gateway`, `L2ERC1155Gateway`.
+
+#### Uyumluluk
+
+##### Sıralayıcı ve takipçi düğümleri (l2geth)
+
+`l2geth` düğümü çalıştıran operatörlerin yükseltme yapmasına gerek yoktur. Bu yükseltmedeki değişiklikler `l2geth`i etkilemeyecektir.
+
+##### Dapp'ler ve indexer'lar
+
+Sözleşmeleri sorgulayan veya sözleşme arayüzlerine dayanan dapp'lerin ve indeksleyicilerin (ve benzer zincir dışı altyapının) çoğu durumda değiştirilmesine gerek yoktur. Sözleşme değişikliklerinin çoğunluğu dahili ve/veya geriye dönük olarak uyumludur.
+
+Uygulamanız, Scroll'un L1'deki L2 gas fiyatını nasıl takip ettiğini izlemek için [`L2GasPriceOracle`](https://etherscan.io/address/0x987e300fDfb06093859358522a79098848C33852)'ye bağlıysa yükseltme blok numarasından izlemeye başlamanız gerekir [`L1MessageQueueWithGasPriceOracle`](https://etherscan.io/address/0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B).
+
+Orijinal gas fiyatı oracle sözleşmesi kullanımdan kaldırılacak: artık Scroll köprüsü tarafından güncellenmeyecek veya kullanılmayacaktır.
+
+- Ethereum:
+ - `L2GasPriceOracle`: [`0x987e300fDfb06093859358522a79098848C33852`](https://etherscan.io/address/0x987e300fDfb06093859358522a79098848C33852)
+ - `L1MessageQueueWithGasPriceOracle`: [`0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B`](https://etherscan.io/address/0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B)
+- Sepolia:
+ - `L2GasPriceOracle`: [`0x247969F4fad93a33d4826046bc3eAE0D36BdE548`](https://sepolia.etherscan.io/address/0x247969F4fad93a33d4826046bc3eAE0D36BdE548)
+ - `L1MessageQueueWithGasPriceOracle`: [`0xF0B2293F5D834eAe920c6974D50957A1732de763`](https://sepolia.etherscan.io/address/0xF0B2293F5D834eAe920c6974D50957A1732de763)
\ No newline at end of file
diff --git a/src/content/docs/tr/technology/prover/proof-generation.mdx b/src/content/docs/tr/technology/prover/proof-generation.mdx
new file mode 100644
index 000000000..93857ebbd
--- /dev/null
+++ b/src/content/docs/tr/technology/prover/proof-generation.mdx
@@ -0,0 +1,7 @@
+---
+section: technology
+date: Last Modified
+title: "Kanıt Oluşturma"
+lang: "tr"
+permalink: "technology/prover/proof-generation"
+---
diff --git a/src/content/docs/tr/technology/security/audits-and-bug-bounty.mdx b/src/content/docs/tr/technology/security/audits-and-bug-bounty.mdx
new file mode 100644
index 000000000..e124b89d9
--- /dev/null
+++ b/src/content/docs/tr/technology/security/audits-and-bug-bounty.mdx
@@ -0,0 +1,71 @@
+---
+section: technology
+date: Last Modified
+title: "Denetimler ve Hata Ödül Programı"
+lang: "tr"
+permalink: "technology/security/audits-and-bug-bounty"
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+Scroll, güvenliği birinci öncelik olarak ele alır.
+
+Sıkı testlerin, dahili bir güvenlik ekibinin ve kapsamlı kod incelemelerinin yanı sıra, kod tabanımızda denetimler gerçekleştirmek için birden fazla güvenlik denetim firmasıyla da görüştük. Topluluğumuzun protokolümüzün güvenliğine katılmasını teşvik etmek için bir hata ödül programı da başlattık.
+
+
+
+## Bağımsız Denetimler
+
+Scroll, kod tabanımızı incelemek için sektör lideri birkaç güvenlik denetim firmasıyla birlikte çalıştı; [Trail of Bits](https://www.trailofbits.com/), [OpenZeppelin](https://www.openzeppelin.com/), [Zellic](https://www.zellic.io/) ve [KALOS](https://www.kalos.xyz/).
+
+- Trail of Bits, Zellic ve KALOS zkEVM devrelerimizi inceledi
+- OpenZeppelin ve Zellic köprü ve rollup sözleşmelerimizde bağımsız denetimler gerçekleştirdi
+- Trail of Bits, düğüm uygulamamızı analiz etti
+
+### zkEVM devreleri
+
+- Trail of Bits
+ - [1. Dalga](https://github.com/trailofbits/publications/blob/master/reviews/2023-04-scroll-zkEVM-wave1-securityreview.pdf)
+ - [2. Dalga](https://github.com/trailofbits/publications/blob/master/reviews/2023-08-scroll-zkEVM-wave2-securityreview.pdf)
+ - [3. Dalga](https://github.com/trailofbits/publications/blob/master/reviews/2023-09-scroll-zkEVM-wave3-securityreview.pdf)
+- Zellic ve Kalos
+ - [1. Dalga](https://github.com/Zellic/publications/blob/master/Scroll%20zkEVM%20-%20Part%201%20-%20Audit%20Report.pdf)
+ - [2. Dalga](https://github.com/Zellic/publications/blob/master/Scroll%20zkEVM%20-%20Part%202%20-%20Audit%20Report.pdf)
+
+### Düğüm uygulaması
+
+- Trail of Bits
+ - [zkTrie](https://github.com/trailofbits/publications/blob/master/reviews/2023-07-scroll-zktrie-securityreview.pdf)
+ - [L2geth](https://github.com/trailofbits/publications/blob/master/reviews/2023-08-scrollL2geth-initial-securityreview.pdf)
+ - [L2geth diff](https://github.com/trailofbits/publications/blob/master/reviews/2023-08-scrollL2geth-securityreview.pdf)
+
+### Köprü ve rollup sözleşmesi
+
+- OpenZeppelin
+ - [1. Aşama](https://blog.openzeppelin.com/scroll-layer-1-audit-1)
+ - [2. Aşama](https://blog.openzeppelin.com/scroll-phase-2-audit)
+ - [GasSwap, Multiple Verifier, Wrapped Ether ve Diff](https://blog.openzeppelin.com/scroll-gasswap-multiple-verifier-wrapped-ether-and-diff-audit)
+ - [ScrollOwner and Rate Limiter](https://blog.openzeppelin.com/scrollowner-and-rate-limiter-audit)
+ - [USDC Ağ Geçidi](https://blog.openzeppelin.com/scroll-usdc-gateway-audit)
+ - [Contract diff](https://blog.openzeppelin.com/scroll-diff-audit-report)
+- Zellic
+ - [Rapor 1](https://github.com/Zellic/publications/blob/master/Scroll%20-%2005.26.23%20Zellic%20Audit%20Report.pdf)
+ - [Rapor 2](https://github.com/Zellic/publications/blob/master/Scroll%20-%2009.27.23%20Zellic%20Audit%20Report.pdf)
+
+## Hata Ödül Programı
+
+Scroll'un, önde gelen bir hata ödül platformu olan aktif bir [Immunefi'de Hata Ödül Programı](https://immunefi.com/bounty/scroll/) vardır. Program herkese açık olup, herkesi katılmaya davet ediyoruz.
+
+Ödüller, bildirilen güvenlik açıklarının ciddiyetine bağlıdır:
+
+- **Kritik**: 1.000.000$'a kadar
+- **Yüksek**: 10.000$ - 50.000$
+- **Orta**: 5.000$
+
+### Kapsam
+
+Hata ödül programının kapsamı, blokzincir altyapısını ve köprüleme ve rolluplara yönelik akıllı sözleşmeleri kapsıyor. Hata kategorilerinin ayrıntılı bir dökümü için lütfen hata ödülü sayfasına bakın.
+
+Hata ödül programında listelenen kapsamların yanı sıra, tespit edilen tüm güvenlik açıklarının Immunefi'ye bildirilmesini de teşvik ediyoruz; bunları ödül olarak değerlendirmeye devam edeceğiz. Hata ödül programının kapsamı dışındaki kritik güvenlik açıklarının keşfi için lütfen security@scroll.io adresine de rapor gönderin.
\ No newline at end of file
diff --git a/src/content/docs/tr/technology/sequencer/execution-node.mdx b/src/content/docs/tr/technology/sequencer/execution-node.mdx
new file mode 100644
index 000000000..f536c649f
--- /dev/null
+++ b/src/content/docs/tr/technology/sequencer/execution-node.mdx
@@ -0,0 +1,82 @@
+---
+section: technology
+date: Last Modified
+title: "Yürütme Düğümü"
+lang: "tr"
+permalink: "technology/sequencer/execution-node"
+whatsnext: { "Rollup Düğümü": "/tr/technology/sequencer/rollup-node/" }
+---
+
+import Aside from "../../../../../components/Aside.astro"
+
+Yürütme düğümü, Scroll protokolündeki temel bileşenlerden biridir, L2 blokzincirinin devamlılığından sorumludur. Yürütme düğümü sayesinde Scroll'daki kullanıcı ve geliştirici deneyimi Ethereum'daki kullanıcı ve geliştirici deneyimine benzer. Bu benzerliği doğrudan Ethereum'dan miras aldığı EVM ve RPC davranışını minimal değişiklikle koruyarak başarır.
+
+Scroll'un yürütme düğümünün ana işlevleri şunlardır:
+- L1 ve L2'den işlemleri toplar.
+- İşlemleri doğrular ve bu işlemleri L2 bloklarına paketler.
+- Blokları yürütür ve L2 zinciri sürdürür.
+
+L1'den L2'ye token ve mesaj köprülemenin de yürütme düğümünün sorumluluğunda olduğunu vurgulamakta fayda var. Öte yandan L2'den L1'e gerçekleşen mesajlar L1'deki herhangi bir kullanıcı tarafından yürütülebilir.
+
+Scroll'un yürütme düğümünün ikincil işlevleri şunlardır:
+- Standart Ethereum RPC API'leri ve bazı Scroll eklenti API'leri sunar.
+- Eşlerin (takipçi düğümlerinin), Ethereum'un eşler arası protokolünü kullanarak blokzincirini senkronize etmesine olanak sağlar.
+
+[go-ethereum](https://github.com/ethereum/go-ethereum)'un bir çatallanması olan yürütme düğümü, işlevlerinin çoğunu Ethereum'dan devralır. Buna işlem ve blok veri yapıları, EVM yürütme, RPC ve p2p protokolleri dahildir. Bu veri yapıları ve protokoller doğrudan `go-ethereum`dan miras alındığı için, Scroll'un Ethereum ile uyumluluğu konusunda çok yüksek bir kesinliğe sahip olabiliriz.
+
+Aşağıdaki bölümlerde yürütme düğümünün ana bileşenleri, ek doğrulama kuralları ve değişiklik ayrıntılarının özeti tanıtılacaktır.
+
+## `l2geth` Bileşenleri
+
+[`l2geth`](https://github.com/scroll-tech/go-ethereum), Scroll'un [go-ethereum](https://github.com/ethereum/go-ethereum) çatallanmasıdır. Blokların oluşturulmasından, yürütülmesinden ve blokzincir durumunun sürdürülmesinden sorumludur. `l2geth`, aşağıda listelenen bazı önemli farklılıklarla birlikte, işlevlerinin çoğunu Ethereum'dan devralmaktadır. `l2geth` aşağıdaki alt modüllere sahiptir (kapsamlı liste değildir):
+- **Storage**: LevelDB kullanılarak uygulanan defter ve durum depolaması.
+- **EVM**: Ethereum'un durum geçiş kuralları.
+- **Worker:** Yeni L2 blokları oluşturmaktan sorumludur.
+- **L1 SyncService**: L1 mesajlarını `l2geth` yerel veritabanında senkronize eder ve saklar.
+- **API katmanı**: Standart Ethereum RPC ve p2p arayüzleri.
+- **Transaction pool**: L2 işlemleri için mempool.
+- **Circuit capacity checker**: bir işlemin veya bloğun devre kapasitesi sınırını aşıp aşmadığını kontrol eder.
+
+### Devre Kapasitesi Denetleyicisi
+
+Scroll'un mevcut zkEVM devreleri ile zkEVM devresine uymadığı için kanıtlanamayan işlem ve bloklar oluşturmak mümkün. Biz buna *kanıt taşması* diyoruz. Bunu önlemek için l2geth'in parçası olarak bir *devre kapasitesi denetleyicisi* modülü uyguladık. Devre kapasitesi denetleyicisi hem blok oluşturma hem de blok doğrulama sırasında kullanılır.
+
+Blok oluşturma sırasında eğer bir sonraki işlem kanıt taşmasına neden olacaksa bloğu mühürleyip işlemi bir sonraki bloğa bırakıyoruz. Tek bir işlem kanıt taşmasına yol açarsa l2geth bunu iptal eder. Bu mekanizmaya *atlama* diyoruz.
+
+L2 işlemlerini atlamak, onları basitçe atmak anlamına gelir. Bu durumda, kullanıcının devam edebilmesi için kanıt taşmasına yol açmayacak aynı nonce ile başka bir işlem göndermesi gerekir.
+
+L1 mesajlarını atlamak daha açık bir süreçtir. Hem L1'deki `ScrollChain` sözleşmesi hem de zkEVM, `L1MessageQueue`daki her L1 işleminin ya dahil edildiğini ve yürütüldüğünü ya da atlandığını doğrular. Toplu kodlama L1 işlemlerini içermese de, hangi L1 mesajlarının atlandığını `ScrollChain`e gösteren bir *atlama bit eşlemi* içerir. Bir L1 depozito mesajı atlanırsa, kullanıcı L1'de tokenlarının iadesini alabilir.
+
+
+
+zkEVM kanıtlama birimi yığın olduğundan, yığınlar için de kanıt taşmasından kaçınılmalıdır.
+Bu, asla kanıtlanamaz parçalar önermediğinden emin olmak için devre kapasitesi denetleyicisinin rollup rölesine dahil edilmesiyle elde edilir.
+
+## Doğrulama Kuralları
+
+Scroll, Ethereum'un blok doğrulama kurallarına ek olarak birkaç doğrulama kuralı ekler. Bu yeni kurallar, L1 mesajının dahil edilmesinin L2 davranışını ve zkEVM devre kapasitesi limitini kısıtlar.
+
+- Yukarıda özetlenen [devre kapasitesi denetleyicisi](/es/technology/sequencer/execution-node/#devre-kapasitesi-denetleyicisi) modülü
+ bloğun zkEVM devresinin devre alanı kapasitesine sığabileceğini doğrular.
+- L1 mesajlarıyla ilgili kurallar:
+ - Bir bloktaki L1 mesajları bitişik ve bloğun önünde olmalıdır.
+ - Bir bloktaki L1 mesajları `L1MessageQueue`daki sırasına göre dahil edilmelidir, yani artan `QueueIndex` ile dahil edilmelidir.
+ - Bir bloktaki L1 mesajları `L1MessageQueue` sözleşmesindekilerle eşleşmelidir.
+- Bu kuralların çoğu hem blok oluşturma hem de blok doğrulama sırasında dikkate alınır. Sonuç olarak, eğer blok öneren düğüm bu kurallardan herhangi birini ihlal ederse, takipçi düğümler bloklarını reddedecektir.
+
+## Değişikliklerin Özeti
+
+Scroll yürütme düğümü, Ethereum'un davranışlarının çoğunu devralır. Ancak daha verimli kanıtlamayı mümkün kılmak için `l2geth`te bazı önemli değişiklikler yapmamız gerekiyordu. Bu bölümde, gerekçeleriyle birlikte değişikliklerin kapsamlı olmayan bir listesi sunulmaktadır.
+
+- **State and storage tree**: Ethereum, durum ve sözleşme depolama veri yapısı olarak MPT'yi (Merkle-Partricia Trie) kullanır. Bu trie'nin yapısı ve Keccak hash değerini kullanması, onu ZK devreleri için aşırı derecede pahalı hale getirecektir. `l2geth` bunun yerine [zkTrie](/tr/technology/sequencer/zktrie) kullanır: durumu ve sözleşme depolaması için Poseidon hash değerine sahip ikili bir Merkle trie'si.
+- **StateAccount**: Durum hesabının değiştirilmesi [Hesaplar ve Durum] bölümünde açıklanmıştır(/tr/technology/chain/accounts).
+- **EVM**: Değişiklikler [Ethereum'dan EVM Farkları] bölümünde açıklanmıştır(/tr/technology/chain/differences).
+- **İşlem ücretleri**
+ - L2'de toplanan tüm ücretler, Scroll tarafından korunan bir L2 ücret kasası sözleşmesine gönderilir.
+ - L1 ücreti: L2 blok alanı ve uygulama masraflarını kapsayan L2 gaz ücretine ek olarak, işlemin L1'e gerçekleştirilme masraflarını kapsayan bir L1 ücreti de alıyoruz. Bu ücret, RLP kodlu işlemin boyutuyla orantılıdır. Gerçek maliyet, L2'deki `L1GasOracle` sözleşmesinde saklanan mevcut ayarlara bağlıdır. Bu ücret doğrudan gönderenin bakiyesinden kesilir (gaz ödeneğinden değil).
+- **L1MessageTx**: Yeni bir işlem türü olan 'L1MessageTx'i tanıttık. Ayrıca bu tür işlemleri ve ilgili meta verileri depolamak için veritabanı arayüzleri de ekledik.
+- **SyncService**: L1'deki sonlandırılmış blokları izler ve bunlardan L1 mesajlarını toplar.
+- **New API**: `l2geth`, kanıtlayıcıların kanıt oluşturmak amacıyla izleme bilgilerini sorgulaması için bir izleme API'si olan `scroll_traceBlockByNumberOrHash` sunar.
diff --git a/src/content/docs/tr/technology/sequencer/rollup-node.mdx b/src/content/docs/tr/technology/sequencer/rollup-node.mdx
new file mode 100644
index 000000000..2cd4abdd2
--- /dev/null
+++ b/src/content/docs/tr/technology/sequencer/rollup-node.mdx
@@ -0,0 +1,33 @@
+---
+section: technology
+date: Last Modified
+title: "Rollup Düğümü"
+lang: "tr"
+permalink: "technology/sequencer/rollup-node"
+whatsnext: { "zkTrie": "/tr/technology/sequencer/zktrie/" }
+---
+
+Rollup düğümü, Scroll blokzincirini L1'de kanıtlama ve taahhüt için uygun bölümlere bölmekten sorumludur. Bunun iki ana birimi *parçalar* ve *yığınlar*dır.
+* Bir parça, L2 defterinin bitişik bir bölümüdür, L2 bloklarının bir koleksiyonudur ve parçalar, zkEVM kanıtlama birimidir.
+* Öte yandan bir yığın, toplu bir kanıtla birlikte L1'e gönderilen parçaların bir koleksiyonudur.
+
+Rollup düğümü aşağıdaki alt modüllere sahiptir:
+- Parça Önerici: L2 bloklarını toplar ve belirli sınırları zorlayarak parçaları önerir (aşağıya bakın).
+- Yığın Önerici: belirli sınırları uygulayarak parçaları toplayın ve yığınları önerir (aşağıya bakın).
+- Aktarıcı: Yığın verilerini ve yığın kanıtlarını L1'e gönderir.
+
+## Parça ve yığın kısıtlamaları
+
+Yürütme düğümüyle karşılaştırıldığında rollup düğümü çok daha basit ve basit bir bileşendir.
+L2 bloklarını toplar, parçalar ve yığınlar oluşturur ve bunları L1'e gönderir.
+Bu bölümde, parça ve yığın oluşturma sırasında rollup düğümünün uygulaması gereken ana sınırları özetlemekteyiz.
+
+Parçalardaki kısıtlamalar:
+- **Kanıt taşması:** Devre kapasitesi denetleyicisini kullanarak, bir parçaya, yine de kanıt taşmasına yol açmayacak kadar çok bloğun dahil edildiğinden emin oluruz.
+- **L1 yükü:** Yığın önericiden devralınan kısıtlamalar; işlem yükü 128 KB'yi aşamaz.
+
+Yığınlardaki kısıtlamalar:
+- **L1 yükü:** Ethereum'un işlem yükü boyutunda sabit kodlanmış 128 KB sınırı vardır.
+- **L1 işleme gas maliyeti:** Bir yığını işlemenin gas maliyeti, içindeki blokların ve işlemlerin sayısıyla orantılıdır. Bu maliyetin L1 blok gas limitini aşmadığından emin olmalıyız.
+- **Parça sayısı:** Bir yığın, rollup kanıtlayıcısı için en uygun sayıda parçayı içerir.
+
diff --git a/src/content/docs/tr/technology/sequencer/zktrie.mdx b/src/content/docs/tr/technology/sequencer/zktrie.mdx
new file mode 100644
index 000000000..eab1a688b
--- /dev/null
+++ b/src/content/docs/tr/technology/sequencer/zktrie.mdx
@@ -0,0 +1,204 @@
+---
+section: technology
+date: Last Modified
+title: "zkTrie"
+lang: "tr"
+permalink: "technology/sequencer/zktrie"
+whatsnext: { "zkEVM": "/tr/technology/zkevm/intro-to-zkevm/" }
+excerpt: "zkTrie, Poseidon hashi kullanılarak oluşturulmuş seyrek bir ikili (binary) Merkle Patricia Trie'dir."
+---
+
+import Aside from "../../../../../components/Aside.astro"
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import zktrie1 from "../_images/zktrie-arch.png"
+import zktrie2 from "../_images/zktrie-insertion.png"
+import zktrie3 from "../_images/zktrie-deletion.png"
+
+Bu belgede, anahtar/değer çiftlerini verimli bir şekilde depolamak için kullanılan seyrek bir ikili Merkle Patricia Trie olan zkTrie açıklanmaktadır. Ekleme ve silme de dahil olmak üzere ağaç yapısını, yapımını, düğüm hash işlemini ve ağaç işlemlerini açıklar.
+
+Ayrıca [zktrie repomuzu](https://github.com/scroll-tech/zktrie) de inceleyebilirsiniz.
+
+## Ağaç Yapısı
+
+zkTrie, aşağıdaki şekilde gösterildiği şekilde seyrek bir ikili Merkle Patricia Trie'dir.
+Seyrek İkili Merkle Patricia Trie konusuna dalmadan önce Merkle Trees ve Patricia Tries'e kısaca değinelim.
+* **Merkle Tree**: Merkle Tree, her yaprak düğümünün bir veri bloğunun hash değerini temsil ettiği ve yaprak olmayan her düğümün, alt düğümlerinin hash değerini temsil ettiği bir ağaçtır.
+* **Patricia Trie**: Patricia Trie, anahtar/değer çiftlerini verimli bir şekilde depolamak için kullanılan bir tür taban ağacı veya sıkıştırılmış trie'dir. Yolun düğüm anahtarının değeri tarafından belirlendiği ortak yolu paylaşmak için düğümleri aynı anahtar önekiyle kodlar.
+
+Şekil 1'de gösterildiği gibi zkTrie'de üç tip düğüm vardır.
+- Dal Düğümü: zkTrie'nin ikili bir ağaç olduğu göz önüne alındığında, bir dal düğümünün iki alt düğümü vardır.
+- Yaprak Düğümü: Bir yaprak düğümü, bir anahtar/değer çiftinin verilerini tutar.
+- Boş Düğüm: Boş bir düğüm, aynı öneki paylaşan alt grubun boş olduğunu belirten özel bir düğüm türüdür.
+
+zkTrie'de, düğüm hash değerini hesaplamak için Poseidon hash değerini kullanırız çünkü bunu zk devresinde kanıtlamak daha kolay ve verimlidir.
+
+
+
+## Ağaç Yapımı
+
+Bir anahtar/değer çifti verildiğinde, ilk önce Poseidon hash işlevini kullanarak orijinal anahtarı (yani hesap adresi ve depolama anahtarının) hashleyerek ilgili yaprak düğüm için bir *güvenli anahtar* hesaplarız. Bu, anahtarın anahtar alanı üzerinde tekdüze (uniform) dağıtılmasını sağlar. Düğüm anahtarı hash yöntemi, aşağıdaki [Node Hashing](#node-hashing) bölümünde açıklanmaktadır.
+
+Yeni bir yaprak düğümün yolunu, güvenli anahtarı En Az Önemli Bit'ten (LSB) En Önemli Bit'e (MSB) geçerek kodluyoruz. Her adımda, eğer bit 0 ise sol alt düğüme; aksi halde sağ alt düğüme geçiyoruz.
+
+ZkTrie'nin maksimum derinliğini 248 ile sınırlandırıyoruz; bu, ağacın anahtarın yalnızca alt 248 bitini geçeceği anlamına gelir. Güvenli anahtar alanı, Poseidon hashi tarafından kullanılan ve $2^{256}$ aralığının tamamını kaplamayan sonlu bir alan olduğundan, anahtarın bit temsili sonlu alanda belirsiz olabilir ve bu nedenle, zk devresinde bir sağlamlık sorunuyla sonuçlanır.
+
+Yalnızca bir yaprak düğümü olan bir alt ağacı tek bir yaprak düğümüne daraltarak ağaç derinliğini azaltacak bir optimizasyon uyguluyoruz. Örneğin, Şekil 1'de ağacın toplamda '0100', '0010' ve '1010' tuşlarına sahip üç düğümü vardır. '00' son ekine sahip yalnızca bir düğüm olduğundan, '0100' anahtarının yaprak düğümü yalnızca '00' son ekini geçer ve 4 derinliğine neden olacak anahtarını tam olarak genişletmez.
+
+## Ağaç İşlemleri
+
+### Ekleme
+
+
+
+Bir zkTrie'ye yeni bir yaprak düğüm eklediğimizde, Şekil 2'de gösterilen iki durum vardır.
+
+1. Düğüm anahtarının yolunu izlerken boş bir düğüme ulaşılıyor (Şekil 2a). Bu durumda, bu boş düğümü bu yaprak düğümle değiştirmemiz ve dal düğümlerinin merkle hashini köke kadar güncellemek için yolu geriye doğru izlememiz gerekiyor.
+2. Düğüm anahtarının yolunu kat ederken başka bir yaprak düğüm olan 'b'ye ulaşır (Şekil 2b). Bu durumda, iki yaprak düğümün düğüm anahtarlarındaki bir sonraki bit farklılaşana kadar mevcut yaprak düğümü 'b'yi aşağı itmemiz gerekir. Her aşağı itme adımında, dal düğümüne boş bir kardeş düğüm eklememiz gerekir. Bitlerin farklı olduğu seviyeye ulaştığımızda, bitlerine bağlı olarak sol alt düğüm ve sağ alt düğüm olarak iki yaprak düğümü 'b' ve 'd' yerleştiririz. Sonunda yolu geriye doğru izleriz ve tüm dal düğümlerinin Merkle hashini güncelleriz.
+
+### Silme
+
+
+
+Bir yaprak düğümün silinmesi ekleme işlemine benzer. Şekil 3'te gösterilen iki durum vardır.
+
+1. Silinecek yaprak düğümün kardeş düğümü,
+dal düğümü (Şekil 3a). Bu durumda, 'a' düğümünü boş bir düğümle değiştirebilir ve atalarının düğüm hash değerini kök düğüme kadar güncelleyebiliriz.
+2. Silinecek yaprak düğümün kardeş düğümü bir yaprak düğümdür (Şekil 3b). Durum 1'e benzer şekilde, önce yaprak düğümü boş bir düğümle değiştiririz ve kardeş düğümü boş bir düğüm olmayana kadar kardeş düğümünü yukarı doğru daraltmaya başlarız. Örneğin, Şekil 3b'de 'b' yaprak düğümünü boş bir düğümle değiştiriyoruz. 'c' düğümünün kardeşi artık boş bir düğüm haline geldiğinden, 'c' düğümünü bir seviye yukarı taşımamız ve ebeveynini değiştirmemiz gerekiyor. 'C' düğümünün yeni kardeşi 'e' düğümü hâlâ boş bir düğümdür. Böylece yine 'c' düğümünü yukarı doğru hareket ettiriyoruz. Artık 'c' düğümünün kardeşi bir yaprak düğüm olan 'a' düğümü olduğuna göre, silme işlemi tamamlanmıştır.
+
+Geçerli bir zkTrie'deki yaprak düğümün kardeşinin boş bir düğüm olamayacağını unutmayın. Aksi halde her zaman alt ağacı budamalı ve yaprak düğümünü yukarı doğru hareket ettirmeliyiz.
+
+## Düğüm Hash İşlemi
+
+Bu bölümde yaprak güvenlik anahtarının ve düğüm Merkle hash'inin nasıl hesaplandığını anlatacağız. Her iki hash hesaplaması için arity 2 ile Poseidon hash değerini kullanıyoruz. Scroll'da, Poseidon hash işlevi her seferinde iki alan öğesi girişi ve etki alanı ayırma için başlangıç bağlamı olarak aşağıda belirtilen bir `domain_value` alacak şekilde yapılandırılmıştır.
+```
+h{domain_value}(input1, input2)
+```
+
+### Boş Düğüm
+
+Boş bir düğümün düğüm hashi 0'dır.
+
+### Dal Düğümü
+
+Dal düğümü hashi aşağıdaki şekilde hesaplanır:
+
+```go
+branchNodeHash = h{BranchNodeType}(leftChildHash, rightChildHash)
+```
+
+### Yaprak düğümü
+
+Bir yaprak düğümün düğüm hashi aşağıdaki şekilde hesaplanır:
+
+```go
+leafNodeHash = h{LeafNodeType}(nodeKey, valueHash)
+```
+
+Hesaplama, `nodeKey` ve `valueHash` olmak üzere iki alanı içerir.
+- `nodeKey` orijinal anahtardan hashe dönüştürülür. Poseidon hashinde kullanılan alan adı değeri 256'dır.
+- `valueHash`, yaprak düğüm değerinin hashlenmesiyle hesaplanır. Poseidon hashinde kullanılan etki alanı değeri '256 * n'dir; burada 'n', yaprak düğüm değerindeki öğelerin sayısıdır.
+
+İki tür yaprak düğüm vardır: Ethereum hesapları ve depolama anahtar/değer çiftleri. Daha sonra, her bir yaprak düğüm türü için sırasıyla düğüm anahtarının ve değer hashinin hesaplama yöntemini açıklayacağız.
+
+#### Ethereum Hesabı Yaprak Düğümü
+Bir Ethereum Hesabı Yaprak Düğümü, bir Ethereum adresinden ve bir durum hesabı veri yapısından oluşur. Güvenli anahtar Ethereum adresinden türetilir.
+```go
+var address byte[20] // 20 bytes in big-endian
+valHi := address[0:16]
+valLo := address[16:20] * 2^96 // padding 12 bytes of 0 at the end
+nodeKey := h{256}(valHi, valLo)
+```
+
+Scroll'daki bir durum hesabı yapısı aşağıdaki alanlardan oluşur ('Fr' sonlu alanı belirtir ve 254 bitlik bir değerdir)
+
+- `Nonce`: u64
+- `Balance`: u256, ancak Fr olarak kabul edilir
+- `StorageRoot`: Fr
+- `KeccakCodeHash`: u256
+- `PoseidonCodeHash`: Fr
+- `CodeSize`: u64
+
+Değer hashini hesaplamadan önce, durum hesabı ilk olarak `u256` değerlerinin yer aldığı bir listeye sıralanır. Sıralama şeması
+
+```text
+(The following scheme assumes the big-endian encoding)
+[0:32]
+ [0:16] Reserved with all 0
+ [16:24] CodeSize, uint64 in big-endian
+ [24:32] Nonce, uint64 in big-endian
+[32:64] Balance
+[64:96] StorageRoot
+[96:128] KeccakCodeHash
+[128:160] PoseidonCodehash
+(total 160 bytes)
+```
+
+Marshal işlevi aynı zamanda `u256` değerlerinden oluşan bir vektörle birlikte bir `flag` değeri de döndürür. `Flag`, bir `u256` değerinin alan öğesi (Fr) olarak değerlendirilip değerlendirilemeyeceğini belirten bir bit eşlemdir. Durum hesabı için `flag` değeri aşağıda gösterildiği gibi 8'dir.
+
+```
+ +--------------------+---------+------+----------+----------+
+ index | 0 | 1 | 2 | 3 | 4 |
+ +--------------------+---------+------+----------+----------+
+ u256 | nonce||codesize||0 | balance | root | keccak | poseidon |
+ +--------------------+---------+------+----------+----------+
+flag bit | 0 | 0 | 0 | 1 | 0 |
+ +--------------------+---------+------+----------+----------+
+ (LSB) (MSB)
+```
+
+Değer hashi iki adımda hesaplanır:
+1. Poseidon hashinin alan öğesi olarak temsil edilemeyen değerini alan öğesine dönüştürün.
+2. Ağaç kökü değer hashi olarak ele alınana kadar alan öğelerini ikili ağaç yapısında birleştirin.
+
+İlk adımda, `flag`daki bit, alan elemanı olarak değerlendirilemeyen `u256` değerini belirten 1 olduğunda, değeri yüksek 128 bitlik değere ve düşük-128 bitlik değere bölüyoruz ve ardından bunları bir alan öğesi değeri üretmek için Poseidon hashine dönüştürüyoruz.
+
+```go
+// convert Keccak codehash to a field element
+compressedKeccakCodeHash := h{512}(keccakCodeHash[0:16], keccakCodeHash[16:32])
+```
+
+İkinci olarak değer hashi şu şekilde hesaplanır.
+
+```go
+domain := 256 * 5 // 5 elements to compute the valueHash
+valueHash :=
+ h{domain}(
+ h{domain}(
+ h{domain}(nonce||codesize||0, balance),
+ h{domain}(
+ storageRoot,
+ compressedKeccakCodeHash,
+ ),
+ ),
+ poseidonCodeHash,
+ )
+```
+
+#### Depolama Yaprak Düğümü
+
+Depolama Yaprağı Düğümü, hem anahtar hem de değerin `u256` değerleri olduğu bir anahtar/değer çiftini kodlar. Bu yaprak düğümün güvenli anahtarı, depolama anahtarından türetilir.
+
+```go
+var storageKey byte[32] // 32 bytes in big-endian
+valHi := storageKey[0:16]
+valLo := storageKey[16:32]
+nodeKey := h{256}(valHi, valLo)
+```
+
+Depolama değeri bir `u256` değeridir. Depolama değeri için `flag` aşağıda gösterilen 1'dir.
+
+```
+ +--------------+
+ index | 0 |
+ +--------------+
+ u256 | storageValue |
+ +--------------+
+flag bit | 1 |
+ +--------------+
+```
+
+Değer hashi aşağıdaki şekilde hesaplanır
+
+```go
+valueHash = h{512}(storageValue[0:16], storageValue[16:32])
+```
diff --git a/src/content/docs/tr/technology/zkevm/intro-to-zkevm.md b/src/content/docs/tr/technology/zkevm/intro-to-zkevm.md
new file mode 100644
index 000000000..8de318f51
--- /dev/null
+++ b/src/content/docs/tr/technology/zkevm/intro-to-zkevm.md
@@ -0,0 +1,30 @@
+---
+section: technology
+date: Last Modified
+title: "zkEVM'e Giriş"
+lang: "tr"
+permalink: "technology/intro-to-zkevm"
+excerpt: "ZK rolluplar, Ethereum için ideal ölçeklendirme çözümü olarak geniş çapta kabul edilmektedir."
+whatsnext: { "zkEVM Overview": "/tr/technology/zkevm/zkevm-overview" }
+---
+
+## Giriş ve motivasyon
+
+ZK rolluplar, Ethereum için ideal ölçeklendirme çözümü olarak geniş çapta kabul edilmektedir. Ethereum'un güçlü güvenliğini miras alırlar ve diğer L2 çözümleriyle karşılaştırıldığında en hızlı işlem kesinliğini sunarlar.
+
+ZK rollupların temel fikri, işlemleri zincir dışında yürütmek ve yürütmenin geçerliliğine dair kısa ve öz kanıtlar oluşturmaktır. Bu kısa ve öz kanıtlar daha sonra Ethereum'a gönderilebilir ve doğrulanabilir. ZK rolluplar, bir grup işlem için kanıtın doğrulanması, işlem kümesinin yeniden yürütülmesinden çok daha ucuz olduğundan ölçeklenebilirliği artırır.
+
+ZK rolluplar, destekledikleri işlem türlerine göre uygulamaya özel ve genel amaçlı rolluplar olarak kategorize edilebilir. Uygulamaya özel ZK rolluplar, ödemeler ve takaslar gibi belirli işlem kümeleri veya bir oyuncunun zincir üstü bir oyun için eylem kümesi için tasarlanmıştır. Bu durumlarda, rolluplar yalnızca oyun oyuncuları için geçerli durum geçişleri gibi desteklenen temel öğelerin doğruluğunu kanıtlayan kanıtlar üretmesi gerekir.
+
+Öte yandan, genel amaçlı ZK rolluplar daha geniş bir işlem ve hesaplama yelpazesini destekler. Bu rolluplar, derleme kodunu yürütmek için bir sanal makine (VM) kullanır ve ardından yürütmenin VM'nin özelliklerine göre doğru şekilde yapıldığını gösteren bir kanıt oluşturur. Bir ZK rollup'ın hesaplama için kullandığı belirli VM, birçok ZK rollup projesi arasında farklılık gösterir. Bazı projeler, hızlı kanıt oluşturma için optimize edilmiş kendi VM'lerini oluşturmayı tercih ediyor. Diğer projeler, Ethereum ekosistemiyle optimum uyumluluk için EVM'yi kullanmayı seçiyor.
+
+Scroll, zincir dışı hesaplamalar için EVM'yi kullanan genel amaçlı bir ZK rollup'tır. Scroll'un yürütme katmanı Ethereum'unkine benzer şekilde çalışır; işlemler bloklar halinde gruplanır ve ardından bloklar [EVM](https://ethereum.org/en/developers/docs/evm/) spesifikasyonlarına göre yürütülür (aslında [Geth'in](https://geth.ethereum.org/) biraz [değiştirilmiş versiyonu](https://github.com/scroll-tech/go-ethereum)). Bu, kullanıcıların Scroll ile Ethereum ile etkileşimde oldukları şekilde etkileşime girebilecekleri anlamına gelir. Bu aynı zamanda geliştiricilerin Ethereum'un üzerinde geliştirdikleri gibi Scroll'un üzerinde de geliştirebilecekleri anlamına geliyor.
+
+Bununla birlikte, bir ZK rollup ile Ethereum uyumluluğunun sağlanması büyük bir zorluk teşkil ediyor; rollup'ın, zincir dışı bir EVM hesaplamasının doğru şekilde yürütüldüğünü kanıtlayan bir kanıt oluşturabilmesi gerekiyor. Temel olarak “zkEVM” budur: **zkEVM, EVM'nin doğru şekilde yürütüldüğünü kanıtlayan bir sistemdir**.
+
+EVM, başlangıçta ZK rollupları düşünülmeden tasarlandı ve bir zkEVM oluşturmanın oldukça zorlu olduğu ortaya çıktı. Ancak biz Scroll olarak bu zorluklardan yılmadık ve zkEVM'yi gerçeğe dönüştürmek için [Ethereum Privacy and Scaling Explorations](https://appliedzkp.org/) ekibiyle işbirliği içinde yoğun bir şekilde çalışıyoruz.
+
+## Daha fazla bilgi edin
+
+- [Blog yazısı](https://scroll.io/blog/zkEVM) zkEVM'yi tanıtıyor
+- [zkEVM'ye genel bakış](https://youtu.be/NHwd-gJ8xg4) - Haichen Shen
diff --git a/src/content/docs/tr/technology/zkevm/zkevm-overview.mdx b/src/content/docs/tr/technology/zkevm/zkevm-overview.mdx
new file mode 100644
index 000000000..655e105ff
--- /dev/null
+++ b/src/content/docs/tr/technology/zkevm/zkevm-overview.mdx
@@ -0,0 +1,56 @@
+---
+section: technology
+date: Last Modified
+title: "zkEVM Genel Bakış"
+lang: "tr"
+permalink: "technology/zkevm-overview"
+excerpt: "EVM'nin çalışmasını kanıtlayan zkEVM'nin nasıl oluşturulacağını anlamak için öncelikle EVM'nin kendisine bakmamız gerekiyor."
+---
+
+import ClickToZoom from "../../../../../components/ClickToZoom.astro"
+import zkevm1 from "../_images/zkevm1.png"
+import zkevm2 from "../_images/zkevm2.png"
+import zkevm3 from "../_images/zkevm3.png"
+
+## EVM
+
+EVM'nin çalışmasını kanıtlayan zkEVM'nin nasıl oluşturulacağını anlamak için öncelikle EVM'nin kendisine bakmamız gerekiyor.
+
+EVM, durum geçiş fonksiyonu olarak modellenebilir. Başlangıç dünya durumu `S` ve bir `T` işlemi verildiğinde, yeni bir dünya durumu `S’`: `f(S,T) = S'` üreten bir geçiş fonksiyonu `f`yi belirtir.
+
+"Dünya durumu", [değiştirilmiş Merkle-Patricia Trie](https://ethereum.org/en/developers/docs/data-structures-and-encoding/patricia-merkle-trie/) (MPT) olarak modellenmiştir. Bu trie ağın tüm kalıcı verilerini içerir. Bu, tüm harici sahipli hesapların (EOA'lar) ve akıllı sözleşme hesaplarının bilgilerini içerir. Akıllı sözleşme hesapları, akıllı sözleşmenin bytecode'unu ve kalıcı depolamayı tutan alt trie'lere sahiptir.
+
+EVM, ortaya çıkan hesaplamaları yürüterek ve buna göre dünya durumunda değişiklikler yaparak yeni bir işlemi işler. EVM hesaplaması, geçici veri depolarının (stack and memory) yanı sıra kalıcı veri depoları (contract bytecode ve storage) üzerinde de çalışır.
+
+
+
+Bireysel bir işlem tarafından tetiklenen hesaplama, EVM'nin doğrudan anlayıp yürütebileceği "opcodes" adı verilen küçük makine talimatlarına bölünür. Her bir opcode'un davranışı [Ethereum Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)'da belirtilmiştir. Bu nedenle bir işlemin yürütülmesi, yalnızca opcode yürütmelerinin sıralı bir listesi olan bir "yürütme izi" ile özetlenebilir. [Geth](https://geth.ethereum.org/) gibi Ethereum yürütme istemcileri, gerçekleştirdiği hesaplama için açıkça adım adım yürütme takibi çıktısı alabilir.
+
+
+
+Opcode'lar yürütüldükçe durum trie'si değiştirilir. Bu, yeni bir durum köküne sahip yeni bir durum trie'si sonuçlanır.
+
+## Bir EVM yürütmesinin kanıtlanması
+
+zkEVM'nin amacı, bir işlemin yürütülmesinin geçerliliğini doğrulayan bir kanıt oluşturmaktır. Başka bir deyişle, başlangıç dünya durumu `S`, bir işlem `T` ve sonuçta ortaya çıkan dünya durumu `S` verildiğinde, zkEVM'nin `f(S,T) = S` olduğuna dair bir kanıt üretmesi gerekir; burada `f`, Ethereum Yellow Paper'da belirtilen durum geçiş fonksiyonudur.
+
+Geçiş fonksiyonu yürütmesinin geçerliliğini kanıtlamak için yürütmeyi adım adım yürütme izine böleriz. `f(S,T)`nin yürütülmesi, sıralı opcode yürütmelerinin bir listesine genişletilir. Yürütme izi, `f(S,T) = S` durum geçişinin doğruluğunu onaylayan bir "tanık" görevi görür - iz, bir anlamda, durumun `S`den `S'`e nasıl geçiş yaptığını adım adım açıklayan bir açıklamadır.
+
+Daha sonra sorun aşağıdakileri kanıtlamaya indirgenir:
+
+- Yürütme izlemesi _doğru_.
+ - Her bir opcode, Ethereum Yellow Paper spesifikasyonuna göre doğru şekilde yürütülür.
+ - Örneğin, `ADD` opcode'u, yığından iki değerin çıkarılması ve bunların toplamının yığına aktarılmasıyla sonuçlanmalıdır.
+ - Bir kanıt, geçici veri depolarında (stack and memory) veya kalıcı veri depolarında yapılan değişiklikler de dahil olmak üzere her bir opcode'unun uygun davranışla yürütüldüğünü göstermelidir.
+ - Yürütülen opcodelarının sıralı listesi aslında işlem tarafından tetiklenen opcodelarının doğru listesidir.
+ - Bu, ilk işlem çağrı verilerinin ve çağrılan sözleşmelerin bytecode'unun doğru şekilde yüklenmesini içerir.
+- Yürütme izlemesi başlangıç durumu `S` ile başlar ve `S` durumuyla sonuçlanır.
+
+
+
+Sonraki bölümlerde EVM yürütme izlerinin doğruluğunun nasıl kanıtlanabileceğinin ayrıntılarına gireceğiz.
+
+## Daha fazla bilgi edin
+
+- EVM'de Cypherpunk'lar [GitBook bölümü](https://cypherpunks-core.github.io/ethereumbook/13evm.html)
+- [zkEVM'ye genel bakış](https://youtu.be/NHwd-gJ8xg4) - Haichen Shen
diff --git a/src/content/docs/tr/user-guide/_images/bridge1.png b/src/content/docs/tr/user-guide/_images/bridge1.png
new file mode 100644
index 000000000..dd552310e
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge1.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge2.png b/src/content/docs/tr/user-guide/_images/bridge2.png
new file mode 100644
index 000000000..e3fe4701f
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge2.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge3.png b/src/content/docs/tr/user-guide/_images/bridge3.png
new file mode 100644
index 000000000..03772fee9
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge3.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge4.png b/src/content/docs/tr/user-guide/_images/bridge4.png
new file mode 100644
index 000000000..a060b2ce3
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge4.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge5.png b/src/content/docs/tr/user-guide/_images/bridge5.png
new file mode 100644
index 000000000..7e75aeb4d
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge5.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge6.png b/src/content/docs/tr/user-guide/_images/bridge6.png
new file mode 100644
index 000000000..80066a330
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge6.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge7.png b/src/content/docs/tr/user-guide/_images/bridge7.png
new file mode 100644
index 000000000..66ee3ff94
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge7.png differ
diff --git a/src/content/docs/tr/user-guide/_images/bridge8.png b/src/content/docs/tr/user-guide/_images/bridge8.png
new file mode 100644
index 000000000..4b78a8b9e
Binary files /dev/null and b/src/content/docs/tr/user-guide/_images/bridge8.png differ
diff --git a/src/content/docs/tr/user-guide/bridge.mdx b/src/content/docs/tr/user-guide/bridge.mdx
new file mode 100644
index 000000000..dafaeef7c
--- /dev/null
+++ b/src/content/docs/tr/user-guide/bridge.mdx
@@ -0,0 +1,124 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Köprü"
+lang: "tr"
+permalink: "user-guide/bridge/"
+excerpt: "Sepolia'dan varlıkları köprülemeye başlamak için Portal Bridge uygulamasına gidin."
+---
+
+{/* // import ClickToZoom from "../../../../components/ClickToZoom.astro" */}
+{/* // import bridge1 from "./\_images/bridge1.png" */}
+{/* // import bridge2 from "./\_images/bridge2.png" */}
+{/* // import bridge3 from "./\_images/bridge3.png" */}
+{/* // import bridge4 from "./\_images/bridge4.png" */}
+{/* // import bridge5 from "./\_images/bridge5.png" */}
+{/* // import bridge6 from "./\_images/bridge6.png" */}
+{/* // import bridge7 from "./\_images/bridge7.png" */}
+{/* // import bridge8 from "./\_images/bridge8.png" */}
+
+{/* TODO: Update all instructions after being able to walk through the whole flow. */}
+
+Başlamak için [Köprü](https://sepolia.scroll.io/bridge) uygulamamızı ziyaret edin![^thanks-hop] Köprü, varlık **Yatırma** ve **Çekme** işlemlerini destekler ve kullanıcılara Sepolia Test Ağı'ndan Scroll Sepolia Test Ağı'na varlıkları güvenle taşıma imkanı sunar.
+[^thanks-hop]: [Hop Exchange](https://hop.exchange/)’in kullanıcı arayüzünden forklanmıştır 🙌
+
+Yatırılan varlıkların Scroll üzerinde kullanılabilir hale gelmesi 15 dakikaya kadar sürebilir.
+
+Varlık çekme işlemleri, çekim işlemi tamamlandıktan sonra Sepolia'da ikinci bir ek etkileşim gerektirmesinden dolayı çok daha uzun sürebilir.
+
+:::caution[Köprü işlemi için uzun süredir bekliyor musunuz?]
+Yukarıdaki zaman tahminleri, normal ağ davranışı ve etkinlik seviyeleri içindir. Bir L2 bloğunda, yalnızca belirli sayıda sıralanmış L1 işlemini işlediğimizden, köprülenmiş mesajların Scroll’a dahil edilmesi, istisnai ağ kullanım durumlarında daha uzun sürebilir.
+:::
+
+## Sepolia'dan Scroll Sepolia'ya Yatırma
+
+### Talimatlar
+
+1. İlk olarak, [Scroll Köprüsü'ne](https://sepolia.scroll.io/bridge) gidin ve "Cüzdanı Bağla" düğmesine basın.
+1. Uygulamada, **Ethereum Sepolia**'nın en üstte ve **Scroll Sepolia**'nın en altta olduğundan emin olun. Pozisyonlarını değiştirmek için "**↓**" düğmesine tıklayabilirsiniz.
+1. Sepolia'dan Scroll Sepolia'ya transfer etmek istediğiniz tokenı seçin. İlk kez köprü kullanıyorsanız, "ETH"yi deneyin.
+1. Eğer belirli bir ERC20 tokenını ilk kez transfer ediyorsanız, Sepolia Köprü sözleşmesine ERC20 tokenınıza erişim izni vermek için **Onayla**'yı seçmelisiniz.
+1. Ardından, yatırma işlemi yapmak için **Scroll Sepolia'ya Gönder** düğmesine tıklayın. Cüzdanınız transfer işlemini onaylamanızı isteyecektir.
+1. Transfer işlemi gönderildikten ve onaylandıktan sonra, token Sepolia cüzdanınızdan düşecektir.
+1. Bir işlemin durumunu her zaman sağ üst köşede cüzdan adresinizin yanındaki "Geçmiş" simgesine basarak kontrol edebilirsiniz.
+
+### Tokenlarınız Scroll Sepolia cüzdanınıza ne zaman ulaşır?
+
+Tokenlarınızın Scroll Sepolia cüzdanınıza gelmesi **8 ile 14 dakika** arasında sürebilir. (Sepolia'da [_Güvenli_](https://www.alchemy.com/overviews/ethereum-commitment-levels#what-are-ethereum-commitment-levels) duruma gelmesi bekleniyor).
+
+{/* You can check the progress of deposit transactions as follows: */}
+
+{/* ##### 1. Click the "History" icon next to your wallet address in the top-right corner. */}
+
+{/* */}
+
+{/* The pop-up panel lists the most recent transactions made in the Bridge app. There are two statuses: Sepolia status and Scroll Sepolia status. For deposit transactions (L1 -> L2), once your transaction becomes _Safe_ on Sepolia (**8 to 14 minutes**), you will see the **`success`** status shown. Your funds will be relayed to Scoll Sepolia after this. */}
+
+{/* The Recent Bridge Transactions window should give you an estimate of the time expected before your transaction is _Safe_ on Sepolia. */}
+
+{/* ##### 2. Click on the most recent transaction’s Sepolia transaction hash. */}
+
+{/* */}
+
+{/* It will open the Transaction Details page in a new tab. You can see this transaction is confirmed on Sepolia. To check the Block's confirmation status, click the Block number and read the "Status" field. */}
+
+{/* */}
+
+{/* ##### 3. Return to the Bridge app and wait! */}
+
+{/* Once your transaction status shows **`success`** on Scroll Sepolia, you should see the funds in your Scroll L2 wallet and a transaction hash: */}
+
+{/* */}
+
+## Scroll Sepolia'dan Sepolia'ya Varlık Çekme
+
+### Talimatlar
+
+#### İlk Çekim İşleminizi Gönderme
+
+1. İlk olarak, cüzdanınızda **Scroll Sepolia** Ağı'na geçin.
+1. Uygulamada, **Scroll Sepolia**'nın en üstte ve **Ethereum Sepolia**'nın en altta olduğundan emin olun. Pozisyonlarını değiştirmek için "**↓**" butonuna tıklayabilirsiniz.
+1. **Scroll Sepolia**'dan **Sepolia**'ya aktarmak istediğiniz tokenı seçin. İlk kez köprü kullanıyorsanız, "ETH"yi deneyin.
+1. Eğer belirli bir ERC20 tokenını ilk kez transfer ediyorsanız, Scroll Sepolia Köprü sözleşmesine ERC20 tokenınıza erişim izni vermek için **Onayla**'yı seçmelisiniz.
+1. Ardından, varlık çekme işlemi yapmak için **Ethereum Sepolia'ya Gönder** düğmesine tıklayın. Cüzdanınız transfer işlemini onaylamanızı isteyecektir.
+1. Transfer işlemi gönderildikten ve onaylandıktan sonra, token Scroll Sepolia cüzdanınızdan düşecektir.
+
+#### Çekim Gerçekleştirme İşlemi Göndermek
+
+_Kalan adımlar Scroll Sepolia'da gerçekleşiyor, ama işleminizin Ethereum Sepolia'da tamamen kanıtlanması ("kesinleşmesi") beklenmelidir. Bu süreç en fazla dört saat sürebilir._
+
+1. Varlık çekme işleminiz Ethereum Sepolia'da tamamlandığında, Son İşlemler alanındaki "Talep Et" butonunun sabit hale geldiğini göreceksiniz.
+1. "Talep Et" düğmesine tıklayarak Çekim Gerçekleştirme işlemini gönderin.
+1. Gönderildikten sonra, çekilen fonlarınız Sepolia cüzdanınızda hemen görünmelidir.
+
+### Tokenlarınız ne zaman Sepolia cüzdanınıza ulaşır?
+
+Transfer edilen token, Çekim Gerçekleştirme işlemi Sepolia'da onaylandıktan hemen sonra Sepolia cüzdanınıza ulaşacaktır.
+
+{/* TODO: check architecture link is live */}
+
+:::tip[Rollup Durumu]
+Rollup durumu `Kesinleştirildi`, bu bloktaki işlemlerin doğru bir şekilde yürütülmesinin Sepolia üzerinde bir geçerlilik kanıtının doğrulanmasıyla kanıtlandığını belirtir. Rollup durumu hakkında daha fazla bilgi için [Scroll Mimarisine Genel Bakış](/tr/technology)'a bakın.
+:::
+
+{/* You can check the progress of withdrawal transactions as follows: */}
+
+{/* 1. Click your wallet address at the top-right corner of the Bridge web app. */}
+
+{/* */}
+
+{/* The pop-up panel lists the most recent transactions you made in the Bridge app (see the image below). There are two statuses: L1 status and L2 status. In this case, because we are bridging from L2 -> L1, we will quickly get a **`success`** status after submitting the transaction to the L2 Bridge. L1, on the other hand, takes **10 minutes to a few hours** to reach **`success`**. */}
+
+{/* 1. Click on the most recent transaction’s L2 transaction hash: */}
+
+{/* */}
+
+{/* It will open the _Transaction Details_ page in a new tab. You can see this transaction is confirmed on L2. */}
+
+{/* */}
+
+{/* The transaction is confirmed on L2, but still needs to be finalized on Goerli. */}
+
+{/* 1. Go back to the [Bridge](https://scroll.io/bridge) app. It takes about 10 minutes before the token shows up in your Goerli wallet. Once your transaction status shows success on L2, you should see the funds in your Goerli wallet and a transaction hash: */}
+
+{/* */}
diff --git a/src/content/docs/tr/user-guide/common-errors.mdx b/src/content/docs/tr/user-guide/common-errors.mdx
new file mode 100644
index 000000000..42285c7f5
--- /dev/null
+++ b/src/content/docs/tr/user-guide/common-errors.mdx
@@ -0,0 +1,41 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Yaygın Hatalar"
+lang: "tr"
+permalink: "user-guide/common-errors/"
+excerpt: "Scroll Sepolia Test Ağı ile etkileşim kurmaya çalışırken bir hata mı görüyorsunuz? İşte bazı yaygın yapılandırma hataları ve bunları hızlıca nasıl düzeltebileceğiniz hakkında bilgiler."
+---
+
+## MetaMask'te işlem gönderirken yanlış nonce hatası
+
+MetaMask cüzdanınızda depolanan yerel nonce, Scroll Test Ağı düğümündeki nonce'tan farklı olduğunda bu hatayla karşılaşırsınız. Bunun nedeni yakın zamanda bekleyen bir işleminiz olması olabilir.
+
+Bu sorunu düzeltmek için MetaMask hesabınızı Scroll Sepolia Test Ağı için sıfırlamanız gerekir. Hesabı sıfırlamak için izlenmesi gereken adımlar şunlardır:
+
+1. Tarayıcıda **MetaMask** uzantısını açın
+2. Üst bölgede **Scroll Sepolia Test Ağı'nı** seçin
+3. Sağ üst köşedeki yuvarlak **hesap simgesine** tıklayın
+4. **Ayarlar**'ı seçin
+5. **Gelişmiş** bölümüne gidin
+6. **Hesabı sıfırla**'ya tıklayın
+
+MetaMask hesabınızı sıfırlarken hiçbir varlık kaybolmaz.
+
+:::caution[Caution]
+Bir ağı kaldırmak ve yeniden eklemek bu sorunu düzeltmek için YETERLİ DEĞİLDİR - hesabınızı sıfırlamanız gerekir.
+:::
+
+## Köprüleme/değiştirme işlemi onaylandığında hiçbir şey olmuyor ise
+
+Eğer hata veya konsol kayıtları görünmüyorsa, büyük olasılıkla bir nonce sorunu vardır. Lütfen MetaMask hesabınızı yukarıda belirtilen şekilde [sıfırlayın](/tr/user-guide/common-errors).
+
+## Blok Gezgini "Dahili sunucu hatası" gösteriyor
+
+Bir gizli pencere kullanın veya tarayıcıdan geliştirici konsolunu açıp `_explorer_key` çerezini (veya tüm çerezleri) kaldırın. [Çerezlerin nasıl kaldırılacağı hakkında bu kılavuzu inceleyin.](https://www.contentstack.com/docs/developers/how-to-guides/clear-caches-and-cookies-in-different-browsers/).
+
+## MetaMask'te maksimum Ether gönderme "Başarısız" hatası veriyor
+
+MetaMask kullanarak Ether gönderirken, "Maksimum" miktarı göndermeyi denerseniz, "Başarısız" hatasıyla sonuçlanacaktır. Bunun nedeni, MetaMask'ın, rollup'ların normal gaz ücretlerinin yanı sıra ek "L1 Ücreti"ni hesaba katmaması ve işlemin gazını ödemek için gereken küçük bir miktarın yetersiz kalmasıdır.
+
+Bunu çözmek için, ether miktarını önerilenden biraz daha az olacak şekilde manuel olarak azaltın; işlem gerçekleşecektir.
diff --git a/src/content/docs/tr/user-guide/faucet.mdx b/src/content/docs/tr/user-guide/faucet.mdx
new file mode 100644
index 000000000..63322e572
--- /dev/null
+++ b/src/content/docs/tr/user-guide/faucet.mdx
@@ -0,0 +1,39 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Musluk"
+lang: "tr"
+permalink: "user-guide/faucet/"
+whatsnext: { "ETH'nizi Scroll Sepolia'ya köprüleyin": "/tr/user-guide/bridge" }
+excerpt: "Test ağımızla etkileşimde bulunmak için öncelikle Sepolia ETH elde etmeniz gerekiyor. Başlamak için birkaç Sepolia musluk uygulaması bulunmaktadır."
+---
+
+Test ağımız ile etkileşimde bulunmak için öncelikle _Sepolia Test Ağı'nda_ test ağı ETH'i almanız gerekmektedir. Daha sonra _Sepolia Test Ağı_ üzerinden _Scroll Sepolia Test Ağı'na_ köprüleme yapabilirsiniz.
+
+## Sepolia Muslukları
+
+Her musluk kendi kurallarına ve şartlarına sahiptir, bu nedenle işinize yarayacak bir musluk bulana kadar birkaç tanesini denemeniz gerekebilir.
+
+İşte birkaç Sepolia musluk uygulaması:
+
+- [https://sepoliafaucet.com](https://sepoliafaucet.com/)
+- [https://sepolia-faucet.pk910.de](https://sepolia-faucet.pk910.de)
+- [https://faucet.quicknode.com/drip](https://faucet.quicknode.com/drip)
+- [https://faucet.chainstack.com](https://faucet.chainstack.com)
+- [https://infura.io/faucet/sepolia](https://infura.io/faucet/sepolia)
+
+Sepolia'da ETH aldıktan sonra, bunları cüzdanınızda _Sepolia Ağı_ üzerinde görmelisiniz. Görünmeleri birkaç saniye sürebilir, ancak [Sepolia Blok Gezgini](https://sepolia.etherscan.io/) üzerinde adresinize yapılan bir işlemi kontrol ederek durumu kontrol edebilirsiniz.
+
+:::note[Yavaşlayın!]
+Çoğu musluk, test tokenları için yalnızca 24 saatte bir talep oluşturmanıza izin verir.
+:::
+
+## Scroll Sepolia Muslukları
+
+Köprü ile etkileşime geçmek istemiyorsanız, bazı musluklar doğrudan Scroll Sepolia ETH dağıtır.
+
+- [https://scroll.l2scan.co/faucet](https://scroll.l2scan.co/faucet)
+- [https://www.covalenthq.com/faucet/](https://www.covalenthq.com/faucet)
+- [https://faucet.quicknode.com/scroll/sepolia](https://faucet.quicknode.com/scroll/sepolia)
+- [https://bwarelabs.com/faucets/scroll-testnet](https://bwarelabs.com/faucets/scroll-testnet)
+- [https://scroll.faucetme.pro](https://scroll.faucetme.pro)
diff --git a/src/content/docs/tr/user-guide/index.mdx b/src/content/docs/tr/user-guide/index.mdx
new file mode 100644
index 000000000..5abdb281a
--- /dev/null
+++ b/src/content/docs/tr/user-guide/index.mdx
@@ -0,0 +1,44 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Scroll Sepolia Kullanıcı Kılavuzu"
+lang: "tr"
+permalink: "user-guide/"
+excerpt: "Sepolia Test Ağı'mızı denediğiniz için teşekkür ederiz. Sepolia Ağı, Ethereum Sepolia Test Ağı'nı ve Scroll Sepolia Test Ağı'nı içerir."
+whatsnext: { "Cüzdanınızı Kurun": "/tr/user-guide/setup" }
+---
+
+import Aside from "../../../../components/Aside.astro"
+
+
+
+Scroll Sepolia Test Ağı'nı denediğiniz için teşekkür ederiz. Sorularınız varsa veya geri bildirimde bulunmak istiyorsanız, [Discord](https://discord.gg/scroll)'umuza katılın!
+
+Sepolia Test Ağı, _Ethereum Sepolia Test Ağı_ ve _Scroll Sepolia Test Ağı'ndan_ oluşur. Sepolia, bir Ethereum test ağıdır; Scroll Sepolia ise, bu test ağının üstüne kurulmuş bir zero knowledge rollup(zk rollup) test ağıdır. Önceden dağıtılmış bazı demo uygulamalar bulunmaktadır: _Sepolia_ ile _Scroll Sepolia_ arasında bir [köprü](https://sepolia.scroll.io/bridge),[^1] _Scroll Sepolia_ için bir [blok gezgini](https://sepolia-blockscout.scroll.io/),[^2] ve bir [rollup gezgini](https://sepolia.scroll.io/rollupscan).
+
+L1 işlemlerini görüntülemek için Etherscan'in [Sepolia gezgini](https://sepolia.etherscan.io/).
+L2 işlemlerini görüntülemek için [Scrollscan](https://sepolia.scrollscan.com) veya Scroll'un [Blockscout](https://sepolia-blockscout.scroll.io/)'unu kullanabilirsiniz, ancak ayrıca [Dora](https://www.ondora.xyz/network/scroll-sepolia/interactions) veya [L2Scan](https://scroll-sepolia.l2scan.co/)'in sağladığı ek işlevleri de denemek isteyebilirsiniz.
+
+Test ağını keşfetmek için önerilen iş akışı aşağıdaki gibidir:
+
+1. Cüzdanınıza [Sepolia Test Ağı](https://sepolia.scroll.io/portal) yapılandırmalarını ekleyin
+2. Herhangi bir Ethereum Musluğu uygulamasından _Sepolia_ ağında test tokenları isteyin. (bkz. [Musluk](/tr/user-guide/faucet) makalesi)
+3. _Sepolia_ ile _Scroll Sepolia_ arasında [Köprü](https://sepolia.scroll.io/bridge) uygulaması aracılığıyla test tokenlarını aktarın.
+4. Cüzdanınızı kullanarak _Scroll Sepolia_'daki diğer cüzdanlara token aktarın.
+5. [Uniswap](https://uniswap-showcase.sepolia.scroll.xyz/) veya [Aave](https://app.aave.com) gibi akıllı sözleşmelerle etkileşimde bulunarak ekosistemimizi keşfedin.
+6. _Scroll Sepolia_'dan _Sepolia_'ya tokenları [Köprü](https://sepolia.scroll.io/bridge) uygulaması aracılığıyla çekin.
+
+Her uygulama için talimatları bu kullanıcı kılavuzunun geri kalanında bulabilirsiniz.
+
+## Sorular ve Geri Bildirim
+
+Herhangi bir sorunla karşılaşırsanız, [Discord](https://discord.gg/scroll)'a katılın ve `#general-support` kanalında bizimle konuşun. Ayrıca deneyiminizi nasıl iyileştirebileceğimiz hakkındaki düşüncelerinizi veya geri bildirimlerinizi de duymaktan mutluluk duyarız.
+
+[^1]: [Hop Exchange](https://hop.exchange/) arayüzünden forklanmıştır 🐇🙌
+[^2]: [Blockscout](https://blockscout.com/)'un harika açık kaynaklı blok gezgini
\ No newline at end of file
diff --git a/src/content/docs/tr/user-guide/setup.mdx b/src/content/docs/tr/user-guide/setup.mdx
new file mode 100644
index 000000000..2dda51c18
--- /dev/null
+++ b/src/content/docs/tr/user-guide/setup.mdx
@@ -0,0 +1,40 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Kurulum"
+lang: "tr"
+permalink: "user-guide/setup/"
+whatsnext: { "Sepolia ETH'sini bir musluktan alabilirsiniz": "/tr/user-guide/faucet" }
+excerpt: "Scroll Test Ağı ile etkileşimde bulunmak için bir cüzdana ihtiyacınız var. Bazı örnek cüzdanlara ve yapılandırma ipuçlarına işte buradan ulaşabilirsiniz."
+---
+
+import Aside from "../../../../components/Aside.astro"
+
+## Cüzdan
+
+Scroll Sepolia Test Ağı'ndaki dApp'lerle etkileşimde bulunmak için bir cüzdana ihtiyacınız olacak. Aşağıda bazı örnek cüzdanları ve yapılandırma ipuçlarını bulabilirsiniz. Köprü uygulamamız MetaMask, Coinbase Wallet veya WalletConnect desteği olan herhangi bir cüzdanı destekler.
+
+### MetaMask
+
+MetaMask'i [resmi web sitelerinden](https://metamask.io/download/) indirebilirsiniz.
+
+Scroll Sepolia Test Ağı yapılandırmalarını MetaMask cüzdanınıza içe aktarabilirsiniz. Bunun için, [Scroll Sepolia portalına](https://sepolia.scroll.io/portal) gidin, ardından "Cüzdanı Bağla" düğmesine tıklayın ve MetaMask'i seçin. Sonraki adımda, Sepolia Test Ağı ve Scroll Sepolia Test Ağı için "MetaMask'e Ekle" düğmelerine tıklayın. Bu işlem, Scroll Sepolia Test Ağı için zincir kimliği ve RPC URL'lerini içe aktaracaktır. Sepolia Test Ağı ayrıca MetaMask'te varsayılan olarak yapılandırılmıştır. Onu göstermek için, MetaMask ağ seçim açılır menüsünde "Test ağlarını göster/gizle" yi tıklayın.
+
+### Manuel ağ yapılandırması (diğer cüzdanlar için)
+
+**Cüzdan Ekle** bağlantıları her cüzdanla uyumlu olmayabilir. Bunları kullanırken sorun yaşıyorsanız, _Sepolia Test Ağı_ ve _Scroll Sepolia Ağı'nı_ tablodaki yapılandırma detaylarını manuel olarak eklemeniz gerekebilir:
+
+| Ağ Adı | Scroll Sepolia Test Ağı | Sepolia Test Ağı |
+| ------------------ | ---------------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| RPC URL | [https://sepolia-rpc.scroll.io/](https://sepolia-rpc.scroll.io/) | [https://eth-sepolia-public.unifra.io](https://eth-sepolia-public.unifra.io) |
+| Zincir Kimliği | 534351 | 11155111 |
+| Para Birimi Sembolü| ETH | ETH |
+| Blok Gezgini URL'si| [https://sepolia.scrollscan.com](https://sepolia.scrollscan.com) | [https://sepolia.etherscan.io](https://sepolia.etherscan.io) |
+
+
diff --git a/src/content/docs/tr/user-guide/transfer-tokens.md b/src/content/docs/tr/user-guide/transfer-tokens.md
new file mode 100644
index 000000000..854a2cb5b
--- /dev/null
+++ b/src/content/docs/tr/user-guide/transfer-tokens.md
@@ -0,0 +1,18 @@
+---
+section: gettingStarted
+date: Last Modified
+title: "Tokenları Aktar"
+lang: "tr"
+permalink: "user-guide/transfer-tokens/"
+excerpt: "Scroll Sepolia Test Ağı'nda tokenları aktarmak için cüzdanınızı her zamanki gibi kullanabilirsiniz."
+---
+
+Scroll Sepolia Test Ağı'nda token aktarmak için cüzdanınızın normal işlevini kullanabilirsiniz -- hiçbir ek yapılandırmaya gerek yoktur.
+
+## MetaMask'te bir token gönderme
+
+1. Cüzdanınızı açın ve **Scroll Sepolia Test Ağı**'na geçin.
+2. Ortadaki **Gönder** düğmesine tıklayın ve metin kutusuna transfer yapmak istediğiniz adresi yazın.
+3. **Varlık** kutusunda tokenı seçin ve aktarmak istediğiniz token miktarını yazın.
+4. İşlemi göndermek için **İleri** düğmesine ve ardından **Onayla** düğmesine tıklayın.
+5. Gönderdikten sonra işlemi cüzdanınızın **Aktivite** sekmesinde bulabilirsiniz.
diff --git a/src/pages/tr/[...redirect].astro b/src/pages/tr/[...redirect].astro
new file mode 100644
index 000000000..e81067797
--- /dev/null
+++ b/src/pages/tr/[...redirect].astro
@@ -0,0 +1,30 @@
+---
+import { changeLanguage } from "i18next"
+import { GetStaticPathsResult } from "astro"
+import redirects from "../../features/redirects/redirects.json"
+
+changeLanguage("tr")
+
+export async function getStaticPaths(): Promise {
+ const sanitizeSource = (source: string) => {
+ let newSource = source
+ if (newSource[newSource.length - 1] === "/") newSource = newSource.slice(0, newSource.length - 1)
+ if (newSource[0] === "/") return newSource.slice(1, newSource.length)
+ return newSource
+ }
+ return redirects.redirects.map((entry) => {
+ return {
+ params: { redirect: sanitizeSource(entry.source) },
+ props: {
+ to:
+ entry.destination.charAt(0) === "/" || entry.destination.includes("https://")
+ ? entry.destination
+ : "/" + entry.destination,
+ },
+ }
+ })
+}
+const { to } = Astro.props
+---
+
+
diff --git a/src/pages/tr/home/ConnectUs.astro b/src/pages/tr/home/ConnectUs.astro
new file mode 100644
index 000000000..bcc78345d
--- /dev/null
+++ b/src/pages/tr/home/ConnectUs.astro
@@ -0,0 +1,152 @@
+---
+import SectionHeader from "~/components/SectionHeader/index.astro"
+import LinkArrowSvg from "~/assets/svgs/home/home-link-arrow.svg?raw"
+import DiscordSvg from "~/assets/svgs/home/Discord.svg?raw"
+import ForumSvg from "~/assets/svgs/home/Forum.svg?raw"
+import ContributeSvg from "~/assets/svgs/home/Contribute.svg?raw"
+
+const mediaList = [
+ {
+ icon: DiscordSvg,
+ name: "Discord'umuza Katılın",
+ content: "Diğer Scroll geliştiricileri ve kullanıcılarıyla bağlantı kurun.",
+ link: "https://discord.gg/scroll",
+ },
+ {
+ icon: ForumSvg,
+ name: "Topluluk Forumu",
+ content: "Scroll'un temel protokollerindeki değişiklikleri tartışın ve önerin.",
+ link: "http://community.scroll.io/",
+ },
+ {
+ icon: ContributeSvg,
+ name: "Scroll'a Katkıda Bulunun",
+ content: "Diğer geliştiricilerle birlikte inşa edin.",
+ link: "https://github.com/scroll-tech/contribute-to-scroll",
+ },
+]
+---
+
+
}
+