diff --git a/public/content/translations/sw/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md b/public/content/translations/sw/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
new file mode 100644
index 00000000000..bba1c7f91c9
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/set-up-web3js-to-use-ethereum-in-javascript/index.md
@@ -0,0 +1,92 @@
+---
+title: Sanidi web3.js ili kutumia mnyororo wa bloku wa Ethereum katika JavaScript
+description: Jifunze jinsi ya kuweka na kusanidi maktaba ya web3.js ili kuingiliana na mnyororo wa bloku wa Ethereum kutoka kwa programu za JavaScript.
+author: "jdourlens"
+tags: [ "web3.js", "javascript" ]
+skill: beginner
+lang: sw
+published: 2020-04-11
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/setup-web3js-to-use-the-ethereum-blockchain-in-javascript/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+Katika somo hili, tutaona jinsi ya kuanza na [web3.js](https://web3js.readthedocs.io/) ili kuingiliana na mnyororo wa bloku wa Ethereum. Web3.js inaweza kutumika katika sehemu zote mbili za mbele na za nyuma ili kusoma data kutoka kwenye mnyororo wa bloku au kufanya miamala na hata kupeleka mikataba-erevu.
+
+Hatua ya kwanza ni kujumuisha web3.js katika mradi wako. Ili kuitumia kwenye ukurasa wa wavuti, unaweza kuagiza maktaba moja kwa moja kwa kutumia CDN kama JSDeliver.
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/web3@latest/dist/web3.min.js"></script>
+```
+
+Ukipenda kusakinisha maktaba ili kuitumia katika sehemu ya nyuma au mradi wa mbele unaotumia muundo unaweza kuisakinisha kwa kutumia npm:
+
+```bash
+npm install web3 --save
+```
+
+Kisha ili kuagiza Web3.js katika hati ya Node.js au mradi wa mbele wa Browserify, unaweza kutumia mstari ufuatao wa JavaScript:
+
+```js
+const Web3 = require("web3")
+```
+
+Sasa kwa kuwa tumejumuisha maktaba katika mradi tunahitaji kuianzisha. Mradi wako unahitaji kuwa na uwezo wa kuwasiliana na mnyororo wa bloku. Maktaba nyingi za Ethereum huwasiliana na [nodi](/developers/docs/nodes-and-clients/) kupitia simu za RPC. Ili kuanzisha mtoa huduma wetu wa Web3, tutaanzisha mfano wa Web3 kwa kupitisha URL ya mtoa huduma kama kiunda. Ikiwa una nodi au [mfano wa ganache unaoendeshwa kwenye kompyuta yako](https://ethereumdev.io/testing-your-smart-contract-with-existing-protocols-ganache-fork/) itaonekana kama hivi:
+
+```js
+const web3 = new Web3("http://localhost:8545")
+```
+
+Ikiwa ungependa kufikia moja kwa moja nodi iliyohifadhiwa unaweza kupata chaguo kwenye [nodi kama huduma](/developers/docs/nodes-and-clients/nodes-as-a-service).
+
+```js
+const web3 = new Web3("https://cloudflare-eth.com")
+```
+
+Ili kujaribu kwamba tumesanidi mfano wetu wa Web3 ipasavyo, tutajaribu kupata nambari ya bloku ya hivi karibuni kwa kutumia utendaji wa `getBlockNumber`. Utendaji huu unakubali simu ya kurudi kama kigezo na hurudisha nambari ya bloku kama nambari kamili.
+
+```js
+var Web3 = require("web3")
+const web3 = new Web3("https://cloudflare-eth.com")
+
+web3.eth.getBlockNumber(function (error, result) {
+  console.log(result)
+})
+```
+
+Ukiendesha programu hii, itachapisha tu nambari ya bloku ya hivi karibuni: juu ya mnyororo wa bloku. Unaweza pia kutumia miito ya utendaji ya `await/async` ili kuepuka miito ya kurudi iliyopachikwa katika msimbo wako:
+
+```js
+async function getBlockNumber() {
+  const latestBlockNumber = await web3.eth.getBlockNumber()
+  console.log(latestBlockNumber)
+  return latestBlockNumber
+}
+
+getBlockNumber()
+```
+
+Unaweza kuona utendaji wote unaopatikana kwenye mfano wa Web3 katika [nyaraka rasmi za web3.js](https://docs.web3js.org/).
+
+Maktaba nyingi za Web3 hazifanani kwa sababu chinichini maktaba hupiga simu za JSON-RPC kwa nodi ambayo hurudisha matokeo.
+
+<Divider />
+
+Ikiwa unafanya kazi kwenye kivinjari, baadhi ya pochi huweka mfano wa Web3 moja kwa moja na unapaswa kujaribu kuitumia kila inapowezekana hasa ikiwa unapanga kuingiliana na anwani ya Ethereum ya mtumiaji ili kufanya miamala.
+
+Hii hapa ni sehemu fupi ya kugundua ikiwa pochi ya MetaMask inapatikana na kujaribu kuiwasha ikiwa ipo. Baadaye itakuruhusu kusoma salio la mtumiaji na kuwawezesha kuhalalisha miamala ambayo ungependa wafanye kwenye mnyororo wa bloku wa Ethereum:
+
+```js
+if (window.ethereum != null) {
+  state.web3 = new Web3(window.ethereum)
+  try {
+    // Omba ufikiaji wa akaunti ikiwa inahitajika
+    await window.ethereum.enable()
+    // Akaunti sasa zimefichuliwa
+  } catch (error) {
+    // Mtumiaji amekataa ufikiaji wa akaunti...
+  }
+}
+```
+
+Njia mbadala za web3.js kama [Ethers.js](https://docs.ethers.io/) zipo na pia hutumiwa kwa kawaida. Katika somo linalofuata tutaona [jinsi ya kusikiliza kwa urahisi bloku mpya zinazoingia kwenye mnyororo wa bloku na kuona yaliyomo ndani yake](https://ethereumdev.io/listening-to-new-transactions-happening-on-the-blockchain/).
diff --git a/public/content/translations/sw/developers/tutorials/short-abi/index.md b/public/content/translations/sw/developers/tutorials/short-abi/index.md
new file mode 100644
index 00000000000..d46d8641b12
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/short-abi/index.md
@@ -0,0 +1,585 @@
+---
+title: "ABI Fupi za Uboreshaji wa Calldata"
+description: Kuboresha mikataba-erevu kwa ajili ya Optimistic Rollups
+author: Ori Pomerantz
+lang: sw
+tags: [ "safu ya 2" ]
+skill: intermediate
+published: 2022-04-01
+---
+
+## Utangulizi {#introduction}
+
+Katika makala haya, utajifunza kuhusu [optimistic rollups](/developers/docs/scaling/optimistic-rollups), gharama za miamala juu yao, na jinsi muundo huo tofauti wa gharama unavyotulazimu kuboresha mambo tofauti kuliko kwenye Mtandao Mkuu wa Ethereum.
+Pia utajifunza jinsi ya kutekeleza uboreshaji huu.
+
+### Ufichuzi kamili {#full-disclosure}
+
+Mimi ni mfanyakazi wa muda wote wa [Optimism](https://www.optimism.io/), kwa hivyo mifano katika makala haya itaendeshwa kwenye Optimism.
+Hata hivyo, mbinu iliyoelezwa hapa inapaswa kufanya kazi vizuri vile vile kwa rollups zingine.
+
+### Istilahi {#terminology}
+
+Wakati wa kujadili rollups, neno 'safu ya 1' (L1) hutumika kwa Mtandao Mkuu, mtandao wa uzalishaji wa Ethereum.
+Neno 'safu ya 2' (L2) hutumika kwa rollup au mfumo mwingine wowote unaotegemea L1 kwa usalama lakini hufanya usindikaji wake mwingi nje ya chain.
+
+## Je, tunawezaje kupunguza zaidi gharama ya miamala ya L2? {#how-can-we-further-reduce-the-cost-of-L2-transactions}
+
+[Optimistic rollups](/developers/docs/scaling/optimistic-rollups) zinapaswa kuhifadhi rekodi ya kila muamala wa kihistoria ili mtu yeyote aweze kuzipitia na kuthibitisha kwamba hali ya sasa ni sahihi.
+Njia ya bei nafuu zaidi ya kuingiza data kwenye Mtandao Mkuu wa Ethereum ni kuiandika kama calldata.
+Suluhisho hili lilichaguliwa na [Optimism](https://help.optimism.io/hc/en-us/articles/4413163242779-What-is-a-rollup-) na [Arbitrum](https://developer.offchainlabs.com/docs/rollup_basics#intro-to-rollups).
+
+### Gharama ya miamala ya L2 {#cost-of-l2-transactions}
+
+Gharama ya miamala ya L2 inaundwa na vijenzi viwili:
+
+1. Usindikaji wa L2, ambao kwa kawaida ni wa bei nafuu sana
+2. Ghala la L1, ambalo limeunganishwa na gharama za gesi za Mtandao Mkuu
+
+Ninapoandika haya, kwenye Optimism gharama ya gesi ya L2 ni 0.001 [Gwei](/developers/docs/gas/#pre-london).
+Gharama ya gesi ya L1, kwa upande mwingine, ni takriban gwei 40.
+[Unaweza kuona bei za sasa hapa](https://public-grafana.optimism.io/d/9hkhMxn7z/public-dashboard?orgId=1&refresh=5m).
+
+Baiti moja ya calldata hugharimu gesi 4 (ikiwa ni sifuri) au gesi 16 (ikiwa ni thamani nyingine yoyote).
+Moja ya operesheni za gharama kubwa zaidi kwenye EVM ni kuandika kwenye ghala.
+Gharama ya juu ya kuandika neno la baiti 32 kwenye ghala kwenye L2 ni gesi 22100. Kwa sasa, hii ni gwei 22.1.
+Kwa hivyo ikiwa tunaweza kuokoa baiti moja ya sifuri ya calldata, tutaweza kuandika takriban baiti 200 kwenye ghala na bado tuwe na faida.
+
+### ABI {#the-abi}
+
+Idadi kubwa ya miamala hufikia mkataba kutoka kwa akaunti inayomilikiwa na mtu wa nje.
+Mikataba mingi imeandikwa katika Solidity na kutafsiri uga wao wa data kulingana na [kiolesura cha binary cha programu (ABI)](https://docs.soliditylang.org/en/latest/abi-spec.html#formal-specification-of-the-encoding).
+
+Hata hivyo, ABI ilitengenezwa kwa ajili ya L1, ambapo baiti ya calldata hugharimu takriban sawa na operesheni nne za hesabu, sio L2 ambapo baiti ya calldata hugharimu zaidi ya operesheni elfu moja za hesabu.
+Calldata imegawanywa kama ifuatavyo:
+
+| Sehemu                          | Urefu | Baiti | Baiti zilizopotea | Gesi iliyopotea | Baiti zinazohitajika | Gesi inayohitajika |
+| ------------------------------- | ----: | ----: | ----------------: | --------------: | -------------------: | -----------------: |
+| Kiteuzi cha chaguo za kukokotoa |     4 |   0-3 |                 3 |              48 |                    1 |                 16 |
+| Sifuri                          |    12 |  4-15 |                12 |              48 |                    0 |                  0 |
+| Anwani ya mwisho                |    20 | 16-35 |                 0 |               0 |                   20 |                320 |
+| Kiasi                           |    32 | 36-67 |                17 |              64 |                   15 |                240 |
+| Jumla                           |    68 |       |                   |             160 |                      |                576 |
+
+Maelezo:
+
+- **Kiteuzi cha chaguo za kukokotoa**: Mkataba una chaguo za kukokotoa chini ya 256, kwa hivyo tunaweza kuzitofautisha kwa baiti moja.
+  Kwa kawaida baiti hizi si sifuri na kwa hivyo [hugharimu gesi kumi na sita](https://eips.ethereum.org/EIPS/eip-2028).
+- **Sifuri**: Baiti hizi daima ni sifuri kwa sababu anwani ya baiti ishirini haihitaji neno la baiti thelathini na mbili ili kuihifadhi.
+  Baiti zinazoshikilia sifuri hugharimu gesi nne ([angalia karatasi ya njano](https://ethereum.github.io/yellowpaper/paper.pdf), Nyongeza G,
+  k. 27, thamani ya `G`<sub>`txdatazero`</sub>).
+- **Kiasi**: Tukichukulia kuwa katika mkataba huu `decimals` ni kumi na nane (thamani ya kawaida) na kiasi cha juu cha tokeni tunachohamisha kitakuwa 10<sup>18</sup>, tunapata kiasi cha juu cha 10<sup>36</sup>.
+  256<sup>15</sup> &gt; 10<sup>36</sup>, kwa hivyo baiti kumi na tano zinatosha.
+
+Upotevu wa gesi 160 kwenye L1 kwa kawaida hauzingatiwi. Muamala hugharimu angalau [gesi 21,000](https://yakkomajuri.medium.com/blockchain-definition-of-the-week-ethereum-gas-2f976af774ed), kwa hivyo 0.8% ya ziada haijalishi.
+Hata hivyo, kwenye L2, mambo ni tofauti. Karibu gharama nzima ya muamala ni kuiandika kwa L1.
+Mbali na calldata ya muamala, kuna baiti 109 za kichwa cha muamala (anwani ya mwisho, saini, n.k.).
+Gharama ya jumla kwa hivyo ni `109*16+576+160=2480`, na tunapoteza takriban 6.5% ya hiyo.
+
+## Kupunguza gharama wakati haudhibiti mwishilio {#reducing-costs-when-you-dont-control-the-destination}
+
+Tukichukulia kuwa huna udhibiti juu ya mkataba wa mwishilio, bado unaweza kutumia suluhisho sawa na [hili](https://github.com/qbzzt/ethereum.org-20220330-shortABI).
+Wacha tupitie faili zinazohusika.
+
+### Token.sol {#token-sol}
+
+[Huu ni mkataba wa mwishilio](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/Token.sol).
+Ni mkataba wa kawaida wa ERC-20, wenye kipengele kimoja cha ziada.
+Kitendo hiki cha `faucet` humruhusu mtumiaji yeyote kupata tokeni fulani ya kutumia.
+Ingefanya mkataba wa uzalishaji wa ERC-20 usiwe na maana, lakini hurahisisha maisha wakati ERC-20 ipo tu kuwezesha majaribio.
+
+```solidity
+    /**
+     * @dev Gives the caller 1000 tokens to play with
+     */
+    function faucet() external {
+        _mint(msg.sender, 1000);
+    }   // function faucet
+```
+
+### CalldataInterpreter.sol {#calldatainterpreter-sol}
+
+[Huu ni mkataba ambao miamala inapaswa kuita na calldata fupi](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/contracts/CalldataInterpreter.sol).
+Wacha tuipitie mstari kwa mstari.
+
+```solidity
+//SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8.0;
+
+
+import { OrisUselessToken } from "./Token.sol";
+```
+
+Tunahitaji chaguo za kukokotoa za tokeni ili kujua jinsi ya kuiita.
+
+```solidity
+contract CalldataInterpreter {
+
+    OrisUselessToken public immutable token;
+```
+
+Anwani ya tokeni ambayo sisi ni proksi.
+
+```solidity
+
+    /**
+     * @dev Specify the token address
+     * @param tokenAddr_ The ERC-20 contract address
+     */
+    constructor(
+        address tokenAddr_
+    )  {
+        token = OrisUselessToken(tokenAddr_);
+    }   // constructor
+```
+
+Anwani ya tokeni ndiyo kigezo pekee tunachohitaji kubainisha.
+
+```solidity
+    function calldataVal(uint startByte, uint length)
+        private pure returns (uint) {
+```
+
+Soma thamani kutoka kwa calldata.
+
+```solidity
+        uint _retVal;
+
+        require(length < 0x21,
+            "calldataVal length limit is 32 bytes");
+
+        require(length + startByte <= msg.data.length,
+            "calldataVal trying to read beyond calldatasize");
+```
+
+Tutaipakia neno moja la baiti 32 (biti 256) kwenye kumbukumbu na kuondoa baiti ambazo si sehemu ya uga tunaotaka.
+Algorithm hii haifanyi kazi kwa thamani ndefu kuliko baiti 32, na bila shaka hatuwezi kusoma zaidi ya mwisho wa calldata.
+Kwenye L1 inaweza kuwa muhimu kuruka majaribio haya ili kuokoa gesi, lakini kwenye L2 gesi ni nafuu sana, ambayo huwezesha ukaguzi wowote wa kiakili tunaoweza kufikiria.
+
+```solidity
+        assembly {
+            _retVal := calldataload(startByte)
+        }
+```
+
+Tungeweza kunakili data kutoka kwa simu hadi `fallback()` (tazama hapa chini), lakini ni rahisi zaidi kutumia [Yul](https://docs.soliditylang.org/en/v0.8.12/yul.html), lugha ya mkusanyiko ya EVM.
+
+Hapa tunatumia [opcode ya CALLDATALOAD](https://www.evm.codes/#35) kusoma baiti `startByte` hadi `startByte+31` kwenye rundo.
+Kwa ujumla, sintaksia ya opcode katika Yul ni `<opcode name>(<first stack value, if any>,<second stack value, if any>...)`.
+
+```solidity
+
+        _retVal = _retVal >> (256-length*8);
+```
+
+Ni baiti za `urefu` muhimu pekee ndizo sehemu ya uga, kwa hivyo [tunahamisha kulia](https://en.wikipedia.org/wiki/Logical_shift) ili kuondoa thamani zingine.
+Hii ina faida iliyoongezwa ya kuhamisha thamani upande wa kulia wa uga, kwa hivyo ni thamani yenyewe badala ya thamani mara 256<sup>kitu</sup>.
+
+```solidity
+
+        return _retVal;
+    }
+
+
+    fallback() external {
+```
+
+Wito kwa mkataba wa Solidity usipofanana na saini zozote za chaguo za kukokotoa, huita [chaguo la kukokotoa la `fallback()`](https://docs.soliditylang.org/en/v0.8.12/contracts.html#fallback-function) (kwa kudhani kuna moja).
+Katika kisa cha `CalldataInterpreter`, wito _yoyote_ hufika hapa kwa sababu hakuna chaguo zingine za kukokotoa za `external` au `public`.
+
+```solidity
+        uint _func;
+
+        _func = calldataVal(0, 1);
+```
+
+Soma baiti ya kwanza ya calldata, ambayo inatuambia chaguo za kukokotoa.
+Kuna sababu mbili kwa nini chaguo za kukokotoa hazipatikani hapa:
+
+1. Chaguo za kukokotoa ambazo ni `pure` au `view` hazibadilishi hali na hazigharimu gesi (zinapoitwa nje ya chain).
+   Haina maana kujaribu kupunguza gharama yao ya gesi.
+2. Chaguo za kukokotoa zinazotegemea [`msg.sender`](https://docs.soliditylang.org/en/v0.8.12/units-and-global-variables.html#block-and-transaction-properties).
+   Thamani ya `msg.sender` itakuwa anwani ya `CalldataInterpreter`, si ya mpigaji simu.
+
+Kwa bahati mbaya, [ukiangalia vipimo vya ERC-20](https://eips.ethereum.org/EIPS/eip-20), hii inaacha chaguo moja tu la kukokotoa, `transfer`.
+Hii inatuacha na chaguo mbili tu za kukokotoa: `transfer` (kwa sababu tunaweza kuita `transferFrom`) na `faucet` (kwa sababu tunaweza kuhamisha tokeni kurudi kwa yeyote aliyetuita).
+
+```solidity
+
+        // Call the state changing methods of token using
+        // information from the calldata
+
+        // faucet
+        if (_func == 1) {
+```
+
+Wito kwa `faucet()`, ambayo haina vigezo.
+
+```solidity
+            token.faucet();
+            token.transfer(msg.sender,
+                token.balanceOf(address(this)));
+        }
+```
+
+Baada ya kuita `token.faucet()` tunapata tokeni. Hata hivyo, kama mkataba wa proksi, **hatuhitaji** tokeni.
+EOA (akaunti inayomilikiwa nje) au mkataba uliotuita unahitaji.
+Kwa hivyo tunahamisha tokeni zetu zote kwa yeyote aliyetuita.
+
+```solidity
+        // transfer (assume we have an allowance for it)
+        if (_func == 2) {
+```
+
+Kuhamisha tokeni kunahitaji vigezo viwili: anwani ya mwisho na kiasi.
+
+```solidity
+            token.transferFrom(
+                msg.sender,
+```
+
+Tunawaruhusu tu wapigaji simu kuhamisha tokeni wanazomiliki
+
+```solidity
+                address(uint160(calldataVal(1, 20))),
+```
+
+Anwani ya mwisho huanza kwenye baiti #1 (baiti #0 ni chaguo za kukokotoa).
+Kama anwani, ina urefu wa baiti 20.
+
+```solidity
+                calldataVal(21, 2)
+```
+
+Kwa mkataba huu mahususi tunadhani kwamba idadi ya juu ya tokeni ambazo mtu yeyote angetaka kuhamisha inatoshea katika baiti mbili (chini ya 65536).
+
+```solidity
+            );
+        }
+```
+
+Kwa ujumla, uhamisho unachukua baiti 35 za calldata:
+
+| Sehemu                          | Urefu | Baiti |
+| ------------------------------- | ----: | ----: |
+| Kiteuzi cha chaguo za kukokotoa |     1 |     0 |
+| Anwani ya mwisho                |    32 |  1-32 |
+| Kiasi                           |     2 | 33-34 |
+
+```solidity
+    }   // fallback
+
+}       // contract CalldataInterpreter
+```
+
+### test.js {#test-js}
+
+[Jaribio hili la kitengo cha JavaScript](https://github.com/qbzzt/ethereum.org-20220330-shortABI/blob/master/test/test.js) linatuonyesha jinsi ya kutumia utaratibu huu (na jinsi ya kuthibitisha kuwa inafanya kazi ipasavyo).
+Nitachukulia kuwa unaelewa [chai](https://www.chaijs.com/) na [ethers](https://docs.ethers.io/v5/) na nitaelezea tu sehemu zinazohusu mkataba haswa.
+
+```js
+const { expect } = require("chai");
+
+describe("CalldataInterpreter", function () {
+  it("Inapaswa kuturuhusu kutumia tokeni", async function () {
+    const Token = await ethers.getContractFactory("OrisUselessToken")
+    const token = await Token.deploy()
+    await token.deployed()
+    console.log("Anwani ya tokeni:", token.address)
+
+    const Cdi = await ethers.getContractFactory("CalldataInterpreter")
+    const cdi = await Cdi.deploy(token.address)
+    await cdi.deployed()
+    console.log("Anwani ya CalldataInterpreter:", cdi.address)
+
+    const signer = await ethers.getSigner()
+```
+
+Tunaanza kwa kupeleka mikataba yote miwili.
+
+```javascript
+    // Get tokens to play with
+    const faucetTx = {
+```
+
+Hatuwezi kutumia chaguo za kukokotoa za kiwango cha juu ambazo tungetumia kwa kawaida (kama vile `token.faucet()`) kuunda miamala, kwa sababu hatufuati ABI.
+Badala yake, tunapaswa kujenga muamala wenyewe na kisha kuutuma.
+
+```javascript
+      to: cdi.address,
+      data: "0x01"
+```
+
+Kuna vigezo viwili tunavyohitaji kutoa kwa muamala:
+
+1. `to`, anwani ya mwisho.
+   Huu ni mkataba wa mkalimani wa calldata.
+2. `data`, calldata ya kutuma.
+   Katika kesi ya simu ya bomba, data ni baiti moja, `0x01`.
+
+```javascript
+
+    }
+    await (await signer.sendTransaction(faucetTx)).wait()
+```
+
+Tunaita [mbinu ya `sendTransaction` ya mtia saini](https://docs.ethers.io/v5/api/signer/#Signer-sendTransaction) kwa sababu tayari tumebainisha lengo (`faucetTx.to`) na tunahitaji muamala utiwe saini.
+
+```javascript
+// Check the faucet provides the tokens correctly
+expect(await token.balanceOf(signer.address)).to.equal(1000)
+```
+
+Hapa tunathibitisha salio.
+Hakuna haja ya kuokoa gesi kwenye chaguo za kukokotoa za `view`, kwa hivyo tunaziendesha kawaida.
+
+```javascript
+// Give the CDI an allowance (approvals cannot be proxied)
+const approveTX = await token.approve(cdi.address, 10000)
+await approveTX.wait()
+expect(await token.allowance(signer.address, cdi.address)).to.equal(10000)
+```
+
+Mpe mkalimani wa calldata posho ili aweze kufanya uhamisho.
+
+```javascript
+// Transfer tokens
+const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
+const transferTx = {
+  to: cdi.address,
+  data: "0x02" + destAddr.slice(2, 42) + "0100",
+}
+```
+
+Unda muamala wa uhamisho. Baiti ya kwanza ni "0x02", ikifuatiwa na anwani ya mwisho, na hatimaye kiasi (0x0100, ambayo ni 256 katika desimali).
+
+```javascript
+    await (await signer.sendTransaction(transferTx)).wait()
+
+    // Check that we have 256 tokens less
+    expect (await token.balanceOf(signer.address)).to.equal(1000-256)
+
+    // And that our destination got them
+    expect (await token.balanceOf(destAddr)).to.equal(256)
+  })    // it
+})      // describe
+```
+
+## Kupunguza gharama unapodhibiti mkataba wa mwisho {#reducing-the-cost-when-you-do-control-the-destination-contract}
+
+Ikiwa una udhibiti juu ya mkataba wa mwisho unaweza kuunda chaguo za kukokotoa zinazokwepa ukaguzi wa `msg.sender` kwa sababu zinamuamini mkalimani wa calldata.
+[Unaweza kuona mfano wa jinsi hii inavyofanya kazi hapa, katika tawi la `control-contract`](https://github.com/qbzzt/ethereum.org-20220330-shortABI/tree/control-contract).
+
+Ikiwa mkataba ungekuwa ukijibu tu miamala ya nje, tungeweza kutosheka na kuwa na mkataba mmoja tu.
+Hata hivyo, hilo lingevunja [uwezo wa kutunga](/developers/docs/smart-contracts/composability/).
+Ni bora zaidi kuwa na mkataba unaojibu simu za kawaida za ERC-20, na mkataba mwingine unaojibu miamala yenye data fupi ya simu.
+
+### Token.sol {#token-sol-2}
+
+Katika mfano huu tunaweza kurekebisha `Token.sol`.
+Hii inatuwezesha kuwa na idadi ya chaguo za kukokotoa ambazo proksi pekee inaweza kuita.
+Hapa kuna sehemu mpya:
+
+```solidity
+    // The only address allowed to specify the CalldataInterpreter address
+    address owner;
+
+    // The CalldataInterpreter address
+    address proxy = address(0);
+```
+
+Mkataba wa ERC-20 unahitaji kujua utambulisho wa proksi aliyeidhinishwa.
+Hata hivyo, hatuwezi kuweka kigezo hiki katika mjenzi, kwa sababu hatujui thamani bado.
+Mkataba huu unathibitishwa kwanza kwa sababu proksi inatarajia anwani ya tokeni katika mjenzi wake.
+
+```solidity
+    /**
+     * @dev Calls the ERC20 constructor.
+     */
+    constructor(
+    ) ERC20("Oris useless token-2", "OUT-2") {
+        owner = msg.sender;
+    }
+```
+
+Anwani ya muundaji (inayoitwa `owner`) huhifadhiwa hapa kwa sababu hiyo ndiyo anwani pekee inayoruhusiwa kuweka proksi.
+
+```solidity
+    /**
+     * @dev set the proxy address (CalldataInterpreter).
+     * Can only be called once by the owner
+     */
+    function setProxy(address _proxy) external {
+        require(msg.sender == owner, "Can only be called by owner");
+        require(proxy == address(0), "Proxy is already set");
+
+        proxy = _proxy;
+    }    // function setProxy
+```
+
+Proksi ina ufikiaji wa upendeleo, kwa sababu inaweza kukwepa ukaguzi wa usalama.
+Ili kuhakikisha tunaweza kuamini proksi tunamruhusu `mmiliki` pekee kuita chaguo hili la kukokotoa, na mara moja tu.
+Mara `proksi` inapokuwa na thamani halisi (sio sifuri), thamani hiyo haiwezi kubadilika, kwa hivyo hata ikiwa mmiliki ataamua kuwa mhalifu, au mnemonic yake itafichuliwa, bado tuko salama.
+
+```solidity
+    /**
+     * @dev Some functions can only be called by the proxy.
+     */
+    modifier onlyProxy {
+```
+
+Hiki ni kitendakazi cha `kirekebishaji` (https://www.tutorialspoint.com/solidity/solidity_function_modifiers.htm), kinarekebisha jinsi vitendakazi vingine vinavyofanya kazi.
+
+```solidity
+      require(msg.sender == proxy);
+```
+
+Kwanza, thibitisha tumeitwa na proksi na si mtu mwingine.
+Ikiwa sivyo, `revert`.
+
+```solidity
+      _;
+    }
+```
+
+Ikiwa ndivyo, endesha kitendakazi tunachorekebisha.
+
+```solidity
+   /* Functions that allow the proxy to act on behalf of accounts */
+
+    function transferProxy(address from, address to, uint256 amount)
+        public virtual onlyProxy() returns (bool)
+    {
+        _transfer(from, to, amount);
+        return true;
+    }
+
+    function approveProxy(address from, address spender, uint256 amount)
+        public virtual onlyProxy() returns (bool)
+    {
+        _approve(from, spender, amount);
+        return true;
+    }
+
+    function transferFromProxy(
+        address spender,
+        address from,
+        address to,
+        uint256 amount
+    ) public virtual onlyProxy() returns (bool)
+    {
+        _spendAllowance(from, spender, amount);
+        _transfer(from, to, amount);
+        return true;
+    }
+```
+
+Hizi ni shughuli tatu ambazo kwa kawaida huhitaji ujumbe kutoka moja kwa moja kutoka kwa huluki inayohamisha tokeni au kuidhinisha posho.
+Hapa tuna toleo la proksi la shughuli hizi ambalo:
+
+1. Hurekebishwa na `onlyProxy()` ili hakuna mtu mwingine anayeruhusiwa kuzidhibiti.
+2. Hupata anwani ambayo kwa kawaida ingekuwa `msg.sender` kama kigezo cha ziada.
+
+### CalldataInterpreter.sol {#calldatainterpreter-sol-2}
+
+Mkalimani wa calldata karibu anafanana na ule ulio juu, isipokuwa kwamba chaguo za kukokotoa zinazowakilishwa hupokea kigezo cha `msg.sender` na hakuna haja ya posho ya `transfer`.
+
+```solidity
+        // transfer (no need for allowance)
+        if (_func == 2) {
+            token.transferProxy(
+                msg.sender,
+                address(uint160(calldataVal(1, 20))),
+                calldataVal(21, 2)
+            );
+        }
+
+        // approve
+        if (_func == 3) {
+            token.approveProxy(
+                msg.sender,
+                address(uint160(calldataVal(1, 20))),
+                calldataVal(21, 2)
+            );
+        }
+
+        // transferFrom
+        if (_func == 4) {
+            token.transferFromProxy(
+                msg.sender,
+                address(uint160(calldataVal( 1, 20))),
+                address(uint160(calldataVal(21, 20))),
+                calldataVal(41, 2)
+            );
+        }
+```
+
+### Test.js {#test-js-2}
+
+Kuna mabadiliko machache kati ya msimbo wa awali wa majaribio na huu.
+
+```js
+const Cdi = await ethers.getContractFactory("CalldataInterpreter")
+const cdi = await Cdi.deploy(token.address)
+await cdi.deployed()
+await token.setProxy(cdi.address)
+```
+
+Tunahitaji kuuambia mkataba wa ERC-20 ni proksi gani ya kuamini
+
+```js
+console.log("CalldataInterpreter address:", cdi.address)
+
+// Need two signers to verify allowances
+const signers = await ethers.getSigners()
+const signer = signers[0]
+const poorSigner = signers[1]
+```
+
+Ili kuangalia `approve()` na `transferFrom()` tunahitaji mtia saini wa pili.
+Tunaiita `poorSigner` kwa sababu haipati tokeni zetu zozote (inahitaji kuwa na ETH, bila shaka).
+
+```js
+// Transfer tokens
+const destAddr = "0xf5a6ead936fb47f342bb63e676479bddf26ebe1d"
+const transferTx = {
+  to: cdi.address,
+  data: "0x02" + destAddr.slice(2, 42) + "0100",
+}
+await (await signer.sendTransaction(transferTx)).wait()
+```
+
+Kwa sababu mkataba wa ERC-20 unaiamini proksi (`cdi`), hatuhitaji posho ya kuwasilisha uhamisho.
+
+```js
+// approval and transferFrom
+const approveTx = {
+  to: cdi.address,
+  data: "0x03" + poorSigner.address.slice(2, 42) + "00FF",
+}
+await (await signer.sendTransaction(approveTx)).wait()
+
+const destAddr2 = "0xE1165C689C0c3e9642cA7606F5287e708d846206"
+
+const transferFromTx = {
+  to: cdi.address,
+  data: "0x04" + signer.address.slice(2, 42) + destAddr2.slice(2, 42) + "00FF",
+}
+await (await poorSigner.sendTransaction(transferFromTx)).wait()
+
+// Check the approve / transferFrom combo was done correctly
+expect(await token.balanceOf(destAddr2)).to.equal(255)
+```
+
+Jaribu chaguo mbili mpya za kukokotoa.
+Kumbuka kwamba `transferFromTx` inahitaji vigezo viwili vya anwani: mtoaji wa posho na mpokeaji.
+
+## Hitimisho {#conclusion}
+
+Wote [Optimism](https://medium.com/ethereum-optimism/the-road-to-sub-dollar-transactions-part-2-compression-edition-6bb2890e3e92) na [Arbitrum](https://developer.offchainlabs.com/docs/special_features) wanatafuta njia za kupunguza ukubwa wa calldata iliyoandikwa kwa L1 na kwa hivyo gharama ya miamala.
+Hata hivyo, kama watoa huduma wa miundombinu wanaotafuta suluhisho za jumla, uwezo wetu una mipaka.
+Kama msanidi programu wa mfumo mtawanyo wa kimamlaka, una ujuzi maalum wa programu, ambao unakuwezesha kuboresha calldata yako vizuri zaidi kuliko tunavyoweza katika suluhisho la jumla.
+Tunatumahi, makala haya yanakusaidia kupata suluhisho bora kwa mahitaji yako.
+
+[Tazama hapa kwa kazi zangu zaidi](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/sw/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/sw/developers/tutorials/smart-contract-security-guidelines/index.md
new file mode 100644
index 00000000000..e26d1fd9f21
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -0,0 +1,91 @@
+---
+title: Miongozo ya usalama ya mkataba-erevu
+description: Orodha hakiki ya miongozo ya usalama ya kuzingatia unapojenga dapp yako
+author: "Trailofbits"
+tags: [ "uimara", "mikataba erevu", "usalama" ]
+skill: intermediate
+lang: sw
+published: 2020-09-06
+source: Building secure contracts
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
+---
+
+Fuata mapendekezo haya ya kiwango cha juu ili kujenga mikataba-erevu salama zaidi.
+
+## Miongozo ya usanifu {#design-guidelines}
+
+Usanifu wa mkataba unapaswa kujadiliwa mapema, kabla ya kuandika mstari wowote wa msimbo.
+
+### Nyaraka na vipimo {#documentation-and-specifications}
+
+Nyaraka zinaweza kuandikwa katika viwango tofauti, na zinapaswa kusasishwa wakati wa kutekeleza mikataba:
+
+- **Maelezo ya mfumo kwa Kiingereza rahisi**, yanayoelezea kile ambacho mikataba hufanya na dhana zozote kwenye msingi wa msimbo.
+- **Michoro ya schema na usanifu**, ikiwemo mwingiliano wa mkataba na mashine ya hali ya mfumo. [Vichapishi vya Slither](https://github.com/crytic/slither/wiki/Printer-documentation) vinaweza kusaidia kutengeneza schema hizi.
+- **Nyaraka za msimbo za kina**, umbizo la [Natspec](https://docs.soliditylang.org/en/develop/natspec-format.html) linaweza kutumika kwa ajili ya Solidity.
+
+### Ukokoaji wa Onchain dhidi ya offchain {#onchain-vs-offchain-computation}
+
+- **Weka msimbo mwingi iwezekanavyo offchain.** Weka safu ya onchain iwe ndogo. Chakata awali data na msimbo offchain kwa namna ambayo uthibitishaji kwenye onchain ni rahisi. Je, unahitaji orodha iliyopangwa? Panga orodha offchain, kisha angalia tu mpangilio wake kwenye onchain.
+
+### Uboreshaji {#upgradeability}
+
+Tulijadili suluhisho tofauti za uboreshaji katika [chapisho letu la blogi](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/). Fanya uamuzi wa makusudi kuunga mkono uboreshaji au la kabla ya kuandika msimbo wowote. Uamuzi utaathiri jinsi unavyounda msimbo wako. Kwa ujumla, tunapendekeza:
+
+- **Pendelea [uhamishaji wa mkataba](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) badala ya uboreshaji.** Mifumo ya uhamishaji ina faida nyingi sawa na ile inayoweza kuboreshwa, bila hasara zake.
+- **Tumia muundo wa kutenganisha data badala ya ule wa delegatecallproxy.** Ikiwa mradi wako una utenganisho wazi wa kimantiki, uboreshaji kwa kutumia utenganishaji wa data utahitaji marekebisho machache tu. Delegatecallproxy inahitaji utaalamu wa EVM na ina uwezekano mkubwa wa kuwa na makosa.
+- **Andika utaratibu wa uhamishaji/usasishaji kabla ya kupeleka.** Ikiwa itakubidi uchukue hatua chini ya shinikizo bila miongozo yoyote, utafanya makosa. Andika utaratibu wa kufuata mapema. Inapaswa kujumuisha:
+  - Wito unaoanzisha mikataba mipya
+  - Mahali ambapo funguo zimehifadhiwa na jinsi ya kuzifikia
+  - Jinsi ya kuangalia upelekaji! Tengeneza na jaribu hati ya baada ya upelekaji.
+
+## Miongozo ya utekelezaji {#implementation-guidelines}
+
+**Jitahidi kuwa na urahisi.** Daima tumia suluhisho rahisi zaidi linalofaa lengo lako. Mwanachama yeyote wa timu yako anapaswa kuwa na uwezo wa kuelewa suluhisho lako.
+
+### Muundo wa kazi {#function-composition}
+
+Usanifu wa msingi wa msimbo wako unapaswa kufanya msimbo wako kuwa rahisi kupitia. Epuka chaguzi za usanifu zinazopunguza uwezo wa kufikiria kuhusu usahihi wake.
+
+- **Gawanya mantiki ya mfumo wako**, ama kupitia mikataba mingi au kwa kuweka pamoja kazi zinazofanana (kwa mfano, uthibitishaji, hesabu, ...).
+- **Andika kazi ndogo, zenye lengo wazi.** Hii itarahisisha upitiaji na kuruhusu upimaji wa vijenzi vya kibinafsi.
+
+### Urithi {#inheritance}
+
+- **Weka urithi uweze kudhibitiwa.** Urithi unapaswa kutumika kugawanya mantiki, hata hivyo, mradi wako unapaswa kulenga kupunguza kina na upana wa mti wa urithi.
+- **Tumia [kichapishi cha urithi cha Slither](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph) kuangalia daraja la mikataba.** Kichapishi cha urithi kitakusaidia kupitia ukubwa wa daraja.
+
+### Matukio {#events}
+
+- **Rekodi shughuli zote muhimu.** Matukio yatasaidia kurekebisha mkataba wakati wa uundaji, na kuufuatilia baada ya kupelekwa.
+
+### Epuka mitego inayojulikana {#avoid-known-pitfalls}
+
+- **Fahamu masuala ya kawaida ya usalama.** Kuna rasilimali nyingi mtandaoni za kujifunza kuhusu masuala ya kawaida, kama vile [Ethernaut CTF](https://ethernaut.openzeppelin.com/), [Capture the Ether](https://capturetheether.com/), au [Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/).
+- **Fahamu sehemu za maonyo katika [nyaraka za Solidity](https://docs.soliditylang.org/en/latest/).** Sehemu za maonyo zitakujulisha kuhusu tabia zisizo dhahiri za lugha.
+
+### Tegemezi {#dependencies}
+
+- **Tumia maktaba zilizojaribiwa vizuri.** Kuingiza msimbo kutoka kwa maktaba zilizojaribiwa vizuri kutapunguza uwezekano wa kuandika msimbo wenye hitilafu. Ikiwa unataka kuandika mkataba wa ERC20, tumia [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
+- **Tumia kidhibiti tegemezi; epuka kunakili na kubandika msimbo.** Ikiwa unategemea chanzo cha nje, basi lazima ukiweke kisasa na chanzo asili.
+
+### Upimaji na uthibitishaji {#testing-and-verification}
+
+- **Andika majaribio ya kina ya vipande.** Mkusanyiko mpana wa majaribio ni muhimu ili kujenga programu ya hali ya juu.
+- **Tumia ukaguzi na sifa maalum za [Slither](https://github.com/crytic/slither), [Echidna](https://github.com/crytic/echidna) na [Manticore](https://github.com/trailofbits/manticore).** Zana za kiotomatiki zitasaidia kuhakikisha mkataba wako ni salama. Pitia sehemu iliyobaki ya mwongozo huu ili kujifunza jinsi ya kuandika ukaguzi na sifa zenye ufanisi.
+- **Tumia [crytic.io](https://crytic.io/).** Crytic huunganishwa na GitHub, hutoa ufikiaji wa vigunduzi vya faragha vya Slither, na huendesha ukaguzi wa sifa maalum kutoka Echidna.
+
+### Solidity {#solidity}
+
+- **Pendelea Solidity 0.5 badala ya 0.4 na 0.6.** Kwa maoni yetu, Solidity 0.5 ni salama zaidi na ina mazoea bora yaliyojengwa ndani kuliko 0.4. Solidity 0.6 imeonekana kuwa si thabiti sana kwa uzalishaji na inahitaji muda kukomaa.
+- **Tumia toleo thabiti kwa kuandaa; tumia toleo la hivi karibuni kuangalia maonyo.** Hakikisha msimbo wako hauna masuala yaliyoripotiwa na toleo la hivi karibuni la mkusanyaji. Hata hivyo, Solidity ina mzunguko wa haraka wa matoleo na ina historia ya hitilafu za mkusanyaji, kwa hivyo hatupendekezi toleo la hivi karibuni kwa upelekaji (angalia [pendekezo la toleo la solc la Slither](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33)).
+- **Usitumie uunganishaji wa ndani.** Uunganishaji unahitaji utaalamu wa EVM. Usiandike msimbo wa EVM kama hujai_bobea_ karatasi ya njano.
+
+## Miongozo ya upelekaji {#deployment-guidelines}
+
+Mara mkataba unapokuwa umeundwa na kupelekwa:
+
+- **Fuatilia mikataba yako.** Tazama kumbukumbu, na uwe tayari kuchukua hatua ikiwa kuna ukiukaji wa mkataba au mkoba.
+- **Ongeza maelezo yako ya mawasiliano kwenye [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts).** Orodha hii husaidia wahusika wengine kuwasiliana nawe ikiwa kasoro ya usalama itagunduliwa.
+- **Linda mikoba ya watumiaji wenye fursa.** Fuata [mazoea yetu bora](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/) ikiwa unahifadhi funguo katika mikoba ya maunzi.
+- **Kuwa na mpango wa kukabiliana na matukio.** Zingatia kuwa mikataba-erevu yako inaweza kuathiriwa. Hata kama mikataba yako haina hitilafu, mshambuliaji anaweza kuchukua udhibiti wa funguo za mmiliki wa mkataba.
diff --git a/public/content/translations/sw/developers/tutorials/stealth-addr/index.md b/public/content/translations/sw/developers/tutorials/stealth-addr/index.md
new file mode 100644
index 00000000000..173d5f4e2de
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/stealth-addr/index.md
@@ -0,0 +1,443 @@
+---
+title: "Kutumia Anwani za Siri"
+description: "Anwani za siri huruhusu watumiaji kuhamisha mali bila kujulikana. Baada ya kusoma makala haya, utaweza: Kueleza anwani za siri ni nini na jinsi zinavyofanya kazi, kuelewa jinsi ya kutumia anwani za siri kwa njia ambayo inalinda kutokujulikana, na kuandika programu ya wavuti inayotumia anwani za siri."
+author: Ori Pomerantz
+tags:
+  [
+    "Anwani ya siri",
+    "faragha",
+    "kriptografia",
+    "rust",
+    "wasm"
+  ]
+skill: intermediate
+published: 2025-11-30
+lang: sw
+sidebarDepth: 3
+---
+
+Wewe ni Bill. Kwa sababu ambazo hatutaziingilia, unataka kuchangia kampeni ya "Alice kwa Malkia wa Dunia" na kumfanya Alice ajue ulichangia ili akuzawadie akishinda. Kwa bahati mbaya, ushindi wake hauna uhakika. Kuna kampeni shindani, "Carol kwa Maliki wa Mfumo wa Jua". Ikiwa Carol atashinda, na akagundua ulichangia kwa Alice, utakuwa matatani. Kwa hivyo huwezi tu kuhamisha ETH 200 kutoka akaunti yako hadi ya Alice.
+
+[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564) ina suluhisho. ERC hii inaeleza jinsi ya kutumia [anwani za siri](https://nerolation.github.io/stealth-utils) kwa uhamisho usiojulikana.
+
+**Onyo**: Kriptografia nyuma ya anwani za siri, kwa kadiri tunavyojua, ni thabiti. Hata hivyo, kuna uwezekano wa mashambulizi ya njia za pembeni. [Chini](#go-wrong), utaona unachoweza kufanya ili kupunguza hatari hii.
+
+## Jinsi anwani za siri zinavyofanya kazi {#how}
+
+Makala haya yatajaribu kueleza anwani za siri kwa njia mbili. Ya kwanza ni [jinsi ya kuzitumia](#how-use). Sehemu hii inatosha kuelewa sehemu iliyobaki ya makala. Kisha, kuna [maelezo ya hisabati nyuma yake](#how-math). Ikiwa una nia ya kriptografia, soma sehemu hii pia.
+
+### Toleo rahisi (jinsi ya kutumia anwani za siri) {#how-use}
+
+Alice huunda funguo mbili za binafsi na kuchapisha funguo za umma zinazolingana (ambazo zinaweza kuunganishwa kuwa anwani-meta moja ya urefu maradufu). Bill pia huunda ufunguo wa binafsi na kuchapisha ufunguo wa umma unaolingana.
+
+Kwa kutumia ufunguo wa umma wa upande mmoja na ufunguo wa binafsi wa mwingine, unaweza kupata siri ya pamoja inayojulikana tu na Alice na Bill (haiwezi kutolewa kutoka kwa funguo za umma pekee). Kwa kutumia siri hii ya pamoja, Bill anapata anwani ya siri na anaweza kutuma mali kwake.
+
+Alice pia hupata anwani kutoka kwa siri ya pamoja, lakini kwa sababu anajua funguo za binafsi za funguo za umma alizochapisha, anaweza pia kupata ufunguo wa binafsi unaomruhusu kutoa pesa kutoka kwa anwani hiyo.
+
+### Hisabati (kwa nini anwani za siri hufanya kazi hivi) {#how-math}
+
+Anwani za kawaida za siri hutumia [kriptografia ya mzingo duaradufu (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor) kupata utendakazi bora na biti chache za ufunguo, huku zikidumisha kiwango kile kile cha usalama. Lakini kwa sehemu kubwa tunaweza kupuuza hilo na kujifanya tunatumia hesabu za kawaida.
+
+Kuna nambari ambayo kila mtu anaijua, _G_. Unaweza kuzidisha kwa _G_. Lakini kwa sababu ya asili ya ECC, haiwezekani kivitendo kugawanya kwa _G_. Njia ambayo kriptografia ya ufunguo wa umma hufanya kazi kwa ujumla katika Ethereum ni kwamba unaweza kutumia ufunguo wa binafsi, _P<sub>priv</sub>_, kusaini miamala ambayo kisha inathibitishwa na ufunguo wa umma, _P<sub>pub</sub> = GP<sub>priv</sub>_.
+
+Alice huunda funguo mbili za binafsi, _K<sub>priv</sub>_ na _V<sub>priv</sub>_. _K<sub>priv</sub>_ itatumika kutumia pesa kutoka kwa anwani ya siri, na _V<sub>priv</sub>_ kuona anwani ambazo ni za Alice. Kisha Alice huchapisha funguo za umma: _K<sub>pub</sub> = GK<sub>priv</sub>_ na _V<sub>pub</sub> = GV<sub>priv</sub>_
+
+Bill huunda ufunguo wa tatu wa binafsi, _R<sub>priv</sub>_, na kuchapisha _R<sub>pub</sub> = GR<sub>priv</sub>_ kwenye sajili ya kati (Bill angeweza pia kumtumia Alice, lakini tunadhania Carol anasikiliza).
+
+Bill anakokotoa _R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>_, ambayo anatarajia Alice pia aijue (imeelezwa hapa chini). Thamani hii inaitwa _S_, siri ya pamoja. Hii inampa Bill ufunguo wa umma, _P<sub>pub</sub> = K<sub>pub</sub>+G\*hashi(S)_. Kutoka kwa ufunguo huu wa umma, anaweza kukokotoa anwani na kutuma rasilimali zozote anazotaka kwake. Katika siku zijazo, ikiwa Alice atashinda, Bill anaweza kumwambia _R<sub>priv</sub>_ ili kudhibitisha rasilimali zilitoka kwake.
+
+Alice anakokotoa _R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_. Hii inampa siri ileile ya pamoja, _S_. Kwa sababu anajua ufunguo wa binafsi, _K<sub>priv</sub>_, anaweza kukokotoa _P<sub>priv</sub> = K<sub>priv</sub>+hashi(S)_. Ufunguo huu unamruhusu kufikia mali katika anwani inayotokana na _P<sub>pub</sub> = GP<sub>priv</sub> = GK<sub>priv</sub>+G\*hashi(S) = K<sub>pub</sub>+G\*hashi(S)_.
+
+Tuna ufunguo tofauti wa kutazama ili kumruhusu Alice kumpa kandarasi ndogo Dave's World Domination Campaign Services. Alice yuko tayari kumruhusu Dave ajue anwani za umma na kumjulisha pesa zaidi zinapopatikana, lakini hataki atumie pesa zake za kampeni.
+
+Kwa sababu kutazama na kutumia hutumia funguo tofauti, Alice anaweza kumpa Dave _V<sub>priv</sub>_. Kisha Dave anaweza kukokotoa _S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ na kwa njia hiyo kupata funguo za umma (_P<sub>pub</sub> = K<sub>pub</sub>+G\*hashi(S)_). Lakini bila _K<sub>priv</sub>_ Dave hawezi kupata ufunguo wa binafsi.
+
+Kwa muhtasari, hizi ni thamani zinazojulikana na washiriki tofauti.
+
+| Alice                                                                     | Imechapishwa      | Bill                                                                      | Dave                                                                        |                                                |
+| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ---------------------------------------------- |
+| G                                                                         | G                 | G                                                                         | G                                                                           |                                                |
+| _K<sub>priv</sub>_                                                        | --                | --                                                                        | --                                                                          |                                                |
+| _V<sub>priv</sub>_                                                        | --                | --                                                                        | _V<sub>priv</sub>_                                                          |                                                |
+| _K<sub>pub</sub> = GK<sub>priv</sub>_                                     | _K<sub>pub</sub>_ | _K<sub>pub</sub>_                                                         | _K<sub>pub</sub>_                                                           |                                                |
+| _V<sub>pub</sub> = GV<sub>priv</sub>_                                     | _V<sub>pub</sub>_ | _V<sub>pub</sub>_                                                         | _V<sub>pub</sub>_                                                           |                                                |
+| --                                                                        | --                | _R<sub>priv</sub>_                                                        | --                                                                          |                                                |
+| _R<sub>pub</sub>_                                                         | _R<sub>pub</sub>_ | _R<sub>pub</sub> = GR<sub>priv</sub>_                                     | _R<sub>pub</sub>_                                                           |                                                |
+| _S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ | --                | _S = R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ | _S = _R<sub>pub</sub>V<sub>priv</sub>_ = GR<sub>priv</sub>V<sub>priv</sub>_ |                                                |
+| _P<sub>pub</sub> = K<sub>pub</sub>+G\*hashi(S)_        | --                | _P<sub>pub</sub> = K<sub>pub</sub>+G\*hashi(S)_        | _P<sub>pub</sub> = K<sub>pub</sub>+G\*hashi(S)_          |                                                |
+| _Anwani=f(P<sub>pub</sub>)_                            | --                | _Anwani=f(P<sub>pub</sub>)_                            | _Anwani=f(P<sub>pub</sub>)_                              | _Anwani=f(P<sub>pub</sub>)_ |
+| _P<sub>priv</sub> = K<sub>priv</sub>+hashi(S)_         | --                | --                                                                        | --                                                                          |                                                |
+
+## Wakati anwani za siri zinakwenda kombo {#go-wrong}
+
+_Hakuna siri kwenye mnyororo wa bloku_. Wakati anwani za siri zinaweza kukupa faragha, faragha hiyo iko katika hatari ya uchambuzi wa trafiki. Ili kuchukua mfano mdogo, fikiria kwamba Bill anafadhili anwani na mara moja anatuma muamala kuchapisha thamani ya _R<sub>pub</sub>_. Bila _V<sub>priv</sub>_ ya Alice, hatuwezi kuwa na uhakika kwamba hii ni anwani ya siri, lakini hiyo ndiyo njia ya kubashiri. Kisha, tunaona muamala mwingine unaohamisha ETH zote kutoka kwa anwani hiyo hadi kwa anwani ya hazina ya kampeni ya Alice. Huenda tusiweze kuthibitisha, lakini kuna uwezekano kwamba Bill alichangia kampeni ya Alice. Carol bila shaka angefikiria hivyo.
+
+Ni rahisi kwa Bill kutenganisha uchapishaji wa _R<sub>pub</sub>_ na ufadhili wa anwani ya siri (kufanya hivyo kwa nyakati tofauti, kutoka kwa anwani tofauti). Hata hivyo, hilo halitoshi. Mtindo ambao Carol anatafuta ni kwamba Bill anafadhili anwani, na kisha hazina ya kampeni ya Alice inatoa pesa kutoka humo.
+
+Suluhisho moja ni kwa kampeni ya Alice kutotoa pesa moja kwa moja, bali kuitumia kumlipa mtu wa tatu. Ikiwa kampeni ya Alice itatuma ETH 10 kwa Dave's World Domination Campaign Services, Carol atajua tu kwamba Bill alimchangia mmoja wa wateja wa Dave. Ikiwa Dave ana wateja wa kutosha, Carol hataweza kujua ikiwa Bill alichangia kwa Alice anayeshindana naye, au kwa Adam, Albert, au Abigail ambao Carol hawajali. Alice anaweza kujumuisha thamani iliyohashishwa na malipo, na kisha kumpa Dave picha ya awali, ili kuthibitisha kuwa ulikuwa mchango wake. Vinginevyo, kama ilivyoelezwa hapo juu, ikiwa Alice atampa Dave _V<sub>priv</sub>_ yake, tayari anajua malipo yalitoka kwa nani.
+
+Tatizo kuu la suluhisho hili ni kwamba linahitaji Alice ajali usiri wakati usiri huo unamnufaisha Bill. Alice anaweza kutaka kudumisha sifa yake ili rafiki yake Bill, Bob, pia amchangie. Lakini inawezekana pia kwamba hatamjali kumfichua Bill, kwa sababu basi ataogopa kitakachotokea ikiwa Carol atashinda. Bill anaweza kuishia kumpa Alice msaada zaidi.
+
+### Kutumia tabaka nyingi za siri {#multi-layer}
+
+Badala ya kumtegemea Alice kulinda faragha ya Bill, Bill anaweza kufanya hivyo mwenyewe. Anaweza kutengeneza anwani-meta nyingi kwa watu wa kubuni, Bob na Bella. Kisha Bill anatuma ETH kwa Bob, na "Bob" (ambaye kwa kweli ni Bill) anaituma kwa Bella. "Bella" (pia Bill) anaituma kwa Alice.
+
+Carol bado anaweza kufanya uchambuzi wa trafiki na kuona bomba la Bill-kwa-Bob-kwa-Bella-kwa-Alice. Hata hivyo, ikiwa "Bob" na "Bella" pia watatumia ETH kwa madhumuni mengine, haitaonekana kwamba Bill alihamisha chochote kwa Alice, hata kama Alice atatoa pesa mara moja kutoka kwa anwani ya siri hadi kwa anwani yake ya kampeni inayojulikana.
+
+## Kuandika programu ya anwani ya siri {#write-app}
+
+Makala haya yanaelezea programu ya anwani ya siri [inayopatikana kwenye GitHub](https://github.com/qbzzt/251022-stealth-addresses.git).
+
+### Zana {#tools}
+
+Kuna [maktaba ya typescript ya anwani za siri](https://github.com/ScopeLift/stealth-address-sdk) tunayoweza kutumia. Hata hivyo, operesheni za kikriptografia zinaweza kutumia CPU sana. Ninapendelea kuzitekeleza katika lugha iliyokusanywa, kama vile [Rust](https://rust-lang.org/), na kutumia [WASM](https://webassembly.org/) kuendesha msimbo kwenye kivinjari.
+
+Tutatumia [Vite](https://vite.dev/) na [React](https://react.dev/). Hizi ni zana za kawaida za tasnia; ikiwa huzifahamu, unaweza kutumia [mafunzo haya](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/). Ili kutumia Vite, tunahitaji Node.
+
+### Angalia anwani za siri zikifanya kazi {#in-action}
+
+1. Sakinisha zana zinazohitajika: [Rust](https://rust-lang.org/tools/install/) na [Node](https://nodejs.org/en/download).
+
+2. Clone hazina ya GitHub.
+
+   ```sh
+   git clone https://github.com/qbzzt/251022-stealth-addresses.git
+   cd 251022-stealth-addresses
+   ```
+
+3. Sakinisha mahitaji ya awali na ukusanye msimbo wa Rust.
+
+   ```sh
+   cd src/rust-wasm
+   rustup target add wasm32-unknown-unknown   
+   cargo install wasm-pack   
+   wasm-pack build --target web
+   ```
+
+4. Anzisha seva ya wavuti.
+
+   ```sh
+   cd ../../
+   npm install
+   npm run dev
+   ```
+
+5. Vinjari hadi [programu](http://localhost:5173/). Ukurasa huu wa programu una fremu mbili: moja kwa ajili ya kiolesura cha mtumiaji cha Alice na nyingine kwa ajili ya cha Bill. Fremu hizi mbili haziwasiliani; ziko tu kwenye ukurasa mmoja kwa urahisi.
+
+6. Kama Alice, bofya **Tengeneza Anwani-Meta ya Siri**. Hii itaonyesha anwani mpya ya siri na funguo za binafsi zinazolingana. Nakili anwani-meta ya siri kwenye ubao wa kunakili.
+
+7. Kama Bill, bandika anwani-meta mpya ya siri na bofya **Tengeneza anwani**. Hii inakupa anwani ya kufadhili kwa ajili ya Alice.
+
+8. Nakili anwani na ufunguo wa umma wa Bill na uvibandike katika eneo la "Ufunguo wa binafsi kwa anwani iliyotengenezwa na Bill" ya kiolesura cha mtumiaji cha Alice. Mara tu sehemu hizo zitakapojazwa, utaona ufunguo wa binafsi wa kufikia mali kwenye anwani hiyo.
+
+9. Unaweza kutumia [kikokotoo cha mtandaoni](https://iancoleman.net/ethereum-private-key-to-address/) ili kuhakikisha ufunguo wa binafsi unalingana na anwani.
+
+### Jinsi programu inavyofanya kazi {#how-the-program-works}
+
+#### Sehemu ya WASM {#wasm}
+
+Msimbo chanzo unaokusanywa kuwa WASM umeandikwa katika [Rust](https://rust-lang.org/). Unaweza kuuona katika [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs). Msimbo huu kimsingi ni kiolesura kati ya msimbo wa JavaScript na [maktaba ya `eth-stealth-addresses`](https://github.com/kassandraoftroy/eth-stealth-addresses).
+
+**`Cargo.toml`**
+
+[`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) katika Rust inafanana na [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) katika JavaScript. Ina maelezo ya kifurushi, tamko za utegemezi, n.k.
+
+```toml
+[package]
+name = "rust-wasm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+eth-stealth-addresses = "0.1.0"
+hex = "0.4.3"
+wasm-bindgen = "0.2.104"
+getrandom = { version = "0.2", features = ["js"] }
+```
+
+Kifurushi cha [`getrandom`](https://docs.rs/getrandom/latest/getrandom/) kinahitaji kutengeneza thamani za nasibu. Hilo haliwezi kufanywa kwa njia za kialgoriti pekee; inahitaji ufikiaji wa mchakato halisi kama chanzo cha entropy. Ufafanuzi huu unabainisha kuwa tutapata entropy hiyo kwa kuuliza kivinjari tunachotumia.
+
+```toml
+console_error_panic_hook = "0.1.7"
+```
+
+[Maktaba hii](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) inatupa ujumbe wa makosa wenye maana zaidi wakati msimbo wa WASM unapokwama na hauwezi kuendelea.
+
+```toml
+[lib]
+crate-type = ["cdylib", "rlib"]
+```
+
+Aina ya towe inayohitajika kutengeneza msimbo wa WASM.
+
+**`lib.rs`**
+
+Huu ndio msimbo halisi wa Rust.
+
+```rust
+use wasm_bindgen::prelude::*;
+```
+
+Ufafanuzi wa kuunda kifurushi cha WASM kutoka kwa Rust. Zimeandikwa [hapa](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html).
+
+```rust
+use eth_stealth_addresses::{
+    generate_stealth_meta_address,
+    generate_stealth_address,
+    compute_stealth_key
+};
+```
+
+Vitendaji tunavyohitaji kutoka kwa [maktaba ya `eth-stealth-addresses`](https://github.com/kassandraoftroy/eth-stealth-addresses).
+
+```rust
+use hex::{decode,encode};
+```
+
+Rust kwa kawaida hutumia safu za baiti ([arrays](https://doc.rust-lang.org/std/primitive.array.html)) (`[u8; <size>]`) kwa thamani. Lakini katika JavaScript, kwa kawaida tunatumia mifuatano ya heksadesimali. [Maktaba ya `hex`](https://docs.rs/hex/latest/hex/) inatutafsiria kutoka uwakilishi mmoja hadi mwingine.
+
+```rust
+#[wasm_bindgen]
+```
+
+Tengeneza viunganishi vya WASM ili kuweza kuita kitendaji hiki kutoka kwa JavaScript.
+
+```rust
+pub fn wasm_generate_stealth_meta_address() -> String {
+```
+
+Njia rahisi zaidi ya kurudisha kitu chenye sehemu nyingi ni kurudisha mfuatano wa JSON.
+
+```rust
+    let (address, spend_private_key, view_private_key) = 
+        generate_stealth_meta_address();
+```
+
+[`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) inarudisha sehemu tatu:
+
+- Anwani-meta (_K<sub>pub</sub>_ na _V<sub>pub</sub>_)
+- Ufunguo wa binafsi wa kutazama (_V<sub>priv</sub>_)
+- Ufunguo wa binafsi wa kutumia (_K<sub>priv</sub>_)
+
+Sintaksia ya [tuple](https://doc.rust-lang.org/std/primitive.tuple.html) inaturuhusu kutenganisha thamani hizo tena.
+
+```rust
+    format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}",
+        encode(address),
+        encode(view_private_key),
+        encode(spend_private_key)
+    )
+}
+```
+
+Tumia macro ya [`format!`](https://doc.rust-lang.org/std/fmt/index.html) kutengeneza mfuatano uliosimbwa kwa JSON. Tumia [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html) kubadilisha safu kuwa mifuatano ya heksi.
+
+```rust
+fn str_to_array<const N: usize>(s: &str) -> Option<[u8; N]> {
+```
+
+Kitendaji hiki hugeuza mfuatano wa heksi (unaotolewa na JavaScript) kuwa safu ya baiti. Tunaitumia kuchanganua thamani zinazotolewa na msimbo wa JavaScript. Kitendaji hiki ni kigumu kwa sababu ya jinsi Rust inavyoshughulikia safu na vekta.
+
+Usemi wa `<const N: usize>` unaitwa [generic](https://doc.rust-lang.org/book/ch10-01-syntax.html). `N` ni kigezo kinachodhibiti urefu wa safu inayorudishwa. Kitendaji hiki kwa kweli kinaitwa `str_to_array::<n>`, ambapo `n` ni urefu wa safu.
+
+Thamani ya kurudisha ni `Option<[u8; N]>`, ambayo inamaanisha safu inayorudishwa ni ya [hiari](https://doc.rust-lang.org/std/option/). Huu ni mtindo wa kawaida katika Rust kwa vitendaji ambavyo vinaweza kushindwa.
+
+Kwa mfano, tukiiita `str_to_array::10("bad060a7")`, kitendaji kinatakiwa kurudisha safu ya thamani kumi, lakini ingizo ni baiti nne tu. Kitendaji kinahitaji kushindwa, na hufanya hivyo kwa kurudisha `None`. Thamani ya kurudisha kwa `str_to_array::4("bad060a7")` itakuwa `Some<[0xba, 0xd0, 0x60, 0xa7]>`.
+
+```rust
+    // decode returns Result<Vec<u8>, _>
+    let vec = decode(s).ok()?;
+```
+
+Kitendaji cha [`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html) kinarudisha `Result<Vec<u8>, FromHexError>`. Aina ya [`Result`](https://doc.rust-lang.org/std/result/) inaweza kuwa na matokeo ya mafanikio (`Ok(value)`) au kosa (`Err(error)`).
+
+Mbinu ya `.ok()` hubadilisha `Result` kuwa `Option`, ambayo thamani yake ni thamani ya `Ok()` ikiwa imefanikiwa au `None` ikiwa sivyo. Mwishowe, [opereta ya alama ya swali](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) huacha vitendaji vya sasa na kurudisha `None` ikiwa `Option` ni tupu. Vinginevyo, hufungua thamani na kuirudisha (katika kesi hii, kugawa thamani kwa `vec`).
+
+Hii inaonekana kama njia ya kushangaza iliyopotoka ya kushughulikia makosa, lakini `Result` na `Option` huhakikisha kuwa makosa yote yanashughulikiwa, kwa njia moja au nyingine.
+
+```rust
+    if vec.len() != N { return None; }
+```
+
+Ikiwa idadi ya baiti si sahihi, hilo ni kosa, na tunarudisha `None`.
+
+```rust
+    // try_into consumes vec and attempts to make [u8; N]
+    let array: [u8; N] = vec.try_into().ok()?;
+```
+
+Rust ina aina mbili za safu. [Safu](https://doc.rust-lang.org/std/primitive.array.html) zina ukubwa usiobadilika. [Vekta](https://doc.rust-lang.org/std/vec/index.html) zinaweza kukua na kupungua. `hex::decode` inarudisha vekta, lakini maktaba ya `eth_stealth_addresses` inataka kupokea safu. [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) hubadilisha thamani kuwa aina nyingine, kwa mfano, vekta kuwa safu.
+
+```rust
+    Some(array)
+}
+```
+
+Rust haikuhitaji utumie neno kuu la [`return`](https://doc.rust-lang.org/std/keyword.return.html) unaporudisha thamani mwishoni mwa kitendaji.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option<String> {
+```
+
+Kitendaji hiki kinapokea anwani-meta ya umma, ambayo inajumuisha _V<sub>pub</sub>_ na _K<sub>pub</sub>_. Inarudisha anwani ya siri, ufunguo wa umma wa kuchapisha (_R<sub>pub</sub>_), na thamani ya skanisho ya baiti moja ambayo inaharakisha utambuzi wa anwani zilizochapishwa ambazo zinaweza kuwa za Alice.
+
+Thamani ya skanisho ni sehemu ya siri ya pamoja (_S = GR<sub>priv</sub>V<sub>priv</sub>_). Thamani hii inapatikana kwa Alice, na kuikagua ni haraka zaidi kuliko kuangalia ikiwa _f(K<sub>pub</sub>+G\*hashi(S))_ ni sawa na anwani iliyochapishwa.
+
+```rust
+    let (address, r_pub, scan) = 
+        generate_stealth_address(&str_to_array::<66>(stealth_address)?);
+```
+
+Tunatumia [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html) ya maktaba.
+
+```rust
+    format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}",
+        encode(address),
+        encode(r_pub),
+        encode(&[scan])
+    ).into()
+}
+```
+
+Andaa mfuatano wa towe uliosimbwa kwa JSON.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_compute_stealth_key(
+    address: &str, 
+    bill_pub_key: &str, 
+    view_private_key: &str,
+    spend_private_key: &str    
+) -> Option<String> {
+    .
+    .
+    .
+}
+```
+
+Kitendaji hiki hutumia [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html) ya maktaba kukokotoa ufunguo wa binafsi wa kutoa pesa kutoka kwa anwani (_R<sub>priv</sub>_). Ukokoaji huu unahitaji thamani hizi:
+
+- Anwani (_Anwani=f(P<sub>pub</sub>)_)
+- Ufunguo wa umma uliotengenezwa na Bill (_R<sub>pub</sub>_)
+- Ufunguo wa binafsi wa kutazama (_V<sub>priv</sub>_)
+- Ufunguo wa binafsi wa kutumia (_K<sub>priv</sub>_)
+
+```rust
+#[wasm_bindgen(start)]
+```
+
+[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) inabainisha kuwa kitendaji kinachotekelezwa wakati msimbo wa WASM unapowashwa.
+
+```rust
+pub fn main() {
+    console_error_panic_hook::set_once();
+}
+```
+
+Msimbo huu unabainisha kuwa towe la hitilafu litumwe kwenye kiweko cha JavaScript. Ili kuiona ikifanya kazi, tumia programu na mpe Bill anwani-meta isiyo sahihi (badilisha tu tarakimu moja ya heksadesimali). Utaona kosa hili kwenye kiweko cha JavaScript:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9:
+assertion `left == right` failed
+  left: 0
+ right: 1
+```
+
+Ikifuatiwa na ufuatiliaji wa mrundikano. Kisha mpe Bill anwani-meta sahihi, na mpe Alice anwani isiyo sahihi au ufunguo wa umma usio sahihi. Utaona kosa hili:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9:
+keys do not generate stealth address
+```
+
+Tena, ikifuatiwa na ufuatiliaji wa mrundikano.
+
+#### Kiolesura cha Mtumiaji {#ui}
+
+Kiolesura cha mtumiaji kimeandikwa kwa kutumia [React](https://react.dev/) na kinatolewa na [Vite](https://vite.dev/). Unaweza kujifunza kuzihusu kwa kutumia [mafunzo haya](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/). Hakuna haja ya [WAGMI](https://wagmi.sh/) hapa kwa sababu hatuingiliani moja kwa moja na mnyororo wa bloku au mkoba.
+
+Sehemu pekee isiyo dhahiri ya kiolesura cha mtumiaji ni muunganisho wa WASM. Hivi ndivyo inavyofanya kazi.
+
+**`vite.config.js`**
+
+Faili hili lina [usanidi wa Vite](https://vite.dev/config/).
+
+```js
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import wasm from "vite-plugin-wasm";
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), wasm()],
+})
+```
+
+Tunahitaji programu-jalizi mbili za Vite: [react](https://www.npmjs.com/package/@vitejs/plugin-react) na [wasm](https://github.com/Menci/vite-plugin-wasm#readme).
+
+**`App.jsx`**
+
+Faili hili ndilo sehemu kuu ya programu. Ni kontena linalojumuisha sehemu mbili: `Alice` na `Bill`, violesura vya watumiaji hao. Sehemu muhimu kwa WASM ni msimbo wa uanzishaji.
+
+```jsx
+import init from './rust-wasm/pkg/rust_wasm.js'
+```
+
+Tunapotumia [`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/), inatengeneza faili mbili tunazotumia hapa: faili la wasm lenye msimbo halisi (hapa, `src/rust-wasm/pkg/rust_wasm_bg.wasm`) na faili la JavaScript lenye ufafanuzi wa kuitumia (hapa, `src/rust_wasm/pkg/rust_wasm.js`). Usafirishaji chaguo-msingi wa faili hilo la JavaScript ni msimbo unaohitaji kuendeshwa ili kuanzisha WASM.
+
+```jsx
+function App() {
+    .
+    .
+    .
+  useEffect(() => {
+    const loadWasm = async () => {
+      try {
+        await init();
+        setWasmReady(true)
+      } catch (err) {
+        console.error('Error loading wasm:', err)
+        alert("Wasm error: " + err)
+      }
+    }
+
+    loadWasm()
+    }, []
+  )
+```
+
+[Ndoano ya `useEffect`](https://react.dev/reference/react/useEffect) inakuwezesha kubainisha kitendaji kinachotekelezwa wakati vigezo vya hali vinapobadilika. Hapa, orodha ya vigezo vya hali ni tupu (`[]`), kwa hivyo kitendaji hiki kinachotekelezwa mara moja tu wakati ukurasa unapopakiwa.
+
+Kitendaji cha athari lazima kirudi mara moja. Ili kutumia msimbo wa asinkroni, kama vile `init` ya WASM (ambayo inapaswa kupakia faili la `.wasm` na kwa hivyo inachukua muda) tunafafanua kitendaji cha ndani cha [`async`](https://en.wikipedia.org/wiki/Async/await) na kukiendesha bila `await`.
+
+**`Bill.jsx`**
+
+Hiki ni kiolesura cha mtumiaji cha Bill. Ina kitendo kimoja, kutengeneza anwani kulingana na anwani-meta ya siri iliyotolewa na Alice.
+
+```jsx
+import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js'
+```
+
+Mbali na usafirishaji chaguo-msingi, msimbo wa JavaScript uliotengenezwa na `wasm-pack` husafirisha kitendaji kwa kila kitendaji katika msimbo wa WASM.
+
+```jsx
+            <button onClick={() => {
+              setPublicAddress(JSON.parse(wasm_generate_stealth_address(stealthMetaAddress)))
+            }}>
+```
+
+Ili kuita vitendaji vya WASM, tunaita tu kitendaji kilichosafirishwa na faili la JavaScript lililotengenezwa na `wasm-pack`.
+
+**`Alice.jsx`**
+
+Msimbo katika `Alice.jsx` unafanana, isipokuwa kwamba Alice ana vitendo viwili:
+
+- Tengeneza anwani-meta
+- Pata ufunguo wa binafsi kwa anwani iliyochapishwa na Bill
+
+## Hitimisho {#conclusion}
+
+Anwani za siri si suluhisho la kila kitu; zinapaswa [kutumiwa ipasavyo](#go-wrong). Lakini zinapotumiwa ipasavyo, zinaweza kuwezesha faragha kwenye mnyororo wa bloku wa umma.
+
+[Tazama hapa kwa kazi zangu zaidi](https://cryptodocguy.pro/).
\ No newline at end of file
diff --git a/public/content/translations/sw/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/sw/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
new file mode 100644
index 00000000000..1c17be8894e
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
@@ -0,0 +1,314 @@
+---
+title: "The Graph: Kurekebisha uulizaji wa data wa Web3"
+description: Mnyororo wa bloku ni kama hifadhidata lakini bila SQL. Data yote ipo, lakini hakuna njia ya kuipata. Acha nikuonyeshe jinsi ya kurekebisha hili kwa kutumia The Graph na GraphQL.
+author: Markus Waas
+lang: sw
+tags:
+  [
+    "uimara",
+    "mikataba erevu",
+    "kuuliza",
+    "the graph",
+    "react"
+  ]
+skill: intermediate
+published: 2020-09-06
+source: soliditydeveloper.com
+sourceUrl: https://soliditydeveloper.com/thegraph
+---
+
+Wakati huu tutaangalia kwa undani zaidi The Graph ambayo kimsingi imekuwa sehemu ya rundo la kawaida la kuendeleza mfumo mtawanyo wa kimamlaka katika mwaka uliopita. Hebu kwanza tuone jinsi tungefanya mambo kwa njia ya jadi...
+
+## Bila The Graph... {#without-the-graph}
+
+Kwa hivyo, hebu tuchukue mfano rahisi kwa madhumuni ya kielelezo. Sote tunapenda michezo, kwa hivyo fikiria mchezo rahisi ambapo watumiaji wanaweka dau:
+
+```solidity
+pragma solidity 0.7.1;
+
+contract Game {
+    uint256 totalGamesPlayerWon = 0;
+    uint256 totalGamesPlayerLost = 0;
+    event BetPlaced(address player, uint256 value, bool hasWon);
+
+    function placeBet() external payable {
+        bool hasWon = evaluateBetForPlayer(msg.sender);
+
+        if (hasWon) {
+            (bool success, ) = msg.sender.call{ value: msg.value * 2 }('');
+            require(success, "Uhamisho umeshindikana");
+            totalGamesPlayerWon++;
+        } else {
+            totalGamesPlayerLost++;
+        }
+
+        emit BetPlaced(msg.sender, msg.value, hasWon);
+    }
+}
+```
+
+Sasa tuseme katika mfumo wetu uliotawanywa, tunataka kuonyesha jumla ya dau, jumla ya michezo iliyopotea/kushinda na pia kuisasisha kila wakati mtu anapocheza tena. Njia itakuwa:
+
+1. Leta `totalGamesPlayerWon`.
+2. Leta `totalGamesPlayerLost`.
+3. Jisajili kwa matukio ya `BetPlaced`.
+
+Tunaweza kusikiliza [tukio katika Web3](https://docs.web3js.org/api/web3/class/Contract#events) kama inavyoonyeshwa upande wa kulia, lakini inahitaji kushughulikia visa kadhaa.
+
+```solidity
+GameContract.events.BetPlaced({
+    fromBlock: 0
+}, function(error, event) { console.log(event); })
+.on('data', function(event) {
+    // tukio limetokea
+})
+.on('changed', function(event) {
+    // tukio limeondolewa tena
+})
+.on('error', function(error, receipt) {
+    // tx imekataliwa
+});
+```
+
+Sasa hii bado ni sawa kwa mfano wetu rahisi. Lakini tuseme sasa tunataka kuonyesha kiasi cha dau zilizopotea/kushinda kwa mchezaji wa sasa pekee. Basi hatuna bahati, ni bora upeleke mkataba mpya unaohifadhi thamani hizo na kuzileta. Na sasa fikiria mkataba-erevu na mfumo uliotawanywa ulio mgumu zaidi, mambo yanaweza kuwa magumu haraka.
+
+![Mtu Haulizi Hivi Hivi](./one-does-not-simply-query.jpg)
+
+Unaweza kuona jinsi hii si bora zaidi:
+
+- Haifanyi kazi kwa mikataba iliyokwisha pelekwa.
+- Gharama za ziada za gesi kwa kuhifadhi thamani hizo.
+- Inahitaji wito mwingine ili kuleta data kwa nodi ya Ethereum.
+
+![Hiyo haitoshi](./not-good-enough.jpg)
+
+Sasa hebu tuangalie suluhisho bora zaidi.
+
+## Acha nikutambulishe kwa GraphQL {#let-me-introduce-to-you-graphql}
+
+Kwanza hebu tuzungumzie GraphQL, iliyobuniwa na kutekelezwa awali na Facebook. Huenda unaifahamu muundo wa jadi wa REST API. Sasa fikiria badala yake unaweza kuandika hoja ya kuulizia data unayoitaka hasa:
+
+![GraphQL API dhidi ya REST API](./graphql.jpg)
+
+![](./graphql-query.gif)
+
+Picha hizi mbili zinaonyesha kiini cha GraphQL. Kwa hoja ya kuulizia upande wa kulia tunaweza kufafanua hasa data tunayoitaka, kwa hivyo hapo tunapata kila kitu katika ombi moja na si zaidi ya kile tunachohitaji hasa. Seva ya GraphQL hushughulikia upataji wa data yote inayohitajika, kwa hivyo ni rahisi sana kwa upande wa mtumiaji wa frontend kutumia. [Haya ni maelezo mazuri](https://www.apollographql.com/blog/graphql-explained) ya jinsi seva inavyoshughulikia hoja ya kuulizia ikiwa una nia.
+
+Sasa tukiwa na maarifa hayo, hatimaye tuingie katika ulimwengu wa mnyororo wa bloku na The Graph.
+
+## The Graph ni nini? {#what-is-the-graph}
+
+Mnyororo wa bloku ni hifadhidata iliyogatuliwa, lakini kinyume na ilivyo kawaida, hatuna lugha ya kuulizia kwa hifadhidata hii. Mbinu za kupata data ni ngumu au haziwezekani kabisa. The Graph ni itifaki iliyogatuliwa ya kuorodhesha na kuuliza data ya mnyororo wa bloku. Na huenda umekisia, inatumia GraphQL kama lugha ya kuulizia.
+
+![The Graph](./thegraph.png)
+
+Mifano daima ndiyo njia bora ya kuelewa kitu, kwa hivyo hebu tutumie The Graph kwa mfano wetu wa GameContract.
+
+## Jinsi ya kuunda Subgraph {#how-to-create-a-subgraph}
+
+Ufafanuzi wa jinsi ya kuorodhesha data unaitwa subgraph. Inahitaji vipengele vitatu:
+
+1. Manifest (`subgraph.yaml`)
+2. Schema (`schema.graphql`)
+3. Mapping (`mapping.ts`)
+
+### Manifest (`subgraph.yaml`) {#manifest}
+
+Manifest ni faili letu la usanidi na linafafanua:
+
+- ni mikataba-erevu ipi ya kuorodhesha (anwani, mtandao, ABI...)
+- ni matukio yapi ya kusikiliza
+- mambo mengine ya kusikiliza kama miito ya kukokotoa au bloku
+- kazi za ramani zinazoitwa (tazama `mapping.ts` hapa chini)
+
+Unaweza kufafanua mikataba na vidhibiti vingi hapa. Mpangilio wa kawaida ungekuwa na folda ya subgraph ndani ya mradi wa Hardhat na hifadhi yake yenyewe. Kisha unaweza kurejelea ABI kwa urahisi.
+
+Kwa sababu za urahisi unaweza pia kutaka kutumia zana ya violezo kama mustache. Kisha unaunda `subgraph.template.yaml` na kuingiza anwani kulingana na upekuzi wa hivi karibuni. Kwa mfano wa usanidi wa hali ya juu zaidi, angalia kwa mfano [repo ya Aave subgraph](https://github.com/aave/aave-protocol/tree/master/thegraph).
+
+Na nyaraka kamili zinaweza kuonekana [hapa](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest).
+
+```yaml
+specVersion: 0.0.1
+description: Kuweka Dau kwenye Ethereum
+repository: - GitHub link -
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: GameContract
+    network: mainnet
+    source:
+      address: '0x2E6454...cf77eC'
+      abi: GameContract
+      startBlock: 6175244
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.1
+      language: wasm/assemblyscript
+      entities:
+        - GameContract
+      abis:
+        - name: GameContract
+          file: ../build/contracts/GameContract.json
+      eventHandlers:
+        - event: PlacedBet(address,uint256,bool)
+          handler: handleNewBet
+      file: ./src/mapping.ts
+```
+
+### Schema (`schema.graphql`) {#schema}
+
+Schema ni ufafanuzi wa data wa GraphQL. Itakuruhusu kufafanua ni vyombo vipi vipo na aina zake. Aina zinazotumika kutoka kwa The Graph ni
+
+- Baiti
+- ID
+- String
+- Boolean
+- Int
+- BigInt
+- BigDecimal
+
+Unaweza pia kutumia vyombo kama aina kufafanua mahusiano. Katika mfano wetu tunafafanua uhusiano wa 1-kwa-wengi kutoka kwa mchezaji kwenda kwa dau. ! inamaanisha thamani haiwezi kuwa tupu. Nyaraka kamili zinaweza kuonekana [hapa](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest).
+
+```graphql
+type Bet @entity {
+  id: ID!
+  player: Player!
+  playerHasWon: Boolean!
+  time: Int!
+}
+
+type Player @entity {
+  id: ID!
+  totalPlayedCount: Int
+  hasWonCount: Int
+  hasLostCount: Int
+  bets: [Bet]!
+}
+```
+
+### Mapping (`mapping.ts`) {#mapping}
+
+Faili la ramani katika The Graph linafafanua kazi zetu zinazobadilisha matukio yanayoingia kuwa vyombo. Imeandikwa katika AssemblyScript, ambayo ni sehemu ndogo ya Typescript. Hii inamaanisha inaweza kuandaliwa kuwa WASM (WebAssembly) kwa utekelezaji bora zaidi na unaobebeka wa ramani.
+
+Utahihaji kufafanua kila kazi iliyotajwa kwenye faili ya `subgraph.yaml`, kwa hivyo kwa upande wetu tunahitaji moja tu: `handleNewBet`. Kwanza tunajaribu kupakia chombo cha Mchezaji kutoka kwa anwani ya mtumaji kama kitambulisho. Ikiwa haipo, tunaunda chombo kipya na kukijaza na thamani za kuanzia.
+
+Kisha tunaunda chombo kipya cha Dau. Kitambulisho cha hili kitakuwa `event.transaction.hash.toHex() + "-" + event.logIndex.toString()` kuhakikisha daima kuna thamani ya kipekee. Kutumia hashi pekee haitoshi kwani mtu anaweza kuwa anaita kazi ya placeBet mara kadhaa katika muamala mmoja kupitia mkataba-erevu.
+
+Mwisho, tunaweza kusasisha chombo cha Mchezaji na data yote. Safu haziwezi kusukumwa moja kwa moja, lakini zinahitaji kusasishwa kama inavyoonyeshwa hapa. Tunatumia kitambulisho kurejelea dau. Na `.save()` inahitajika mwishoni kuhifadhi chombo.
+
+Nyaraka kamili zinaweza kuonekana hapa: https://thegraph.com/docs/en/developing/creating-a-subgraph/#writing-mappings. Unaweza pia kuongeza matokeo ya kumbukumbu kwenye faili la ramani, tazama [hapa](https://thegraph.com/docs/en/subgraphs/developing/creating/graph-ts/api/#api-reference).
+
+```typescript
+import { Bet, Player } from "../generated/schema"
+import { PlacedBet } from "../generated/GameContract/GameContract"
+
+export function handleNewBet(event: PlacedBet): void {
+  let player = Player.load(event.transaction.from.toHex())
+
+  if (player == null) {
+    // unda ikiwa bado haipo
+    player = new Player(event.transaction.from.toHex())
+    player.bets = new Array<string>(0)
+    player.totalPlayedCount = 0
+    player.hasWonCount = 0
+    player.hasLostCount = 0
+  }
+
+  let bet = new Bet(
+    event.transaction.hash.toHex() + "-" + event.logIndex.toString()
+  )
+  bet.player = player.id
+  bet.playerHasWon = event.params.hasWon
+  bet.time = event.block.timestamp
+  bet.save()
+
+  player.totalPlayedCount++
+  if (event.params.hasWon) {
+    player.hasWonCount++
+  } else {
+    player.hasLostCount++
+  }
+
+  // sasisha safu kama hivi
+  let bets = player.bets
+  bets.push(bet.id)
+  player.bets = bets
+
+  player.save()
+}
+```
+
+## Kuitumia katika Frontend {#using-it-in-the-frontend}
+
+Kwa kutumia kitu kama Apollo Boost, unaweza kuunganisha kwa urahisi The Graph katika mfumo wako uliotawanywa wa React (au Apollo-Vue). Hasa unapotumia React hooks na Apollo, kupata data ni rahisi kama kuandika hoja moja ya GraphQL katika kijenzi chako. Mpangilio wa kawaida unaweza kuonekana hivi:
+
+```javascript
+// Tazama subgraphs zote: https://thegraph.com/explorer/
+const client = new ApolloClient({
+  uri: "{{ subgraphUrl }}",
+})
+
+ReactDOM.render(
+  <ApolloProvider client={client}>
+    <App />
+  </ApolloProvider>,
+  document.getElementById("root")
+)
+```
+
+Na sasa tunaweza kuandika kwa mfano hoja ya kuulizia kama hii. Hii itatuletea
+
+- mtumiaji wa sasa ameshinda mara ngapi
+- mtumiaji wa sasa amepoteza mara ngapi
+- orodha ya mihuri ya muda na dau zake zote za awali
+
+Yote katika ombi moja kwa seva ya GraphQL.
+
+```javascript
+const myGraphQlQuery = gql`
+    players(where: { id: $currentUser }) {
+      totalPlayedCount
+      hasWonCount
+      hasLostCount
+      bets {
+        time
+      }
+    }
+`
+
+const { loading, error, data } = useQuery(myGraphQlQuery)
+
+React.useEffect(() => {
+  if (!loading && !error && data) {
+    console.log({ data })
+  }
+}, [loading, error, data])
+```
+
+![Uchawi](./magic.jpg)
+
+Lakini tunakosa kipande kimoja cha mwisho cha fumbo na hiyo ni seva. Unaweza kuiendesha mwenyewe au kutumia huduma iliyohifadhiwa.
+
+## Seva ya The Graph {#the-graph-server}
+
+### Graph Explorer: Huduma iliyohifadhiwa {#graph-explorer-the-hosted-service}
+
+Njia rahisi zaidi ni kutumia huduma iliyohifadhiwa. Fuata maagizo [hapa](https://thegraph.com/docs/en/deploying/deploying-a-subgraph-to-hosted/) ili kupeleka subgraph. Kwa miradi mingi unaweza kupata subgraphs zilizopo kwenye [explorer](https://thegraph.com/explorer/).
+
+![The Graph-Explorer](./thegraph-explorer.png)
+
+### Kuendesha nodi yako mwenyewe {#running-your-own-node}
+
+Vinginevyo unaweza kuendesha nodi yako mwenyewe. Nyaraka [hapa](https://github.com/graphprotocol/graph-node#quick-start). Sababu moja ya kufanya hivi inaweza kuwa ni kutumia mtandao ambao hautumiki na huduma iliyohifadhiwa. Mitandao inayotumika sasa hivi [inaweza kupatikana hapa](https://thegraph.com/docs/en/developing/supported-networks/).
+
+## Mustakabali uliogatuliwa {#the-decentralized-future}
+
+GraphQL inasaidia mitiririko pia kwa matukio mapya yanayoingia. Hizi zinatumika kwenye grafu kupitia [Substreams](https://thegraph.com/docs/en/substreams/) ambazo kwa sasa ziko katika beta ya wazi.
+
+Mnamo [2021](https://thegraph.com/blog/mainnet-migration/) The Graph ilianza mabadiliko yake kuelekea mtandao wa uorodheshaji uliogatuliwa. Unaweza kusoma zaidi kuhusu usanifu wa mtandao huu wa uorodheshaji uliogatuliwa [hapa](https://thegraph.com/docs/en/network/explorer/).
+
+Vipengele viwili muhimu ni:
+
+1. Watumiaji huwalipa waorodheshaji kwa ajili ya hoja za kuulizia.
+2. Waorodheshaji huweka dau Tokeni za Grafu (GRT).
diff --git a/public/content/translations/sw/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/sw/developers/tutorials/token-integration-checklist/index.md
new file mode 100644
index 00000000000..6ec392799bc
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/token-integration-checklist/index.md
@@ -0,0 +1,80 @@
+---
+title: Orodha hakiki ya muunganisho wa tokeni
+description: Orodha hakiki ya mambo ya kuzingatia unaposhughulika na tokeni
+author: "Trailofbits"
+lang: sw
+tags: [ "uimara", "mikataba erevu", "usalama", "tokeni" ]
+skill: intermediate
+published: 2020-08-13
+source: Building secure contracts
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md
+---
+
+Fuata orodha hakiki hii unaposhughulika na tokeni holela. Hakikisha unaelewa hatari zinazohusiana na kila kipengee, na uthibitishe uondoaji wowote wa sheria hizi.
+
+Kwa urahisi, huduma zote za Slither [utilities](https://github.com/crytic/slither#tools) zinaweza kuendeshwa moja kwa moja kwenye anwani ya tokeni, kama vile:
+
+[Mafunzo ya kutumia Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
+
+```bash
+slither-check-erc 0xdac17f958d2ee523a2206206994597c13d831ec7 TetherToken
+```
+
+Ili kufuata orodha hakiki hii, utahitaji kuwa na matokeo haya kutoka kwa Slither kwa ajili ya tokeni:
+
+```bash
+- slither-check-erc [target] [contractName] [optional: --erc ERC_NUMBER]
+- slither [target] --print human-summary
+- slither [target] --print contract-summary
+- slither-prop . --contract ContractName # inahitaji usanidi, na matumizi ya Echidna na Manticore
+```
+
+## Mambo ya jumla ya kuzingatia {#general-considerations}
+
+- **Mkataba una ukaguzi wa usalama.** Epuka kushughulika na mikataba ambayo haina ukaguzi wa usalama. Angalia urefu wa tathmini (pia inajulikana kama “kiwango cha juhudi”), sifa ya kampuni ya usalama, na idadi na ukali wa matokeo.
+- **Umewasiliana na wasanidi programu.** Huenda ukahitaji kuarifu timu yao kuhusu tukio. Tafuta anwani zinazofaa kwenye [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts).
+- **Wana orodha ya barua pepe ya usalama kwa matangazo muhimu.** Timu yao inapaswa kuwashauri watumiaji (kama wewe!) masuala muhimu yanapopatikana au maboresho yanapotokea.
+
+## Upatanifu wa ERC {#erc-conformity}
+
+Slither inajumuisha huduma, [slither-check-erc](https://github.com/crytic/slither/wiki/ERC-Conformance), ambayo hukagua upatanifu wa tokeni na viwango vingi vinavyohusiana na ERC. Tumia slither-check-erc kukagua kuwa:
+
+- **Transfer na transferFrom hurejesha boolean.** Tokeni kadhaa hazirejeshi boolean kwenye vipengele hivi. Kwa sababu hiyo, wito wao katika mkataba unaweza kushindwa.
+- **Vipengele vya jina, desimali, na alama vipo ikiwa vinatumika.** Vipengele hivi ni vya hiari katika kiwango cha ERC20 na huenda visiwepo.
+- **Desimali hurejesha uint8.** Tokeni kadhaa hurejesha uint256 kimakosa. Ikiwa hali ni hii, hakikisha thamani iliyorejeshwa iko chini ya 255.
+- **Tokeni inapunguza [hali ya mbio ya ERC20](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729) inayojulikana.** Kiwango cha ERC20 kina hali ya mbio ya ERC20 inayojulikana ambayo lazima ipunguzwe ili kuzuia washambuliaji kuiba tokeni.
+- **Tokeni si tokeni ya ERC777 na haina wito wa kipengele cha nje katika transfer na transferFrom.** Wito wa nje katika vipengele vya uhamisho unaweza kusababisha uingiaji tena.
+
+Slither inajumuisha huduma, [slither-prop](https://github.com/crytic/slither/wiki/Property-generation), ambayo hutengeneza majaribio ya kitengo na sifa za usalama ambazo zinaweza kugundua dosari nyingi za kawaida za ERC. Tumia slither-prop kukagua kuwa:
+
+- **Mkataba unapita majaribio yote ya kitengo na sifa za usalama kutoka kwa slither-prop.** Endesha majaribio ya kitengo yaliyotengenezwa, kisha angalia sifa na [Echidna](https://github.com/crytic/echidna) na [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html).
+
+Mwishowe, kuna sifa fulani ambazo ni ngumu kuzitambua kiotomatiki. Kagua hali hizi kwa mikono:
+
+- **Transfer na transferFrom hazipaswi kuchukua ada.** Tokeni za mfumuko wa bei zinaweza kusababisha tabia zisizotarajiwa.
+- **Riba inayoweza kupatikana kutoka kwa tokeni inazingatiwa.** Baadhi ya tokeni husambaza riba kwa wamiliki wa tokeni. Riba hii inaweza kunaswa katika mkataba ikiwa haitazingatiwa.
+
+## Muundo wa mkataba {#contract-composition}
+
+- **Mkataba unaepuka utata usiohitajika.** Tokeni inapaswa kuwa mkataba rahisi; tokeni yenye msimbo tata inahitaji kiwango cha juu cha ukaguzi. Tumia [printa ya muhtasari wa binadamu](https://github.com/crytic/slither/wiki/Printer-documentation#human-summary) ya Slither kutambua msimbo tata.
+- **Mkataba unatumia SafeMath.** Mikataba isiyotumia SafeMath inahitaji kiwango cha juu cha ukaguzi. Kagua mkataba kwa mikono kwa matumizi ya SafeMath.
+- **Mkataba una vipengele vichache tu visivyohusiana na tokeni.** Vipengele visivyohusiana na tokeni huongeza uwezekano wa suala katika mkataba. Tumia [printa ya muhtasari wa mkataba](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) ya Slither kukagua kwa upana msimbo uliotumika katika mkataba.
+- **Tokeni ina anwani moja tu.** Tokeni zenye sehemu nyingi za kuingilia kwa ajili ya masasisho ya salio zinaweza kuvunja utunzaji wa vitabu vya ndani kulingana na anwani (k.m., `balances[token_address][msg.sender]` inaweza isionyeshe salio halisi).
+
+## Haki za mmiliki {#owner-privileges}
+
+- **Tokeni haiwezi kuboreshwa.** Mikataba inayoweza kuboreshwa inaweza kubadilisha sheria zake baada ya muda. Tumia [printa ya muhtasari wa binadamu](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) ya Slither kubaini kama mkataba unaweza kuboreshwa.
+- **Mmiliki ana uwezo mdogo wa kutengeneza.** Wamiliki wenye nia mbaya au walioathiriwa wanaweza kutumia vibaya uwezo wa kutengeneza. Tumia [printa ya muhtasari wa binadamu](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) ya Slither kukagua uwezo wa kutengeneza, na fikiria kukagua msimbo kwa mikono.
+- **Tokeni haiwezi kusitishwa.** Wamiliki wenye nia mbaya au walioathiriwa wanaweza kunasa mikataba inayotegemea tokeni zinazoweza kusitishwa. Tambua msimbo unaoweza kusitishwa kwa mikono.
+- **Mmiliki hawezi kuorodhesha mkataba.** Wamiliki wenye nia mbaya au walioathiriwa wanaweza kunasa mikataba inayotegemea tokeni zenye orodha nyeusi. Tambua vipengele vya orodha nyeusi kwa mikono.
+- **Timu iliyo nyuma ya tokeni inajulikana na inaweza kuwajibishwa kwa matumizi mabaya.** Mikataba yenye timu za wasanidi wasiojulikana, au iliyo katika hifadhi za kisheria inapaswa kuhitaji kiwango cha juu cha ukaguzi.
+
+## Uhaba wa tokeni {#token-scarcity}
+
+Ukaguzi wa masuala ya uhaba wa tokeni unahitaji ukaguzi wa mikono. Angalia hali hizi:
+
+- **Hakuna mtumiaji anayemiliki idadi kubwa ya usambazaji.** Ikiwa watumiaji wachache wanamiliki idadi kubwa ya tokeni, wanaweza kuathiri shughuli kulingana na ugawaji wa tokeni.
+- **Jumla ya usambazaji inatosha.** Tokeni zenye jumla ya usambazaji mdogo zinaweza kudanganywa kwa urahisi.
+- **Tokeni zinapatikana katika zaidi ya exchange chache.** Ikiwa tokeni zote ziko katika exchange moja, udukuzi wa exchange unaweza kuathiri mkataba unaotegemea tokeni.
+- **Watumiaji wanaelewa hatari zinazohusiana na fedha nyingi au mikopo ya haraka.** Mikataba inayotegemea salio la tokeni lazima izingatie kwa makini washambuliaji wenye fedha nyingi au mashambulizi kupitia mikopo ya haraka.
+- **Tokeni hairuhusu utengenezaji wa haraka**. Utengenezaji wa haraka unaweza kusababisha mabadiliko makubwa katika salio na jumla ya usambazaji, ambayo yanahitaji ukaguzi mkali na wa kina wa mfuriko katika utendaji wa tokeni.
diff --git a/public/content/translations/sw/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/public/content/translations/sw/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
new file mode 100644
index 00000000000..9174c829f3d
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -0,0 +1,314 @@
+---
+title: Uhamisho na uidhinishaji wa tokeni za ERC-20 kutoka kwa mkataba-erevu wa solidity
+description: Jenga mkataba-erevu wa DEX unaoshughulikia uhamisho na uidhinishaji wa tokeni za ERC-20 kwa kutumia Solidity.
+author: "jdourlens"
+tags: [ "mikataba erevu", "tokeni", "uimara", "erc-20" ]
+skill: intermediate
+lang: sw
+published: 2020-04-07
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/transfers-and-approval-or-erc20-tokens-from-a-solidity-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+Katika somo lililopita tulijifunza [anatomia ya tokeni ya ERC-20 katika Solidity](/developers/tutorials/understand-the-erc-20-token-smart-contract/) kwenye mnyororo wa bloku wa Ethereum. Katika makala hii tutaona jinsi tunavyoweza kutumia mkataba-erevu kuingiliana na tokeni kwa kutumia lugha ya Solidity.
+
+Kwa ajili ya mkataba-erevu huu, tutaunda mfumo halisi wa majaribio wa kubadilishana uliogatuliwa ambapo mtumiaji anaweza kubadilisha ether kwa [tokeni yetu mpya ya ERC-20](/developers/docs/standards/tokens/erc-20/) iliyotumwa.
+
+Kwa somo hili tutatumia msimbo tuliouandika katika somo lililopita kama msingi. DEX yetu itaanzisha mfano wa mkataba katika kiunda chake na kufanya shughuli za:
+
+- kubadilishana tokeni kwa ether
+- kubadilishana ether kwa tokeni
+
+Tutaanzisha msimbo wetu wa kubadilishana uliogatuliwa kwa kuongeza msimbo wetu rahisi wa ERC20:
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract ERC20Basic is IERC20 {
+
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+
+    mapping(address => uint256) balances;
+
+    mapping(address => mapping (address => uint256)) allowed;
+
+    uint256 totalSupply_ = 10 ether;
+
+
+   constructor() {
+	balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public override view returns (uint256) {
+	return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public override view returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender]-numTokens;
+        balances[receiver] = balances[receiver]+numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public override view returns (uint) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner]-numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
+        balances[buyer] = balances[buyer]+numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}
+
+
+```
+
+Mkataba-erevu wetu mpya wa DEX utatumia ERC-20 na kupata yote yaliyotolewa:
+
+```solidity
+contract DEX {
+
+    IERC20 public token;
+
+    event Bought(uint256 amount);
+    event Sold(uint256 amount);
+
+    constructor() {
+        token = new ERC20Basic();
+    }
+
+    function buy() payable public {
+        // TODO
+    }
+
+    function sell(uint256 amount) public {
+        // TODO
+    }
+
+}
+```
+
+Kwa hiyo sasa tuna DEX yetu na ina hifadhi yote ya tokeni inayopatikana. Mkataba una vipengele viwili:
+
+- `nunua`: Mtumiaji anaweza kutuma ether na kupata tokeni badala yake
+- `uza`: Mtumiaji anaweza kuamua kutuma tokeni ili kurudishiwa ether
+
+## Kipengele cha kununua {#the-buy-function}
+
+Tuandike msimbo wa kipengele cha kununua. Kwanza tutahitaji kuangalia kiasi cha ether kilichomo kwenye ujumbe na kuthibitisha kuwa mikataba inamiliki tokeni za kutosha na kwamba ujumbe una kiasi fulani cha ether ndani yake. Ikiwa mkataba unamiliki tokeni za kutosha, utamtumia mtumiaji idadi ya tokeni na kutoa tukio la `Bought`.
+
+Kumbuka kwamba tukiita kipengele cha `require` katika kisa cha kosa ether iliyotumwa itarejeshwa moja kwa moja na kurudishwa kwa mtumiaji.
+
+Ili kurahisisha mambo, tunabadilishana tokeni 1 kwa Wei 1.
+
+```solidity
+function buy() payable public {
+    uint256 amountTobuy = msg.value;
+    uint256 dexBalance = token.balanceOf(address(this));
+    require(amountTobuy > 0, "Unahitaji kutuma kiasi fulani cha ether");
+    require(amountTobuy <= dexBalance, "Hakuna tokeni za kutosha katika hifadhi");
+    token.transfer(msg.sender, amountTobuy);
+    emit Bought(amountTobuy);
+}
+```
+
+Katika hali ambapo ununuzi unafanikiwa tunapaswa kuona matukio mawili katika muamala: `Transfer` ya tokeni na tukio la `Bought`.
+
+![Matukio mawili katika muamala: Transfer na Bought](./transfer-and-bought-events.png)
+
+## Kipengele cha kuuza {#the-sell-function}
+
+Kipengele kinachohusika na uuzaji kwanza kitahitaji mtumiaji awe ameidhinisha kiasi kwa kuita kipengele cha `approve` kabla. Kuidhinisha uhamisho kunahitaji tokeni ya ERC20Basic iliyoanzishwa na DEX iitwe na mtumiaji. Hii inaweza kufikiwa kwa kwanza kuita kipengele cha `token()` cha mkataba wa DEX ili kupata anwani ambapo DEX ilituma mkataba wa ERC20Basic unaoitwa `token`. Kisha tunaunda mfano wa mkataba huo katika kipindi chetu na kuita kipengele chake cha `approve`. Kisha tunaweza kuita kipengele cha `sell` cha DEX na kubadilisha tokeni zetu na kupata ether. Kwa mfano, hivi ndivyo inavyoonekana katika kipindi cha maingiliano cha brownie:
+
+```python
+#### Python katika koni ya maingiliano ya brownie...
+
+# tuma DEX
+dex = DEX.deploy({'from':account1})
+
+# ita kipengele cha kununua ili kubadilisha ether kwa tokeni
+# 1e18 ni ether 1 katika wei
+dex.buy({'from': account2, 1e18})
+
+# pata anwani ya utumaji ya tokeni ya ERC20
+# ambayo ilitumwa wakati wa uundaji wa mkataba wa DEX
+# dex.token() inarudisha anwani iliyotumwa ya tokeni
+token = ERC20Basic.at(dex.token())
+
+# ita kipengele cha kuidhinisha cha tokeni
+# idhinisha anwani ya dex kama mtumiaji
+# na ni tokeni zako ngapi inaruhusiwa kutumia
+token.approve(dex.address, 3e18, {'from':account2})
+
+```
+
+Kisha kipengele cha `sell` kinapoitwa, tutaangalia kama uhamisho kutoka kwa anwani ya mpigaji kwenda kwa anwani ya mkataba ulifanikiwa na kisha tutatuma Ethers kurudi kwa anwani ya mpigaji.
+
+```solidity
+function sell(uint256 amount) public {
+    require(amount > 0, "Unahitaji kuuza angalau tokeni kadhaa");
+    uint256 allowance = token.allowance(msg.sender, address(this));
+    require(allowance >= amount, "Angalia ruhusa ya tokeni");
+    token.transferFrom(msg.sender, address(this), amount);
+    payable(msg.sender).transfer(amount);
+    emit Sold(amount);
+}
+```
+
+Ikiwa kila kitu kitafanya kazi unapaswa kuona matukio 2 (`Transfer` na `Sold`) katika muamala na salio lako la tokeni na salio la ether likisasishwa.
+
+![Matukio mawili katika muamala: Transfer na Sold](./transfer-and-sold-events.png)
+
+<Divider />
+
+Kutoka kwa somo hili tumeona jinsi ya kuangalia salio na ruhusa ya tokeni ya ERC-20 na pia jinsi ya kuita `Transfer` na `TransferFrom` ya mkataba-erevu wa ERC20 kwa kutumia kiolesura.
+
+Mara tu unapofanya muamala tuna somo la JavaScript la [kusubiri na kupata maelezo kuhusu miamala](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/) ambayo ilifanywa kwa mkataba wako na [somo la kusimbua matukio yaliyotokana na uhamisho wa tokeni au matukio mengine yoyote](https://ethereumdev.io/how-to-decode-event-logs-in-javascript-using-abi-decoder/) mradi tu una ABI.
+
+Huu hapa msimbo kamili wa somo:
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract ERC20Basic is IERC20 {
+
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+
+    mapping(address => uint256) balances;
+
+    mapping(address => mapping (address => uint256)) allowed;
+
+    uint256 totalSupply_ = 10 ether;
+
+
+   constructor() {
+	balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public override view returns (uint256) {
+	return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public override view returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender]-numTokens;
+        balances[receiver] = balances[receiver]+numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public override view returns (uint) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner]-numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
+        balances[buyer] = balances[buyer]+numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}
+
+
+contract DEX {
+
+    event Bought(uint256 amount);
+    event Sold(uint256 amount);
+
+
+    IERC20 public token;
+
+    constructor() {
+        token = new ERC20Basic();
+    }
+
+    function buy() payable public {
+        uint256 amountTobuy = msg.value;
+        uint256 dexBalance = token.balanceOf(address(this));
+        require(amountTobuy > 0, "Unahitaji kutuma kiasi fulani cha ether");
+        require(amountTobuy <= dexBalance, "Hakuna tokeni za kutosha katika hifadhi");
+        token.transfer(msg.sender, amountTobuy);
+        emit Bought(amountTobuy);
+    }
+
+    function sell(uint256 amount) public {
+        require(amount > 0, "Unahitaji kuuza angalau tokeni kadhaa");
+        uint256 allowance = token.allowance(msg.sender, address(this));
+        require(allowance >= amount, "Angalia ruhusa ya tokeni");
+        token.transferFrom(msg.sender, address(this), amount);
+        payable(msg.sender).transfer(amount);
+        emit Sold(amount);
+    }
+
+}
+```
diff --git a/public/content/translations/sw/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md b/public/content/translations/sw/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
new file mode 100644
index 00000000000..7ceedaa777a
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
@@ -0,0 +1,177 @@
+---
+title: Elewa mkataba-erevu wa tokeni ya ERC-20
+description: Jifunze jinsi ya kutekeleza kiwango cha tokeni cha ERC-20 kwa mfano kamili wa mkataba-erevu wa Solidity na maelezo.
+author: "jdourlens"
+tags: [ "mikataba erevu", "tokeni", "uimara", "erc-20" ]
+skill: beginner
+lang: sw
+published: 2020-04-05
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/understand-the-erc20-token-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+Moja ya [viwango muhimu vya mkataba-erevu](/developers/docs/standards/) kwenye Ethereum inajulikana kama [ERC-20](/developers/docs/standards/tokens/erc-20/), ambayo imeibuka kama kiwango cha kiufundi kinachotumiwa kwa mikataba yote erevu kwenye mnyororo wa bloku wa Ethereum kwa utekelezaji wa tokeni zinazoweza kubadilishwa.
+
+ERC-20 inafafanua orodha ya kawaida ya sheria ambazo tokeni zote za Ethereum zinazoweza kubadilishwa zinapaswa kuzingatia. Kwa hivyo, kiwango hiki cha tokeni huwawezesha wasanidi programu wa aina zote kutabiri kwa usahihi jinsi tokeni mpya zitakavyofanya kazi ndani ya mfumo mkuu wa Ethereum. Hii hurahisisha kazi za wasanidi programu, kwa sababu wanaweza kuendelea na kazi zao, wakijua kwamba kila mradi mpya hautahitaji kufanywa upya kila wakati tokeni mpya inapotolewa, mradi tu tokeni inafuata sheria.
+
+Hizi hapa, zikiwasilishwa kama kiolesura, ni kazi ambazo ERC-20 lazima itekeleze. Ikiwa huna uhakika kuhusu kiolesura ni nini: angalia makala yetu kuhusu [upangaji programu wa OOP katika Solidity](https://ethereumdev.io/inheritance-in-solidity-contracts-are-classes/).
+
+```solidity
+pragma solidity ^0.6.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+```
+
+Haya ni maelezo ya mstari kwa mstari ya kila kazi inafanya nini. Baada ya hili tutawasilisha utekelezaji rahisi wa tokeni ya ERC-20.
+
+## Vipata {#getters}
+
+```solidity
+function totalSupply() external view returns (uint256);
+```
+
+Hurejesha kiasi cha tokeni zilizopo. Kazi hii ni kipata na haibadilishi hali ya mkataba. Kumbuka kuwa hakuna 'floats' katika Solidity. Kwa hivyo tokeni nyingi hutumia desimali 18 na zitarejesha jumla ya usambazaji na matokeo mengine kama ifuatavyo 1000000000000000000 kwa tokeni 1. Sio kila tokeni ina desimali 18 na hili ni jambo unalopaswa kulizingatia sana unaposhughulika na tokeni.
+
+```solidity
+function balanceOf(address account) external view returns (uint256);
+```
+
+Hurejesha kiasi cha tokeni zinazomilikiwa na anwani (`account`). Kazi hii ni kipata na haibadilishi hali ya mkataba.
+
+```solidity
+function allowance(address owner, address spender) external view returns (uint256);
+```
+
+Kiwango cha ERC-20 kinaruhusu anwani kutoa ruhusa kwa anwani nyingine ili iweze kuchukua tokeni kutoka kwayo. Kipata hiki hurejesha idadi iliyobaki ya tokeni ambazo `spender` ataruhusiwa kutumia kwa niaba ya `owner`. Kazi hii ni kipata na haibadilishi hali ya mkataba na inapaswa kurejesha 0 kama chaguo-msingi.
+
+## Kazi {#functions}
+
+```solidity
+function transfer(address recipient, uint256 amount) external returns (bool);
+```
+
+Huhamisha `amount` ya tokeni kutoka kwa anwani ya mwitaji wa kazi (`msg.sender`) hadi kwa anwani ya mpokeaji. Kazi hii hutoa tukio la `Transfer` lililofafanuliwa baadaye. Inarejesha 'true' ikiwa uhamisho uliwezekana.
+
+```solidity
+function approve(address spender, uint256 amount) external returns (bool);
+```
+
+Weka kiasi cha `allowance` ambacho `spender` anaruhusiwa kuhamisha kutoka kwenye salio la mwitaji wa kazi (`msg.sender`). Kazi hii hutoa tukio la `Approval`. Kazi hurejesha ikiwa ruhusa iliwekwa kwa mafanikio.
+
+```solidity
+function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+```
+
+Huhamisha `amount` ya tokeni kutoka kwa `sender` kwenda `recipient` kwa kutumia utaratibu wa ruhusa. Kisha `amount` inakatwa kutoka kwa ruhusa ya mwitaji. Kazi hii hutoa tukio la `Transfer`.
+
+## Matukio {#events}
+
+```solidity
+event Transfer(address indexed from, address indexed to, uint256 value);
+```
+
+Tukio hili hutolewa wakati kiasi cha tokeni (value) kinatumwa kutoka anwani ya `from` kwenda anwani ya `to`.
+
+Katika kisa cha kutengeneza tokeni mpya, uhamisho huwa `kutoka` kwa anwani ya 0x00..0000 huku katika kisa cha kuchoma tokeni uhamisho huwa `kwenda` 0x00..0000.
+
+```solidity
+event Approval(address indexed owner, address indexed spender, uint256 value);
+```
+
+Tukio hili hutolewa wakati kiasi cha tokeni (`value`) kimeidhinishwa na `owner` kutumiwa na `spender`.
+
+## Utekelezaji wa msingi wa tokeni za ERC-20 {#a-basic-implementation-of-erc-20-tokens}
+
+Huu ndio msimbo rahisi zaidi wa kutumia kama msingi wa tokeni yako ya ERC-20:
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract ERC20Basic is IERC20 {
+
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+
+    mapping(address => uint256) balances;
+
+    mapping(address => mapping (address => uint256)) allowed;
+
+    uint256 totalSupply_ = 10 ether;
+
+
+   constructor() {
+	balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public override view returns (uint256) {
+	return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public override view returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender]-numTokens;
+        balances[receiver] = balances[receiver]+numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public override view returns (uint) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner]-numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
+        balances[buyer] = balances[buyer]+numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}
+```
+
+Utekelezaji mwingine bora wa kiwango cha tokeni cha ERC-20 ni [utekelezaji wa ERC-20 wa OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
diff --git a/public/content/translations/sw/developers/tutorials/uniswap-v2-annotated-code/index.md b/public/content/translations/sw/developers/tutorials/uniswap-v2-annotated-code/index.md
new file mode 100644
index 00000000000..87aa459316a
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -0,0 +1,1970 @@
+---
+title: "Muongozo wa Mkataba wa Uniswap-v2"
+description: Mkataba wa Uniswap-v2 unafanyaje kazi? Kwa nini umeandikwa kwa njia hiyo?
+author: Ori Pomerantz
+tags: [ "uimara" ]
+skill: intermediate
+published: 2021-05-01
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+[Uniswap v2](https://app.uniswap.org/whitepaper.pdf) inaweza kuunda soko la kubadilishana kati ya tokeni zozote mbili za ERC-20. Katika makala haya tutapitia msimbo chanzo wa mikataba inayotekeleza itifaki hii na kuona kwa nini imeandikwa kwa njia hii.
+
+### Uniswap Inafanya Nini? {#what-does-uniswap-do}
+
+Kimsingi, kuna aina mbili za watumiaji: watoa huduma za ukwasi na wafanyabiashara.
+
+_Watoa huduma za ukwasi_ huweka kwenye bwawa tokeni mbili ambazo zinaweza kubadilishwa (tutaziita **Token0** na **Token1**). Kwa malipo, wanapokea tokeni ya tatu inayowakilisha umiliki wa sehemu ya bwawa inayoitwa _tokeni ya ukwasi_.
+
+_Wafanyabiashara_ hutuma aina moja ya tokeni kwenye bwawa na kupokea nyingine (kwa mfano, tuma **Token0** na pokea **Token1**) kutoka kwenye bwawa lililotolewa na watoa huduma za ukwasi. Kiwango cha ubadilishaji huamuliwa na idadi linganishi ya **Token0** na **Token1** ambazo bwawa linazo. Kwa kuongezea, bwawa huchukua asilimia ndogo kama tuzo kwa bwawa la ukwasi.
+
+Watoa huduma za ukwasi wanapotaka mali zao zirudishwe wanaweza kuondoa tokeni za bwawa na kupokea tokeni zao, ikijumuisha sehemu yao ya tuzo.
+
+[Bofya hapa kwa maelezo kamili](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/swaps/).
+
+### Kwa nini v2? Kwa nini si v3? {#why-v2}
+
+[Uniswap v3](https://app.uniswap.org/whitepaper-v3.pdf) ni boresho ambalo ni changamano zaidi kuliko v2. Ni rahisi kujifunza v2 kwanza na kisha kwenda v3.
+
+### Mikataba ya Msingi dhidi ya Mikataba ya Pembeni {#contract-types}
+
+Uniswap v2 imegawanywa katika sehemu mbili, msingi na pembeni. Mgawanyiko huu unaruhusu mikataba ya msingi, ambayo inashikilia mali na kwa hivyo _lazima_ iwe salama, kuwa rahisi na rahisi kukaguliwa. Utendaji wote wa ziada unaohitajika na wafanyabiashara unaweza kutolewa na mikataba ya pembeni.
+
+## Mtiririko wa Data na Udhibiti {#flows}
+
+Huu ndio mtiririko wa data na udhibiti unaotokea unapofanya vitendo vikuu vitatu vya Uniswap:
+
+1. Kubadilisha kati ya tokeni tofauti
+2. Ongeza ukwasi kwenye soko na uzawadiwe kwa tokeni za ukwasi za ERC-20 za ubadilishaji wa jozi
+3. Ondoa tokeni za ukwasi za ERC-20 na urejeshewe tokeni za ERC-20 ambazo ubadilishaji wa jozi unaruhusu wafanyabiashara kubadilishana
+
+### Badilisha {#swap-flow}
+
+Huu ndio mtiririko wa kawaida zaidi, unaotumiwa na wafanyabiashara:
+
+#### Mwitaji {#caller}
+
+1. Ipe akaunti ya pembeni ruhusa ya kiasi kitakachobadilishwa.
+2. Piga simu mojawapo ya kazi nyingi za kubadilisha za mkataba wa pembeni (ipi inategemea kama ETH inahusika au la, kama mfanyabiashara anabainisha kiasi cha tokeni za kuweka au kiasi cha tokeni za kurejeshewa, n.k).
+   Kila kazi ya kubadilisha inakubali `path`, safu ya mabadilishano ya kupitia.
+
+#### Katika mkataba wa pembeni (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02-sol}
+
+3. Tambua kiasi kinachohitaji kufanyiwa biashara kwenye kila ubadilishaji kando ya njia.
+4. Inarudia juu ya njia. Kwa kila ubadilishaji njiani inatuma tokeni ya kuingiza na kisha inapiga simu kazi ya `swap` ya ubadilishaji.
+   Katika hali nyingi anwani lengwa ya tokeni ni ubadilishaji wa jozi unaofuata kwenye njia. Katika ubadilishaji wa mwisho ni anwani iliyotolewa na mfanyabiashara.
+
+#### Katika mkataba wa msingi (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. Thibitisha kuwa mkataba wa msingi haufanyiwi udanganyifu na unaweza kudumisha ukwasi wa kutosha baada ya ubadilishaji.
+
+6. Angalia ni tokeni ngapi za ziada tunazo pamoja na akiba zinazojulikana. Kiasi hicho ni idadi ya tokeni za kuingiza tulizopokea ili kubadilisha.
+7. Tuma tokeni za matokeo kwenda lengwa.
+8. Piga simu `_update` ili kusasisha kiasi cha akiba
+
+#### Rudi kwenye mkataba wa pembeni (UniswapV2Router02.sol) {#back-in-the-periphery-contract-uniswapv2router02-sol}
+
+9. Fanya usafi wowote unaohitajika (kwa mfano, ondoa tokeni za WETH ili kurudisha ETH kumtumia mfanyabiashara)
+
+### Ongeza Ukwasi {#add-liquidity-flow}
+
+#### Mwitaji {#caller-2}
+
+1. Ipe akaunti ya pembeni ruhusa ya kiasi kitakachoongezwa kwenye bwawa la ukwasi.
+2. Piga simu mojawapo ya kazi za `addLiquidity` za mkataba wa pembeni.
+
+#### Katika mkataba wa pembeni (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-2}
+
+3. Unda ubadilishaji mpya wa jozi ikiwa ni lazima
+4. Ikiwa kuna ubadilishaji wa jozi uliopo, hesabu kiasi cha tokeni za kuongeza. Hii inatakiwa kuwa na thamani sawa kwa tokeni zote mbili, kwa hiyo uwiano sawa wa tokeni mpya kwa tokeni zilizopo.
+5. Angalia kama kiasi kinakubalika (wapigaji simu wanaweza kubainisha kiasi cha chini ambacho hawapendi kuongeza ukwasi chini yake)
+6. Piga simu mkataba wa msingi.
+
+#### Katika mkataba wa msingi (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}
+
+7. Zalisha tokeni za ukwasi na uzitumie kwa mwitaji
+8. Piga simu `_update` ili kusasisha kiasi cha akiba
+
+### Ondoa Ukwasi {#remove-liquidity-flow}
+
+#### Mwitaji {#caller-3}
+
+1. Ipe akaunti ya pembeni ruhusa ya tokeni za ukwasi zitakazoondolewa badala ya tokeni za msingi.
+2. Piga simu mojawapo ya kazi za `removeLiquidity` za mkataba wa pembeni.
+
+#### Katika mkataba wa pembeni (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-3}
+
+3. Tuma tokeni za ukwasi kwenye ubadilishaji wa jozi
+
+#### Katika mkataba wa msingi (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-3}
+
+4. Tuma kwenye anwani lengwa tokeni za msingi kulingana na tokeni zilizoondolewa. Kwa mfano ikiwa kuna tokeni 1000 za A kwenye bwawa, tokeni 500 za B, na tokeni 90 za ukwasi, na tunapokea tokeni 9 za kuondoa, tunaondoa 10% ya tokeni za ukwasi kwa hiyo tunamrudishia mtumiaji tokeni 100 za A na tokeni 50 za B.
+5. Ondoa tokeni za ukwasi
+6. Piga simu `_update` ili kusasisha kiasi cha akiba
+
+## Mikataba ya Msingi {#core-contracts}
+
+Hii ni mikataba salama ambayo inashikilia ukwasi.
+
+### UniswapV2Pair.sol {#UniswapV2Pair}
+
+[Mkataba huu](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol) unatekeleza bwawa halisi linalobadilisha tokeni. Ni utendaji mkuu wa Uniswap.
+
+```solidity
+pragma solidity =0.5.16;
+
+import './interfaces/IUniswapV2Pair.sol';
+import './UniswapV2ERC20.sol';
+import './libraries/Math.sol';
+import './libraries/UQ112x112.sol';
+import './interfaces/IERC20.sol';
+import './interfaces/IUniswapV2Factory.sol';
+import './interfaces/IUniswapV2Callee.sol';
+```
+
+Hizi zote ni miingiliano ambayo mkataba unahitaji kujua kuihusu, ama kwa sababu mkataba unazitekeleza (`IUniswapV2Pair` na `UniswapV2ERC20`) au kwa sababu inapiga simu mikataba inayozitekeleza.
+
+```solidity
+contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
+```
+
+Mkataba huu unarithi kutoka `UniswapV2ERC20`, ambayo hutoa kazi za ERC-20 kwa tokeni za ukwasi.
+
+```solidity
+    using SafeMath  for uint;
+```
+
+Maktaba ya [SafeMath library](https://docs.openzeppelin.com/contracts/2.x/api/math) inatumika kuepuka kufurika na kupungua. Hii ni muhimu kwa sababu vinginevyo tunaweza kuishia na hali ambapo thamani inapaswa kuwa `-1`, lakini badala yake ni `2^256-1`.
+
+```solidity
+    using UQ112x112 for uint224;
+```
+
+Mahesabu mengi katika mkataba wa bwawa yanahitaji sehemu. Hata hivyo, sehemu hazitumiki na EVM.
+Suluhisho ambalo Uniswap ilipata ni kutumia thamani za biti 224, na biti 112 kwa sehemu ya nambari kamili, na biti 112 kwa sehemu. Kwa hivyo `1.0` inawakilishwa kama `2^112`, `1.5` inawakilishwa kama `2^112 + 2^111`, n.k.
+
+Maelezo zaidi kuhusu maktaba hii yanapatikana [baadaye kwenye hati](#FixedPoint).
+
+#### Vigezo {#pair-vars}
+
+```solidity
+    uint public constant MINIMUM_LIQUIDITY = 10**3;
+```
+
+Ili kuepuka visa vya kugawanya kwa sifuri, kuna idadi ya chini ya tokeni za ukwasi ambazo zipo kila wakati (lakini zinamilikiwa na akaunti sifuri). Nambari hiyo ni **MINIMUM_LIQUIDITY**, elfu moja.
+
+```solidity
+    bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
+```
+
+Hiki ni kiteuzi cha ABI kwa ajili ya kazi ya uhamisho wa ERC-20. Inatumika kuhamisha tokeni za ERC-20 katika akaunti mbili za tokeni.
+
+```solidity
+    address public factory;
+```
+
+Huu ni mkataba wa kiwanda uliounda bwawa hili. Kila bwawa ni ubadilishanaji kati ya tokeni mbili za ERC-20, kiwanda ni sehemu kuu inayounganisha mabwawa haya yote.
+
+```solidity
+    address public token0;
+    address public token1;
+```
+
+Kuna anwani za mikataba ya aina mbili za tokeni za ERC-20 zinazoweza kubadilishwa na bwawa hili.
+
+```solidity
+    uint112 private reserve0;           // hutumia nafasi moja ya kuhifadhi, inayopatikana kupitia getReserves
+    uint112 private reserve1;           // hutumia nafasi moja ya kuhifadhi, inayopatikana kupitia getReserves
+```
+
+Akiba ambayo bwawa lina nayo kwa kila aina ya tokeni. Tunadhania kuwa zote mbili zinawakilisha kiasi sawa cha thamani, na kwa hivyo kila token0 ina thamani ya reserve1/reserve0 ya tokeni1.
+
+```solidity
+    uint32  private blockTimestampLast; // hutumia nafasi moja ya kuhifadhi, inayopatikana kupitia getReserves
+```
+
+Mhuri wa muda wa kizuizi cha mwisho ambapo ubadilishanaji ulitokea, unaotumika kufuatilia viwango vya ubadilishanaji kwa muda.
+
+Moja ya gharama kubwa zaidi za gesi za mikataba ya Ethereum ni hifadhi, ambayo huendelea kutoka simu moja ya mkataba hadi nyingine. Kila seli ya hifadhi ina urefu wa biti 256. Kwa hivyo vigezo vitatu, `reserve0`, `reserve1`, na `blockTimestampLast`, vimepangwa kwa namna ambayo thamani moja ya hifadhi inaweza kujumuisha zote tatu (112+112+32=256).
+
+```solidity
+    uint public price0CumulativeLast;
+    uint public price1CumulativeLast;
+```
+
+Vigezo hivi hushikilia gharama limbikizi kwa kila tokeni (kila moja kwa mujibu wa nyingine). Vinaweza kutumika kuhesabu kiwango cha wastani cha ubadilishanaji kwa kipindi cha muda.
+
+```solidity
+    uint public kLast; // reserve0 * reserve1, kuanzia mara tu baada ya tukio la hivi karibuni la ukwasi
+```
+
+Njia ambayo ubadilishanaji wa jozi huamua kiwango cha ubadilishanaji kati ya token0 na token1 ni kuweka zidishi la akiba mbili kuwa la kudumu wakati wa biashara. `kLast` ni thamani hii. Inabadilika wakati mtoa huduma wa ukwasi anaweka au kutoa tokeni, na huongezeka kidogo kwa sababu ya ada ya soko ya 0.3%.
+
+Huu ni mfano rahisi. Kumbuka kuwa kwa ajili ya kurahisisha, jedwali lina tarakimu tatu tu baada ya nukta ya desimali, na tunapuuza ada ya biashara ya 0.3% kwa hivyo nambari si sahihi.
+
+| Tukio                                                                                          |                  reserve0 |                  reserve1 | reserve0 \* reserve1 | Kiwango cha wastani cha ubadilishaji (token1 / token0) |
+| ---------------------------------------------------------------------------------------------- | ------------------------: | ------------------------: | -------------------: | ------------------------------------------------------------------------- |
+| Usanidi wa awali                                                                               | 1,000.000 | 1,000.000 |            1,000,000 |                                                                           |
+| Mfanyabiashara A anabadilisha tokeni 50 za token0 kwa tokeni 47.619 za token1  | 1,050.000 |   952.381 |            1,000,000 | 0.952                                                     |
+| Mfanyabiashara B anabadilisha tokeni 10 za token0 kwa tokeni 8.984 za token1   | 1,060.000 |   943.396 |            1,000,000 | 0.898                                                     |
+| Mfanyabiashara C anabadilisha tokeni 40 za token0 kwa tokeni 34.305 za token1  | 1,100.000 |   909.090 |            1,000,000 | 0.858                                                     |
+| Mfanyabiashara D anabadilisha tokeni 100 za token1 kwa tokeni 109.01 za token0 |   990.990 | 1,009.090 |            1,000,000 | 0.917                                                     |
+| Mfanyabiashara E anabadilisha tokeni 10 za token0 kwa tokeni 10.079 za token1  | 1,000.990 |   999.010 |            1,000,000 | 1.008                                                     |
+
+Wafanyabiashara wanapotoa token0 zaidi, thamani linganishi ya token1 huongezeka, na kinyume chake, kulingana na usambazaji na mahitaji.
+
+#### Funga {#pair-lock}
+
+```solidity
+    uint private unlocked = 1;
+```
+
+Kuna aina ya udhaifu wa usalama unaotokana na [matumizi mabaya ya kuingia tena](https://medium.com/coinmonks/ethernaut-lvl-10-re-entrancy-walkthrough-how-to-abuse-execution-ordering-and-reproduce-the-dao-7ec88b912c14). Uniswap inahitaji kuhamisha tokeni za kiholela za ERC-20, ambayo inamaanisha kupiga simu mikataba ya ERC-20 ambayo inaweza kujaribu kutumia vibaya soko la Uniswap linaloziita.
+Kwa kuwa na kigezo cha `unlocked` kama sehemu ya mkataba, tunaweza kuzuia kazi zisiitwe wakati zinaendeshwa (ndani ya muamala mmoja).
+
+```solidity
+    modifier lock() {
+```
+
+Kazi hii ni [kirekebishaji](https://docs.soliditylang.org/en/v0.8.3/contracts.html#function-modifiers), kazi inayozunguka kazi ya kawaida ili kubadilisha tabia yake kwa namna fulani.
+
+```solidity
+        require(unlocked == 1, 'UniswapV2: LOCKED');
+        unlocked = 0;
+```
+
+Ikiwa `unlocked` ni sawa na moja, iweke sifuri. Ikiwa tayari ni sifuri, rudisha simu, ifanye ishindwe.
+
+```solidity
+        _;
+```
+
+Katika kirekebishaji `_;` ni simu ya awali ya kazi (pamoja na vigezo vyote). Hapa inamaanisha kuwa simu ya kazi inatokea tu ikiwa `unlocked` ilikuwa moja wakati ilipoitwa, na wakati inaendeshwa thamani ya `unlocked` ni sifuri.
+
+```solidity
+        unlocked = 1;
+    }
+```
+
+Baada ya kazi kuu kurudi, toa kufuli.
+
+#### Mbalimbali kazi {#pair-misc}
+
+```solidity
+    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
+        _reserve0 = reserve0;
+        _reserve1 = reserve1;
+        _blockTimestampLast = blockTimestampLast;
+    }
+```
+
+Kazi hii huwapa wapigaji simu hali ya sasa ya ubadilishanaji. Ona kuwa kazi za Solidity [zinaweza kurudisha thamani nyingi](https://docs.soliditylang.org/en/v0.8.3/contracts.html#returning-multiple-values).
+
+```solidity
+    function _safeTransfer(address token, address to, uint value) private {
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
+```
+
+Kazi hii ya ndani huhamisha kiasi cha tokeni za ERC20 kutoka kwenye ubadilishanaji kwenda kwa mtu mwingine. `SELECTOR` inabainisha kuwa kazi tunayoita ni `transfer(address,uint)` (tazama ufafanuzi hapo juu).
+
+Ili kuepuka kulazimika kuingiza kiolesura cha kazi ya tokeni, tunatengeneza simu "kwa mikono" kwa kutumia moja ya [kazi za ABI](https://docs.soliditylang.org/en/v0.8.3/units-and-global-variables.html#abi-encoding-and-decoding-functions).
+
+```solidity
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
+    }
+```
+
+Kuna njia mbili ambazo simu ya uhamisho ya ERC-20 inaweza kuripoti kushindwa:
+
+1. Rejesha. Ikiwa simu ya mkataba wa nje inarejeshwa, basi thamani ya kurudi ya boolean ni `false`
+2. Maliza kawaida lakini ripoti kushindwa. Katika hali hiyo bafa ya thamani ya kurudi ina urefu usio wa sifuri, na inapopambanuliwa kama thamani ya boolean ni `false`
+
+Ikiwa mojawapo ya masharti haya yatatokea, rejesha.
+
+#### Matukio {#pair-events}
+
+```solidity
+    event Mint(address indexed sender, uint amount0, uint amount1);
+    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
+```
+
+Matukio haya mawili hutolewa wakati mtoa huduma wa ukwasi anapoweka ukwasi (`Mint`) au anapoutoa (`Burn`). Katika hali zote mbili, kiasi cha token0 na token1 kinachowekwa au kutolewa ni sehemu ya tukio, pamoja na utambulisho wa akaunti iliyotuita (`sender`). Katika kesi ya uondoaji, tukio pia linajumuisha lengo lililopokea tokeni (`to`), ambalo linaweza lisiwe sawa na mtumaji.
+
+```solidity
+    event Swap(
+        address indexed sender,
+        uint amount0In,
+        uint amount1In,
+        uint amount0Out,
+        uint amount1Out,
+        address indexed to
+    );
+```
+
+Tukio hili hutolewa wakati mfanyabiashara anapobadilisha tokeni moja kwa nyingine. Tena, mtumaji na lengo huenda wasiwe sawa.
+Kila tokeni inaweza kutumwa kwenye ubadilishanaji, au kupokelewa kutoka kwake.
+
+```solidity
+    event Sync(uint112 reserve0, uint112 reserve1);
+```
+
+Mwishowe, `Sync` hutolewa kila wakati tokeni zinapoongezwa au kutolewa, bila kujali sababu, ili kutoa taarifa za hivi karibuni za akiba (na kwa hivyo kiwango cha ubadilishanaji).
+
+#### Kazi za Usanidi {#pair-setup}
+
+Kazi hizi zinapaswa kuitwa mara moja wakati ubadilishanaji mpya wa jozi unapowekwa.
+
+```solidity
+    constructor() public {
+        factory = msg.sender;
+    }
+```
+
+Kiunda huhakikisha tutafuatilia anwani ya kiwanda kilichounda jozi. Taarifa hii inahitajika kwa `initialize` na kwa ada ya kiwanda (ikiwa ipo)
+
+```solidity
+    // inaitwa mara moja na kiwanda wakati wa uwekaji
+    function initialize(address _token0, address _token1) external {
+        require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // ukaguzi wa kutosha
+        token0 = _token0;
+        token1 = _token1;
+    }
+```
+
+Kazi hii inaruhusu kiwanda (na kiwanda pekee) kubainisha tokeni mbili za ERC-20 ambazo jozi hii itabadilishana.
+
+#### Kazi za Kusasisha za Ndani {#pair-update-internal}
+
+##### \_update
+
+```solidity
+    // sasisha akiba na, kwa simu ya kwanza kwa kila kizuizi, vikusanya bei
+    function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
+```
+
+Kazi hii inaitwa kila wakati tokeni zinapowekwa au kutolewa.
+
+```solidity
+        require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
+```
+
+Ikiwa ama balance0 au balance1 (uint256) ni ya juu kuliko uint112(-1) (=2^112-1) (hivyo inafurika na kurudi nyuma hadi 0 inapobadilishwa kuwa uint112) kataa kuendelea na \_update ili kuzuia kufurika. Kwa tokeni ya kawaida inayoweza kugawanywa katika vitengo 10^18, hii inamaanisha kila ubadilishanaji unazuiliwa kwa takriban 5.1\*10^15 ya kila tokeni. Hadi sasa hilo halijakuwa tatizo.
+
+```solidity
+        uint32 blockTimestamp = uint32(block.timestamp % 2**32);
+        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // kufurika kunatakikana
+        if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
+```
+
+Ikiwa muda uliopita sio sifuri, inamaanisha sisi ni muamala wa kwanza wa ubadilishanaji kwenye kizuizi hiki. Katika hali hiyo, tunahitaji kusasisha vikusanya gharama.
+
+```solidity
+            // * haifuriki kamwe, na + kufurika kunatakikana
+            price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
+            price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
+        }
+```
+
+Kila kikusanya gharama husasishwa na gharama ya hivi karibuni (akiba ya tokeni nyingine/akiba ya tokeni hii) mara muda uliopita kwa sekunde. Ili kupata bei ya wastani, unasoma bei limbikizi katika pointi mbili kwa wakati na kugawanya kwa tofauti ya muda kati yao. Kwa mfano, fikiria mfuatano huu wa matukio:
+
+| Tukio                                                                                            |                  reserve0 |                  reserve1 | muhuri wa muda | Kiwango cha ubadilishaji cha ukingoni (reserve1 / reserve0) |                                                       price0CumulativeLast |
+| ------------------------------------------------------------------------------------------------ | ------------------------: | ------------------------: | -------------- | -----------------------------------------------------------------------------: | -------------------------------------------------------------------------: |
+| Usanidi wa awali                                                                                 | 1,000.000 | 1,000.000 | 5,000          |                                                          1.000 |                                                                          0 |
+| Mfanyabiashara A anaweka tokeni 50 za token0 na anapata tokeni 47.619 za token1  | 1,050.000 |   952.381 | 5,020          |                                                          0.907 |                                                                         20 |
+| Mfanyabiashara B anaweka tokeni 10 za token0 na anapata tokeni 8.984 za token1   | 1,060.000 |   943.396 | 5,030          |                                                          0.890 |                       20+10\*0.907 = 29.07 |
+| Mfanyabiashara C anaweka tokeni 40 za token0 na anapata tokeni 34.305 za token1  | 1,100.000 |   909.090 | 5,100          |                                                          0.826 |    29.07+70\*0.890 = 91.37 |
+| Mfanyabiashara D anaweka tokeni 100 za token1 na anapata tokeni 109.01 za token0 |   990.990 | 1,009.090 | 5,110          |                                                          1.018 |    91.37+10\*0.826 = 99.63 |
+| Mfanyabiashara E anaweka tokeni 10 za token0 na anapata tokeni 10.079 za token1  | 1,000.990 |   999.010 | 5,150          |                                                          0.998 | 99.63+40\*1.1018 = 143.702 |
+
+Tuseme tunataka kuhesabu bei ya wastani ya **Token0** kati ya mihuri ya muda 5,030 na 5,150. Tofauti katika thamani ya `price0Cumulative` ni 143.702-29.07=114.632. Hii ni wastani kwa dakika mbili (sekunde 120). Kwa hivyo bei ya wastani ni 114.632/120 = 0.955.
+
+Uhesabuji huu wa bei ndiyo sababu tunahitaji kujua ukubwa wa zamani wa akiba.
+
+```solidity
+        reserve0 = uint112(balance0);
+        reserve1 = uint112(balance1);
+        blockTimestampLast = blockTimestamp;
+        emit Sync(reserve0, reserve1);
+    }
+```
+
+Mwishowe, sasisha vigezo vya kimataifa na toa tukio la `Sync`.
+
+##### \_mintFee
+
+```solidity
+    // ikiwa ada imewashwa, zalisha ukwasi sawa na 1/6 ya ukuaji katika sqrt(k)
+    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
+```
+
+Katika Uniswap 2.0 wafanyabiashara hulipa ada ya 0.30% kutumia soko. Sehemu kubwa ya ada hiyo (0.25% ya biashara) huenda kwa watoa huduma za ukwasi. Asilimia 0.05 iliyobaki inaweza kwenda kwa watoa huduma za ukwasi au kwa anwani iliyobainishwa na kiwanda kama ada ya itifaki, ambayo hulipa Uniswap kwa juhudi zao za maendeleo.
+
+Ili kupunguza mahesabu (na kwa hivyo gharama za gesi), ada hii inahesabiwa tu wakati ukwasi unapoongezwa au kuondolewa kwenye bwawa, badala ya kila muamala.
+
+```solidity
+        address feeTo = IUniswapV2Factory(factory).feeTo();
+        feeOn = feeTo != address(0);
+```
+
+Soma lengo la ada la kiwanda. Ikiwa ni sifuri basi hakuna ada ya itifaki na hakuna haja ya kuhesabu ada hiyo.
+
+```solidity
+        uint _kLast = kLast; // akiba ya gesi
+```
+
+Kigezo cha hali cha `kLast` kiko kwenye hifadhi, kwa hivyo kitakuwa na thamani kati ya simu tofauti kwa mkataba.
+Upatikanaji wa hifadhi ni ghali zaidi kuliko upatikanaji wa kumbukumbu tete inayotolewa wakati simu ya kazi kwa mkataba inapoisha, kwa hivyo tunatumia kigezo cha ndani kuokoa gesi.
+
+```solidity
+        if (feeOn) {
+            if (_kLast != 0) {
+```
+
+Watoa huduma za ukwasi wanapata sehemu yao kwa kuongezeka kwa thamani ya tokeni zao za ukwasi. Lakini ada ya itifaki inahitaji tokeni mpya za ukwasi kuzalishwa na kutolewa kwa anwani ya `feeTo`.
+
+```solidity
+                uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
+                uint rootKLast = Math.sqrt(_kLast);
+                if (rootK > rootKLast) {
+```
+
+Ikiwa kuna ukwasi mpya wa kukusanya ada ya itifaki. Unaweza kuona kazi ya kipeo cha pili [baadaye katika makala haya](#Math)
+
+```solidity
+                    uint numerator = totalSupply.mul(rootK.sub(rootKLast));
+                    uint denominator = rootK.mul(5).add(rootKLast);
+                    uint liquidity = numerator / denominator;
+```
+
+Hesabu hii ngumu ya ada imeelezwa katika [waraka rasmi](https://app.uniswap.org/whitepaper.pdf) kwenye ukurasa wa 5. Tunajua kuwa kati ya wakati `kLast` ilipohesabiwa na sasa hakuna ukwasi ulioongezwa au kuondolewa (kwa sababu tunaendesha hesabu hii kila wakati ukwasi unapoongezwa au kuondolewa, kabla haujabadilika), kwa hivyo mabadiliko yoyote katika `reserve0 * reserve1` lazima yatoke kwenye ada za muamala (bila hizo tungehifadhi `reserve0 * reserve1` kuwa thabiti).
+
+```solidity
+                    if (liquidity > 0) _mint(feeTo, liquidity);
+                }
+            }
+```
+
+Tumia kazi ya `UniswapV2ERC20._mint` kuunda tokeni za ziada za ukwasi na kuzipa kwa `feeTo`.
+
+```solidity
+        } else if (_kLast != 0) {
+            kLast = 0;
+        }
+    }
+```
+
+Ikiwa hakuna ada weka `kLast` kuwa sifuri (ikiwa tayari si hivyo). Wakati mkataba huu ulipoandikwa kulikuwa na [kipengele cha kurejesha gesi](https://eips.ethereum.org/EIPS/eip-3298) ambacho kilihimiza mikataba kupunguza ukubwa wa jumla wa hali ya Ethereum kwa kuweka sifuri kwenye hifadhi ambayo hawakuihitaji.
+Msimbo huu unapata urejeshaji huo inapowezekana.
+
+#### Kazi Zinazoweza Kufikiwa Nje {#pair-external}
+
+Kumbuka kuwa ingawa muamala au mkataba wowote _unaweza_ kuita kazi hizi, zimeundwa kuitwa kutoka kwa mkataba wa pembeni. Ukiziita moja kwa moja huwezi kudanganya ubadilishaji wa jozi, lakini unaweza kupoteza thamani kwa kosa.
+
+##### zalisha
+
+```solidity
+    // kazi hii ya kiwango cha chini inapaswa kuitwa kutoka kwa mkataba unaofanya ukaguzi muhimu wa usalama
+    function mint(address to) external lock returns (uint liquidity) {
+```
+
+Kazi hii inaitwa wakati mtoa huduma wa ukwasi anapoongeza ukwasi kwenye bwawa. Inazalisha tokeni za ziada za ukwasi kama tuzo. Inapaswa kuitwa kutoka kwa [mkataba wa pembeni](#UniswapV2Router02) unaoiita baada ya kuongeza ukwasi katika muamala mmoja (ili hakuna mtu mwingine atakayeweza kuwasilisha muamala unaodai ukwasi mpya kabla ya mmiliki halali).
+
+```solidity
+        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // akiba ya gesi
+```
+
+Hii ndiyo njia ya kusoma matokeo ya kazi ya Solidity inayorudisha thamani nyingi. Tunatupa thamani za mwisho zilizorejeshwa, muhuri wa muda wa kizuizi, kwa sababu hatuihitaji.
+
+```solidity
+        uint balance0 = IERC20(token0).balanceOf(address(this));
+        uint balance1 = IERC20(token1).balanceOf(address(this));
+        uint amount0 = balance0.sub(_reserve0);
+        uint amount1 = balance1.sub(_reserve1);
+```
+
+Pata salio za sasa na uone ni kiasi gani kimeongezwa cha kila aina ya tokeni.
+
+```solidity
+        bool feeOn = _mintFee(_reserve0, _reserve1);
+```
+
+Hesabu ada za itifaki za kukusanya, ikiwa zipo, na uzalishe tokeni za ukwasi ipasavyo. Kwa sababu vigezo vya `_mintFee` ni thamani za zamani za akiba, ada inahesabiwa kwa usahihi kulingana na mabadiliko ya bwawa kutokana na ada.
+
+```solidity
+        uint _totalSupply = totalSupply; // akiba ya gesi, lazima ifafanuliwe hapa kwani totalSupply inaweza kusasishwa katika _mintFee
+        if (_totalSupply == 0) {
+            liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
+           _mint(address(0), MINIMUM_LIQUIDITY); // funga kabisa tokeni za kwanza za MINIMUM_LIQUIDITY
+```
+
+Ikiwa hii ni amana ya kwanza, tengeneza tokeni `MINIMUM_LIQUIDITY` na uzitume kwa anwani sifuri ili kuzifunga. Hazitakombolewa kamwe, ambayo inamaanisha bwawa halitawahi kumwagika kabisa (hii inatuokoa kutokana na kugawanya kwa sifuri katika baadhi ya maeneo). Thamani ya `MINIMUM_LIQUIDITY` ni elfu moja, ambayo kwa kuzingatia tokeni nyingi za ERC-20 zimegawanywa katika vitengo vya 10^-18 vya tokeni, kama ETH inavyogawanywa kuwa wei, ni 10^-15 kwa thamani ya tokeni moja. Sio gharama kubwa.
+
+Wakati wa amana ya kwanza hatujui thamani linganishi ya tokeni mbili, kwa hivyo tunazidisha kiasi na kuchukua mzizi wa mraba, tukichukulia kwamba amana inatupatia thamani sawa katika tokeni zote mbili.
+
+Tunaweza kuamini hii kwa sababu ni kwa manufaa ya mweka amana kutoa thamani sawa, ili kuepuka kupoteza thamani kwa usuluhishi.
+Tuseme kwamba thamani ya tokeni mbili ni sawa, lakini mweka amana wetu aliweka mara nne zaidi ya **Token1** kuliko **Token0**. Mfanyabiashara anaweza kutumia ukweli kwamba ubadilishaji wa jozi unafikiri kwamba **Token0** ina thamani zaidi ili kutoa thamani kutoka humo.
+
+| Tukio                                                                          | reserve0 | reserve1 | reserve0 \* reserve1 | Thamani ya bwawa (reserve0 + reserve1) |
+| ------------------------------------------------------------------------------ | -------: | -------: | -------------------: | --------------------------------------------------------: |
+| Usanidi wa awali                                                               |        8 |       32 |                  256 |                                                        40 |
+| Mfanyabiashara anaweka tokeni 8 za **Token0**, anapata tokeni 16 za **Token1** |       16 |       16 |                  256 |                                                        32 |
+
+Kama unavyoona, mfanyabiashara alipata tokeni 8 za ziada, ambazo zinatokana na kupungua kwa thamani ya bwawa, na kumuumiza mweka amana anayemiliki.
+
+```solidity
+        } else {
+            liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
+```
+
+Kwa kila amana inayofuata tayari tunajua kiwango cha ubadilishanaji kati ya mali mbili, na tunatarajia watoa huduma za ukwasi kutoa thamani sawa katika zote mbili. Ikiwa hawafanyi hivyo, tunawapa tokeni za ukwasi kulingana na thamani ndogo waliyotoa kama adhabu.
+
+Iwe ni amana ya awali au inayofuata, idadi ya tokeni za ukwasi tunazotoa ni sawa na mzizi wa mraba wa mabadiliko katika `reserve0*reserve1` na thamani ya tokeni ya ukwasi haibadiliki (isipokuwa tupate amana ambayo haina thamani sawa za aina zote mbili, katika hali hiyo "faini" inasambazwa). Huu ni mfano mwingine na tokeni mbili ambazo zina thamani sawa, na amana tatu nzuri na moja mbaya (amana ya aina moja tu ya tokeni, kwa hivyo haitoi tokeni za ukwasi).
+
+| Tukio                        |                                reserve0 |                                reserve1 | reserve0 \* reserve1 | Thamani ya bwawa (reserve0 + reserve1) | Tokeni za ukwasi zilizozalishwa kwa amana hii | Jumla ya tokeni za ukwasi |       thamani ya kila tokeni ya ukwasi |
+| ---------------------------- | --------------------------------------: | --------------------------------------: | -------------------: | --------------------------------------------------------: | --------------------------------------------: | ------------------------: | -------------------------------------: |
+| Usanidi wa awali             |                   8.000 |                   8.000 |                   64 |                                    16.000 |                                             8 |                         8 |                  2.000 |
+| Weka aina nne za kila moja   |                  12.000 |                  12.000 |                  144 |                                    24.000 |                                             4 |                        12 |                  2.000 |
+| Weka aina mbili za kila moja |                  14.000 |                  14.000 |                  196 |                                    28.000 |                                             2 |                        14 |                  2.000 |
+| Amana ya thamani isiyo sawa  |                  18.000 |                  14.000 |                  252 |                                    32.000 |                                             0 |                        14 | ~2.286 |
+| Baada ya usuluhishi          | ~15.874 | ~15.874 |                  252 |                   ~31.748 |                                             0 |                        14 | ~2.267 |
+
+```solidity
+        }
+        require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
+        _mint(to, liquidity);
+```
+
+Tumia kazi ya `UniswapV2ERC20._mint` kuunda tokeni za ziada za ukwasi na kuzipa kwa akaunti sahihi.
+
+```solidity
+
+        _update(balance0, balance1, _reserve0, _reserve1);
+        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 na reserve1 zimesasishwa
+        emit Mint(msg.sender, amount0, amount1);
+    }
+```
+
+Sasisha vigezo vya hali (`reserve0`, `reserve1`, na ikihitajika `kLast`) na toa tukio linalofaa.
+
+##### ondoa
+
+```solidity
+    // kazi hii ya kiwango cha chini inapaswa kuitwa kutoka kwa mkataba unaofanya ukaguzi muhimu wa usalama
+    function burn(address to) external lock returns (uint amount0, uint amount1) {
+```
+
+Kazi hii inaitwa wakati ukwasi unapoondolewa na tokeni zinazofaa za ukwasi zinahitaji kuondolewa.
+Inapaswa pia kuitwa [kutoka kwa akaunti ya pembeni](#UniswapV2Router02).
+
+```solidity
+        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // akiba ya gesi
+        address _token0 = token0;                                // akiba ya gesi
+        address _token1 = token1;                                // akiba ya gesi
+        uint balance0 = IERC20(_token0).balanceOf(address(this));
+        uint balance1 = IERC20(_token1).balanceOf(address(this));
+        uint liquidity = balanceOf[address(this)];
+```
+
+Mkataba wa pembeni ulihamisha ukwasi wa kuondolewa kwenye mkataba huu kabla ya simu. Kwa njia hiyo tunajua ni kiasi gani cha ukwasi cha kuondoa, na tunaweza kuhakikisha kuwa kinaondolewa.
+
+```solidity
+        bool feeOn = _mintFee(_reserve0, _reserve1);
+        uint _totalSupply = totalSupply; // akiba ya gesi, lazima ifafanuliwe hapa kwani totalSupply inaweza kusasishwa katika _mintFee
+        amount0 = liquidity.mul(balance0) / _totalSupply; // kutumia salio huhakikisha usambazaji wa pro-rata
+        amount1 = liquidity.mul(balance1) / _totalSupply; // kutumia salio huhakikisha usambazaji wa pro-rata
+        require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
+```
+
+Mtoa huduma wa ukwasi anapokea thamani sawa ya tokeni zote mbili. Kwa njia hii hatubadilishi kiwango cha ubadilishanaji.
+
+```solidity
+        _burn(address(this), liquidity);
+        _safeTransfer(_token0, to, amount0);
+        _safeTransfer(_token1, to, amount1);
+        balance0 = IERC20(_token0).balanceOf(address(this));
+        balance1 = IERC20(_token1).balanceOf(address(this));
+
+        _update(balance0, balance1, _reserve0, _reserve1);
+        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 na reserve1 zimesasishwa
+        emit Burn(msg.sender, amount0, amount1, to);
+    }
+
+```
+
+Sehemu iliyobaki ya kazi ya `burn` ni kioo cha kazi ya `mint` hapo juu.
+
+##### badilisha
+
+```solidity
+    // kazi hii ya kiwango cha chini inapaswa kuitwa kutoka kwa mkataba unaofanya ukaguzi muhimu wa usalama
+    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
+```
+
+Kazi hii pia inapaswa kuitwa kutoka kwa [mkataba wa pembeni](#UniswapV2Router02).
+
+```solidity
+        require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
+        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // akiba ya gesi
+        require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
+
+        uint balance0;
+        uint balance1;
+        { // wigo kwa _token{0,1}, huepuka makosa ya rundo kuwa kina sana
+```
+
+Vigezo vya ndani vinaweza kuhifadhiwa ama kwenye kumbukumbu au, ikiwa si vingi sana, moja kwa moja kwenye rundo.
+Ikiwa tunaweza kupunguza idadi ili tutumie rundo tunatumia gesi kidogo. Kwa maelezo zaidi angalia [waraka wa njano, maelezo rasmi ya Ethereum](https://ethereum.github.io/yellowpaper/paper.pdf), uk. 26, mlinganyo wa 298.
+
+```solidity
+            address _token0 = token0;
+            address _token1 = token1;
+            require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
+            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // hamisha tokeni kwa matumaini
+            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // hamisha tokeni kwa matumaini
+```
+
+Uhamisho huu ni wa matumaini, kwa sababu tunahamisha kabla ya kuwa na uhakika masharti yote yametimizwa. Hii ni sawa katika Ethereum kwa sababu ikiwa masharti hayajatimizwa baadaye katika simu tutarejesha kutoka humo na mabadiliko yoyote iliyoyatengeneza.
+
+```solidity
+            if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
+```
+
+Mjulishe mpokeaji kuhusu ubadilishaji ikiwa imeombwa.
+
+```solidity
+            balance0 = IERC20(_token0).balanceOf(address(this));
+            balance1 = IERC20(_token1).balanceOf(address(this));
+        }
+```
+
+Pata salio za sasa. Mkataba wa pembeni hututumia tokeni kabla ya kutuita kwa ubadilishaji. Hii inarahisisha mkataba kuangalia kwamba haufanyiwi udanganyifu, ukaguzi ambao _lazima_ utokee katika mkataba wa msingi (kwa sababu tunaweza kuitwa na vyombo vingine isipokuwa mkataba wetu wa pembeni).
+
+```solidity
+        uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
+        uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
+        require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
+        { // wigo kwa reserve{0,1}Adjusted, huepuka makosa ya rundo kuwa kina sana
+            uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
+            uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
+            require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
+```
+
+Huu ni ukaguzi wa busara ili kuhakikisha hatupotezi kutokana na ubadilishaji. Hakuna hali yoyote ambayo ubadilishaji unapaswa kupunguza `reserve0*reserve1`. Hapa pia ndipo tunahakikisha ada ya 0.3% inatumwa kwenye ubadilishaji; kabla ya kuangalia thamani ya K, tunazidisha salio zote mbili kwa 1000 kutoa kiasi kilichozidishwa na 3, hii inamaanisha 0.3% (3/1000 = 0.003 = 0.3%) inakatwa kutoka kwa salio kabla ya kulinganisha thamani yake ya K na thamani ya K ya akiba ya sasa.
+
+```solidity
+        }
+
+        _update(balance0, balance1, _reserve0, _reserve1);
+        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
+    }
+```
+
+Sasisha `reserve0` na `reserve1`, na ikihitajika vikusanya bei na mhuri wa muda na toa tukio.
+
+##### Sawazisha au Punguza
+
+Inawezekana kwa salio halisi kupoteza usawazisho na akiba ambayo ubadilishaji wa jozi unafikiri inayo.
+Hakuna njia ya kutoa tokeni bila idhini ya mkataba, lakini amana ni jambo tofauti. Akaunti inaweza kuhamisha tokeni kwenye ubadilishanaji bila kuita `mint` au `swap`.
+
+Katika hali hiyo kuna suluhisho mbili:
+
+- `sync`, sasisha akiba kwa salio za sasa
+- `skim`, toa kiasi cha ziada. Kumbuka kuwa akaunti yoyote inaruhusiwa kuita `skim` kwa sababu hatujui ni nani aliyeweka tokeni. Taarifa hii inatolewa katika tukio, lakini matukio hayapatikani kutoka kwenye mnyororo wa bloku.
+
+```solidity
+    // lazimisha salio kulingana na akiba
+    function skim(address to) external lock {
+        address _token0 = token0; // akiba ya gesi
+        address _token1 = token1; // akiba ya gesi
+        _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
+        _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
+    }
+
+
+
+    // lazimisha akiba kulingana na salio
+    function sync() external lock {
+        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
+    }
+}
+```
+
+### UniswapV2Factory.sol {#UniswapV2Factory}
+
+[Mkataba huu](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Factory.sol) unaunda ubadilishanaji wa jozi.
+
+```solidity
+pragma solidity =0.5.16;
+
+import './interfaces/IUniswapV2Factory.sol';
+import './UniswapV2Pair.sol';
+
+contract UniswapV2Factory is IUniswapV2Factory {
+    address public feeTo;
+    address public feeToSetter;
+```
+
+Vigezo hivi vya hali ni muhimu kutekeleza ada ya itifaki (tazama [waraka rasmi](https://app.uniswap.org/whitepaper.pdf), uk. 5).
+Anwani ya `feeTo` inakusanya tokeni za ukwasi kwa ada ya itifaki, na `feeToSetter` ni anwani inayoruhusiwa kubadilisha `feeTo` kuwa anwani tofauti.
+
+```solidity
+    mapping(address => mapping(address => address)) public getPair;
+    address[] public allPairs;
+```
+
+Vigezo hivi vinafuatilia jozi, ubadilishanaji kati ya aina mbili za tokeni.
+
+Ya kwanza, `getPair`, ni ramani inayotambua mkataba wa ubadilishanaji wa jozi kulingana na tokeni mbili za ERC-20 inazobadilisha. Tokeni za ERC-20 zinatambuliwa na anwani za mikataba inayozitekeleza, kwa hivyo funguo na thamani zote ni anwani. Ili kupata anwani ya ubadilishanaji wa jozi unaokuruhusu kubadilisha kutoka `tokenA` kwenda `tokenB`, unatumia `getPair[<anwani ya tokenA>][<anwani ya tokenB>]` (au kinyume chake).
+
+Kigezo cha pili, `allPairs`, ni safu inayojumuisha anwani zote za ubadilishanaji wa jozi zilizoundwa na kiwanda hiki. Katika Ethereum huwezi kurudia juu ya yaliyomo kwenye ramani, au kupata orodha ya funguo zote, kwa hivyo kigezo hiki ndiyo njia pekee ya kujua ni ubadilishanaji gani kiwanda hiki kinasimamia.
+
+Kumbuka: Sababu huwezi kurudia juu ya funguo zote za ramani ni kwamba hifadhi ya data ya mkataba ni _ghali_, kwa hivyo kadiri tunavyotumia kidogo ndivyo bora, na kadiri tunavyoibadilisha mara chache ndivyo bora. Unaweza kuunda [ramani zinazounga mkono urudiaji](https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol), lakini zinahitaji hifadhi ya ziada kwa orodha ya funguo. Katika programu nyingi hauitaji hiyo.
+
+```solidity
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+```
+
+Tukio hili hutolewa wakati ubadilishanaji mpya wa jozi unapoundwa. Inajumuisha anwani za tokeni, anwani ya ubadilishanaji wa jozi, na idadi jumla ya ubadilishanaji unaosimamiwa na kiwanda.
+
+```solidity
+    constructor(address _feeToSetter) public {
+        feeToSetter = _feeToSetter;
+    }
+```
+
+Kitu pekee ambacho kiunda hufanya ni kubainisha `feeToSetter`. Viwanda huanza bila ada, na ni `feeSetter` pekee anayeweza kubadilisha hilo.
+
+```solidity
+    function allPairsLength() external view returns (uint) {
+        return allPairs.length;
+    }
+```
+
+Kazi hii inarudisha idadi ya jozi za ubadilishanaji.
+
+```solidity
+    function createPair(address tokenA, address tokenB) external returns (address pair) {
+```
+
+Hii ndiyo kazi kuu ya kiwanda, kuunda ubadilishanaji wa jozi kati ya tokeni mbili za ERC-20. Kumbuka kuwa mtu yeyote anaweza kuita kazi hii. Hauhitaji ruhusa kutoka kwa Uniswap kuunda ubadilishanaji mpya wa jozi.
+
+```solidity
+        require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
+        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+```
+
+Tunataka anwani ya ubadilishanaji mpya iwe ya uhakika, ili iweze kuhesabiwa mapema nje ya mnyororo (hii inaweza kuwa muhimu kwa [mikataba ya Layer 2](/developers/docs/scaling/)).
+Ili kufanya hivi tunahitaji kuwa na mpangilio thabiti wa anwani za tokeni, bila kujali mpangilio tuliopokea, kwa hivyo tunazipanga hapa.
+
+```solidity
+        require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
+        require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // ukaguzi mmoja unatosha
+```
+
+Mabwawa makubwa ya ukwasi ni bora kuliko madogo, kwa sababu yana bei thabiti zaidi. Hatutaki kuwa na bwawa zaidi ya moja la ukwasi kwa kila jozi ya tokeni. Ikiwa tayari kuna ubadilishanaji, hakuna haja ya kuunda mwingine kwa jozi hiyo hiyo.
+
+```solidity
+        bytes memory bytecode = type(UniswapV2Pair).creationCode;
+```
+
+Ili kuunda mkataba mpya tunahitaji msimbo unaouunda (kazi ya kiunda na msimbo unaoandika kwenye kumbukumbu msimbo wa EVM wa mkataba halisi). Kawaida katika Solidity tunatumia `addr = new <jina la mkataba>(<vigezo vya kiunda>)` na mkusanyaji hushughulikia kila kitu kwetu, lakini ili kuwa na anwani ya mkataba ya uhakika tunahitaji kutumia [opcode ya CREATE2](https://eips.ethereum.org/EIPS/eip-1014).
+Wakati msimbo huu ulipoandikwa opcode hiyo bado haikuwa ikiungwa mkono na Solidity, kwa hivyo ilikuwa muhimu kupata msimbo kwa mikono. Hili si tatizo tena, kwa sababu [Solidity sasa inasaidia CREATE2](https://docs.soliditylang.org/en/v0.8.3/control-structures.html#salted-contract-creations-create2).
+
+```solidity
+        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
+        assembly {
+            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
+        }
+```
+
+Wakati opcode haijaungwa mkono na Solidity bado tunaweza kuiita kwa kutumia [mkusanyiko wa ndani](https://docs.soliditylang.org/en/v0.8.3/assembly.html).
+
+```solidity
+        IUniswapV2Pair(pair).initialize(token0, token1);
+```
+
+Piga simu kazi ya `initialize` ili kuuambia ubadilishanaji mpya ni tokeni gani mbili inazobadilisha.
+
+```solidity
+        getPair[token0][token1] = pair;
+        getPair[token1][token0] = pair; // jaza ramani kwa upande wa nyuma
+        allPairs.push(pair);
+        emit PairCreated(token0, token1, pair, allPairs.length);
+    }
+```
+
+Hifadhi taarifa mpya ya jozi katika vigezo vya hali na toa tukio la kuujulisha ulimwengu kuhusu ubadilishanaji mpya wa jozi.
+
+```solidity
+    function setFeeTo(address _feeTo) external {
+        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
+        feeTo = _feeTo;
+    }
+
+    function setFeeToSetter(address _feeToSetter) external {
+        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
+        feeToSetter = _feeToSetter;
+    }
+}
+```
+
+Kazi hizi mbili huruhusu `feeSetter` kudhibiti mpokeaji wa ada (ikiwepo), na kubadilisha `feeSetter` kuwa anwani mpya.
+
+### UniswapV2ERC20.sol {#UniswapV2ERC20}
+
+[Mkataba huu](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) unatekeleza tokeni ya ukwasi ya ERC-20. Ni sawa na [mkataba wa OpenZeppelin ERC-20](/developers/tutorials/erc20-annotated-code), kwa hivyo nitaelezea tu sehemu iliyo tofauti, utendaji wa `permit`.
+
+Miamala kwenye Ethereum hugharimu ether (ETH), ambayo ni sawa na pesa halisi. Ikiwa una tokeni za ERC-20 lakini huna ETH, huwezi kutuma miamala, kwa hivyo huwezi kufanya chochote nazo. Suluhisho moja la kuepuka tatizo hili ni [miamala-meta](https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/supporting-meta-transactions).
+Mmiliki wa tokeni husaini muamala unaoruhusu mtu mwingine kutoa tokeni nje ya mnyororo na kuutuma kwa kutumia intaneti kwa mpokeaji. Mpokeaji, ambaye ana ETH, kisha huwasilisha kibali kwa niaba ya mmiliki.
+
+```solidity
+    bytes32 public DOMAIN_SEPARATOR;
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+```
+
+Hashi hii ni [kitambulisho cha aina ya muamala](https://eips.ethereum.org/EIPS/eip-712#rationale-for-typehash). Ile pekee tunayoiunga mkono hapa ni `Permit` na vigezo hivi.
+
+```solidity
+    mapping(address => uint) public nonces;
+```
+
+Haiwezekani kwa mpokeaji kughushi sahihi ya dijitali. Hata hivyo, ni rahisi kutuma muamala huo mara mbili (hii ni aina ya [shambulio la kurudia](https://wikipedia.org/wiki/Replay_attack)). Ili kuzuia hili, tunatumia [nonce](https://wikipedia.org/wiki/Cryptographic_nonce). Ikiwa nonce ya `Permit` mpya si moja zaidi ya ile ya mwisho iliyotumika, tunadhania ni batili.
+
+```solidity
+    constructor() public {
+        uint chainId;
+        assembly {
+            chainId := chainid
+        }
+```
+
+Huu ni msimbo wa kupata [kitambulisho cha mnyororo](https://chainid.network/). Inatumia lahaja ya mkusanyiko wa EVM inayoitwa [Yul](https://docs.soliditylang.org/en/v0.8.4/yul.html). Kumbuka kuwa katika toleo la sasa la Yul unapaswa kutumia `chainid()`, si `chainid`.
+
+```solidity
+        DOMAIN_SEPARATOR = keccak256(
+            abi.encode(
+                keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
+                keccak256(bytes(name)),
+                keccak256(bytes('1')),
+                chainId,
+                address(this)
+            )
+        );
+    }
+```
+
+Hesabu [kitenganishi cha kikoa](https://eips.ethereum.org/EIPS/eip-712#rationale-for-domainseparator) kwa EIP-712.
+
+```solidity
+    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
+```
+
+Hii ndiyo kazi inayotekeleza vibali. Inapokea kama vigezo nyanja husika, na thamani tatu za scalar kwa [sahihi](https://yos.io/2018/11/16/ethereum-signatures/) (v, r, na s).
+
+```solidity
+        require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
+```
+
+Usikubali miamala baada ya muda wa mwisho.
+
+```solidity
+        bytes32 digest = keccak256(
+            abi.encodePacked(
+                '\x19\x01',
+                DOMAIN_SEPARATOR,
+                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
+            )
+        );
+```
+
+`abi.encodePacked(...)` ni ujumbe tunaotarajia kupata. Tunajua nonce inapaswa kuwa nini, kwa hivyo hakuna haja ya kuipata kama kigezo.
+
+Algorithm ya sahihi ya Ethereum inatarajia kupata biti 256 za kusaini, kwa hivyo tunatumia kazi ya hashi ya `keccak256`.
+
+```solidity
+        address recoveredAddress = ecrecover(digest, v, r, s);
+```
+
+Kutoka kwenye digest na sahihi tunaweza kupata anwani iliyoisaini kwa kutumia [ecrecover](https://coders-errand.com/ecrecover-signature-verification-ethereum/).
+
+```solidity
+        require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
+        _approve(owner, spender, value);
+    }
+
+```
+
+Ikiwa kila kitu kiko sawa, chukulia hii kama [idhinisho la ERC-20](https://eips.ethereum.org/EIPS/eip-20#approve).
+
+## Mikataba ya Pembeni {#periphery-contracts}
+
+Mikataba ya pembeni ni API (kiolesura cha programu) kwa Uniswap. Zinapatikana kwa simu za nje, ama kutoka kwa mikataba mingine au mfumo uliotawanywa. Unaweza kuita mikataba ya msingi moja kwa moja, lakini hiyo ni ngumu zaidi na unaweza kupoteza thamani ukifanya kosa. Mikataba ya msingi ina majaribio tu ya kuhakikisha haifanyiwi udanganyifu, sio ukaguzi wa busara kwa mtu mwingine yeyote. Hayo yako kwenye pembeni ili yaweze kusasishwa kama inavyohitajika.
+
+### UniswapV2Router01.sol {#UniswapV2Router01}
+
+[Mkataba huu](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router01.sol) una matatizo, na [haupaswi kutumika tena](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-01). Kwa bahati nzuri, mikataba ya pembeni haina hali na haishikili mali yoyote, kwa hivyo ni rahisi kuiondoa na kupendekeza watu watumie mbadala, `UniswapV2Router02`, badala yake.
+
+### UniswapV2Router02.sol {#UniswapV2Router02}
+
+Katika hali nyingi utatumia Uniswap kupitia [mkataba huu](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router02.sol).
+Unaweza kuona jinsi ya kuitumia [hapa](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02).
+
+```solidity
+pragma solidity =0.6.6;
+
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
+import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
+
+import './interfaces/IUniswapV2Router02.sol';
+import './libraries/UniswapV2Library.sol';
+import './libraries/SafeMath.sol';
+import './interfaces/IERC20.sol';
+import './interfaces/IWETH.sol';
+```
+
+Mengi ya haya tumeyakuta hapo awali, au ni dhahiri kabisa. Ubaguzi mmoja ni `IWETH.sol`. Uniswap v2 inaruhusu ubadilishanaji kwa jozi yoyote ya tokeni za ERC-20, lakini ether (ETH) yenyewe si tokeni ya ERC-20. Ilikuwepo kabla ya kiwango hicho na inahamishwa kwa mifumo ya kipekee. Ili kuwezesha matumizi ya ETH katika mikataba inayotumika kwa tokeni za ERC-20 watu walikuja na mkataba wa [ether iliyofungwa (WETH)](https://weth.tkn.eth.limo/). Unatuma ETH kwa mkataba huu, na inakuzalishia kiasi sawa cha WETH. Au unaweza kuondoa WETH, na kupata ETH tena.
+
+```solidity
+contract UniswapV2Router02 is IUniswapV2Router02 {
+    using SafeMath for uint;
+
+    address public immutable override factory;
+    address public immutable override WETH;
+```
+
+Router inahitaji kujua ni kiwanda gani cha kutumia, na kwa miamala inayohitaji WETH ni mkataba gani wa WETH wa kutumia. Thamani hizi [hazibadiliki](https://docs.soliditylang.org/en/v0.8.3/contracts.html#constant-and-immutable-state-variables), ikimaanisha zinaweza kuwekwa tu katika kiunda. Hii inawapa watumiaji ujasiri kwamba hakuna mtu atakayeweza kuzibadilisha ili zielekeze kwenye mikataba isiyo ya uaminifu.
+
+```solidity
+    modifier ensure(uint deadline) {
+        require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+        _;
+    }
+```
+
+Kirekebishaji hiki huhakikisha kuwa miamala yenye kikomo cha muda ("fanya X kabla ya muda Y ukiweza") haifanyiki baada ya kikomo chao cha muda.
+
+```solidity
+    constructor(address _factory, address _WETH) public {
+        factory = _factory;
+        WETH = _WETH;
+    }
+```
+
+Kiunda huweka tu vigezo vya hali visivyobadilika.
+
+```solidity
+    receive() external payable {
+        assert(msg.sender == WETH); // kubali ETH tu kupitia fallback kutoka kwa mkataba wa WETH
+    }
+```
+
+Kazi hii inaitwa tunapokomboa tokeni kutoka kwa mkataba wa WETH kurudi kuwa ETH. Mkataba wa WETH pekee tunaotumia ndio umeruhusiwa kufanya hivyo.
+
+#### Ongeza Ukwasi {#add-liquidity}
+
+Kazi hizi huongeza tokeni kwenye ubadilishanaji wa jozi, ambayo huongeza bwawa la ukwasi.
+
+```solidity
+
+    // **** ONGEZA UKWASI ****
+    function _addLiquidity(
+```
+
+Kazi hii inatumika kuhesabu kiasi cha tokeni A na B ambazo zinapaswa kuwekwa kwenye ubadilishanaji wa jozi.
+
+```solidity
+        address tokenA,
+        address tokenB,
+```
+
+Hizi ni anwani za mikataba ya tokeni za ERC-20.
+
+```solidity
+        uint amountADesired,
+        uint amountBDesired,
+```
+
+Hivi ni viwango ambavyo mtoa huduma wa ukwasi anataka kuweka. Pia ni viwango vya juu vya A na B vitakavyowekwa.
+
+```solidity
+        uint amountAMin,
+        uint amountBMin
+```
+
+Hivi ni viwango vya chini vinavyokubalika vya kuweka. Ikiwa muamala hauwezi kufanyika kwa viwango hivi au zaidi, rejesha kutoka humo. Ikiwa hutaki kipengele hiki, weka sifuri.
+
+Watoa huduma za ukwasi huweka kiwango cha chini, kwa kawaida, kwa sababu wanataka kupunguza muamala kwa kiwango cha ubadilishanaji kilicho karibu na cha sasa. Ikiwa kiwango cha ubadilishanaji kinabadilika sana inaweza kumaanisha habari zinazobadilisha thamani za msingi, na wanataka kuamua wenyewe nini cha kufanya.
+
+Kwa mfano, fikiria kesi ambapo kiwango cha ubadilishanaji ni moja kwa moja na mtoa huduma wa ukwasi anaweka thamani hizi:
+
+| Kigezo         | Thamani |
+| -------------- | ------: |
+| amountADesired |    1000 |
+| amountBDesired |    1000 |
+| amountAMin     |     900 |
+| amountBMin     |     800 |
+
+Muda wote kiwango cha ubadilishanaji kinapobaki kati ya 0.9 na 1.25, muamala hufanyika. Ikiwa kiwango cha ubadilishanaji kinatoka nje ya masafa hayo, muamala hughairishwa.
+
+Sababu ya tahadhari hii ni kwamba miamala si ya papo hapo, unaiwasilisha na hatimaye mthibitishaji ataijumuisha kwenye kizuizi (isipokuwa bei yako ya gesi ni ya chini sana, katika hali hiyo utahitaji kuwasilisha muamala mwingine na nonce sawa na bei ya juu ya gesi ili kuibatilisha). Huwezi kudhibiti kinachotokea wakati wa muda kati ya uwasilishaji na ujumuishaji.
+
+```solidity
+    ) internal virtual returns (uint amountA, uint amountB) {
+```
+
+Kazi inarudisha viwango ambavyo mtoa huduma wa ukwasi anapaswa kuweka ili kuwa na uwiano sawa na uwiano wa sasa kati ya akiba.
+
+```solidity
+        // unda jozi ikiwa bado haipo
+        if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
+            IUniswapV2Factory(factory).createPair(tokenA, tokenB);
+        }
+```
+
+Ikiwa hakuna ubadilishanaji wa jozi hii ya tokeni bado, uunde.
+
+```solidity
+        (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
+```
+
+Pata akiba za sasa katika jozi.
+
+```solidity
+        if (reserveA == 0 && reserveB == 0) {
+            (amountA, amountB) = (amountADesired, amountBDesired);
+```
+
+Ikiwa akiba za sasa ni tupu basi huu ni ubadilishanaji mpya wa jozi. Viwango vitakavyowekwa vinapaswa kuwa sawa kabisa na vile ambavyo mtoa huduma wa ukwasi anataka kutoa.
+
+```solidity
+        } else {
+            uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
+```
+
+Ikiwa tunahitaji kuona viwango vitakavyokuwa, tunapata kiwango bora kwa kutumia [kazi hii](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol#L35). Tunataka uwiano sawa na akiba za sasa.
+
+```solidity
+            if (amountBOptimal <= amountBDesired) {
+                require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
+                (amountA, amountB) = (amountADesired, amountBOptimal);
+```
+
+Ikiwa `amountBOptimal` ni ndogo kuliko kiwango ambacho mtoa huduma wa ukwasi anataka kuweka inamaanisha tokeni B ina thamani zaidi kwa sasa kuliko mweka amana wa ukwasi anavyofikiri, kwa hivyo kiwango kidogo kinahitajika.
+
+```solidity
+            } else {
+                uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA);
+                assert(amountAOptimal <= amountADesired);
+                require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
+                (amountA, amountB) = (amountAOptimal, amountBDesired);
+```
+
+Ikiwa kiwango bora cha B ni zaidi ya kiwango kinachotakiwa cha B inamaanisha tokeni za B zina thamani ndogo kwa sasa kuliko mweka amana wa ukwasi anavyofikiri, kwa hivyo kiwango cha juu kinahitajika. Hata hivyo, kiwango kinachotakiwa ni cha juu, kwa hivyo hatuwezi kufanya hivyo. Badala yake tunahesabu idadi bora ya tokeni A kwa kiwango kinachotakiwa cha tokeni B.
+
+Tukiweka yote pamoja tunapata grafu hii. Fikiria unajaribu kuweka tokeni elfu moja za A (mstari wa bluu) na tokeni elfu moja za B (mstari mwekundu). Mhimili wa x ni kiwango cha ubadilishanaji, A/B. Ikiwa x=1, zina thamani sawa na unaweka elfu moja ya kila moja. Ikiwa x=2, A ina thamani mara mbili ya B (unapata tokeni mbili za B kwa kila tokeni A) kwa hivyo unaweka tokeni elfu moja za B, lakini tokeni 500 tu za A. Ikiwa x=0.5, hali inabadilika, tokeni elfu moja za A na tokeni mia tano za B.
+
+![Grafu](liquidityProviderDeposit.png)
+
+Unaweza kuweka ukwasi moja kwa moja kwenye mkataba wa msingi (kwa kutumia [UniswapV2Pair::mint](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L110)), lakini mkataba wa msingi huangalia tu kwamba haufanyiwi udanganyifu, kwa hivyo una hatari ya kupoteza thamani ikiwa kiwango cha ubadilishanaji kinabadilika kati ya wakati unapowasilisha muamala wako na wakati unapotekelezwa. Ikiwa unatumia mkataba wa pembeni, huhesabu kiwango unachopaswa kuweka na kukiweka mara moja, kwa hivyo kiwango cha ubadilishanaji hakibadiliki na hupotezi chochote.
+
+```solidity
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint amountADesired,
+        uint amountBDesired,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+```
+
+Kazi hii inaweza kuitwa na muamala ili kuweka ukwasi. Vigezo vingi ni sawa na katika `_addLiquidity` hapo juu, isipokuwa mbili:
+
+. `to` ni anwani inayopata tokeni mpya za ukwasi zilizozalishwa kuonyesha sehemu ya mtoa huduma wa ukwasi ya bwawa
+. `deadline` ni kikomo cha muda kwenye muamala
+
+```solidity
+    ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
+        (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
+        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
+```
+
+Tunahesabu kiasi cha kuweka halisi na kisha kupata anwani ya bwawa la ukwasi. Ili kuokoa gesi hatufanyi hivi kwa kuuliza kiwanda, lakini kwa kutumia kazi ya maktaba `pairFor` (tazama hapa chini katika maktaba)
+
+```solidity
+        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
+        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
+```
+
+Hamisha kiasi sahihi cha tokeni kutoka kwa mtumiaji hadi kwenye ubadilishanaji wa jozi.
+
+```solidity
+        liquidity = IUniswapV2Pair(pair).mint(to);
+```
+
+Kwa malipo, mpe anwani ya `to` tokeni za ukwasi kwa umiliki wa sehemu ya bwawa. Kazi ya `mint` ya mkataba wa msingi huona ni tokeni ngapi za ziada inazo (ikilinganishwa na ilivyokuwa mara ya mwisho ukwasi ulipobadilika) na inazalisha ukwasi ipasavyo.
+
+```solidity
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+```
+
+Wakati mtoa huduma wa ukwasi anapotaka kutoa ukwasi kwa ubadilishanaji wa jozi ya Token/ETH, kuna tofauti chache. Mkataba hushughulikia kufunga ETH kwa ajili ya mtoa huduma wa ukwasi. Hakuna haja ya kubainisha ni ETH ngapi mtumiaji anataka kuweka, kwa sababu mtumiaji huwatuma tu na muamala (kiasi kinapatikana katika `msg.value`).
+
+```solidity
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
+        (amountToken, amountETH) = _addLiquidity(
+            token,
+            WETH,
+            amountTokenDesired,
+            msg.value,
+            amountTokenMin,
+            amountETHMin
+        );
+        address pair = UniswapV2Library.pairFor(factory, token, WETH);
+        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
+        IWETH(WETH).deposit{value: amountETH}();
+        assert(IWETH(WETH).transfer(pair, amountETH));
+```
+
+Ili kuweka ETH, mkataba kwanza huifunga kuwa WETH na kisha huhamisha WETH kwenye jozi. Ona kuwa uhamisho umefungwa kwenye `assert`. Hii inamaanisha kuwa ikiwa uhamisho utashindwa, simu hii ya mkataba pia itashindwa, na kwa hivyo ufungaji hautatokea.
+
+```solidity
+        liquidity = IUniswapV2Pair(pair).mint(to);
+        // rudisha vumbi la eth, ikiwapo
+        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
+    }
+```
+
+Mtumiaji tayari ametutumia ETH, kwa hivyo ikiwa kuna ziada yoyote iliyobaki (kwa sababu tokeni nyingine ina thamani ndogo kuliko mtumiaji alivyofikiria), tunahitaji kurejesha pesa.
+
+#### Ondoa Ukwasi {#remove-liquidity}
+
+Kazi hizi zitaondoa ukwasi na kumlipa mtoa huduma wa ukwasi.
+
+```solidity
+    // **** ONDOA UKWASI ****
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
+```
+
+Kesi rahisi zaidi ya kuondoa ukwasi. Kuna kiasi cha chini cha kila tokeni ambacho mtoa huduma wa ukwasi anakubali kupokea, na lazima itokee kabla ya muda wa mwisho.
+
+```solidity
+        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
+        IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // tuma ukwasi kwenye jozi
+        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
+```
+
+Kazi ya `burn` ya mkataba wa msingi inashughulikia kumlipa mtumiaji tokeni.
+
+```solidity
+        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
+```
+
+Wakati kazi inaporudisha thamani nyingi, lakini tunavutiwa na baadhi tu, hivi ndivyo tunavyopata thamani hizo tu. Ni nafuu kidogo kwa gharama ya gesi kuliko kusoma thamani na kutoitumia.
+
+```solidity
+        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
+```
+
+Tafsiri viwango kutoka jinsi mkataba wa msingi unavyovirudisha (tokeni ya anwani ya chini kwanza) hadi jinsi mtumiaji anavyotarajia (sawa na `tokenA` na `tokenB`).
+
+```solidity
+        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
+        require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
+    }
+```
+
+Ni sawa kufanya uhamisho kwanza na kisha kuthibitisha ni halali, kwa sababu ikiwa si hivyo tutarejesha kutoka kwa mabadiliko yote ya hali.
+
+```solidity
+    function removeLiquidityETH(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) public virtual override ensure(deadline) returns (uint amountToken, uint amountETH) {
+        (amountToken, amountETH) = removeLiquidity(
+            token,
+            WETH,
+            liquidity,
+            amountTokenMin,
+            amountETHMin,
+            address(this),
+            deadline
+        );
+        TransferHelper.safeTransfer(token, to, amountToken);
+        IWETH(WETH).withdraw(amountETH);
+        TransferHelper.safeTransferETH(to, amountETH);
+    }
+```
+
+Kuondoa ukwasi kwa ETH ni karibu sawa, isipokuwa kwamba tunapokea tokeni za WETH na kisha kuzikomboa kwa ETH ili kumrudishia mtoa huduma wa ukwasi.
+
+```solidity
+    function removeLiquidityWithPermit(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external virtual override returns (uint amountA, uint amountB) {
+        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
+        uint value = approveMax ? uint(-1) : liquidity;
+        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
+        (amountA, amountB) = removeLiquidity(tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline);
+    }
+
+
+    function removeLiquidityETHWithPermit(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external virtual override returns (uint amountToken, uint amountETH) {
+        address pair = UniswapV2Library.pairFor(factory, token, WETH);
+        uint value = approveMax ? uint(-1) : liquidity;
+        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
+        (amountToken, amountETH) = removeLiquidityETH(token, liquidity, amountTokenMin, amountETHMin, to, deadline);
+    }
+```
+
+Kazi hizi huwasilisha miamala-meta ili kuruhusu watumiaji wasio na ether kutoa kutoka kwenye bwawa, kwa kutumia [mfumo wa kibali](#UniswapV2ERC20).
+
+```solidity
+
+    // **** ONDOA UKWASI (kuunga mkono tokeni za ada-kwa-uhamisho) ****
+    function removeLiquidityETHSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) public virtual override ensure(deadline) returns (uint amountETH) {
+        (, amountETH) = removeLiquidity(
+            token,
+            WETH,
+            liquidity,
+            amountTokenMin,
+            amountETHMin,
+            address(this),
+            deadline
+        );
+        TransferHelper.safeTransfer(token, to, IERC20(token).balanceOf(address(this)));
+        IWETH(WETH).withdraw(amountETH);
+        TransferHelper.safeTransferETH(to, amountETH);
+    }
+
+```
+
+Kazi hii inaweza kutumika kwa tokeni ambazo zina ada za uhamisho au hifadhi. Wakati tokeni ina ada kama hizo hatuwezi kutegemea kazi ya `removeLiquidity` kutuambia ni kiasi gani cha tokeni tunachopata, kwa hivyo tunahitaji kutoa kwanza na kisha kupata salio.
+
+```solidity
+
+
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external virtual override returns (uint amountETH) {
+        address pair = UniswapV2Library.pairFor(factory, token, WETH);
+        uint value = approveMax ? uint(-1) : liquidity;
+        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
+        amountETH = removeLiquidityETHSupportingFeeOnTransferTokens(
+            token, liquidity, amountTokenMin, amountETHMin, to, deadline
+        );
+    }
+```
+
+Shughuli ya mwisho inaunganisha ada za ghala na shughuli za meta.
+
+#### Fanya biashara {#trade}
+
+```solidity
+    // **** BADILISHA ****
+    // inahitaji kiasi cha awali kuwa tayari kimetumwa kwa jozi ya kwanza
+    function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
+```
+
+Shughuli hii hufanya uchakataji wa ndani ambao unahitajika kwa shughuli zinazoonyeshwa kwa wafanyabiashara.
+
+```solidity
+        for (uint i; i < path.length - 1; i++) {
+```
+
+Ninapoandika hivi, kuna [tokeni 388,160 za ERC-20](https://eth.blockscout.com/tokens). Ikiwa kungekuwa na ubadilishanaji wa jozi kwa kila jozi ya tokeni, kungekuwa na zaidi ya ubadilishanaji wa jozi bilioni 150. Mnyororo mzima, kwa sasa, [una akaunti 0.1% tu ya idadi hiyo](https://eth.blockscout.com/stats/accountsGrowth). Badala yake, shughuli za ubadilishaji zinasaidia dhana ya njia. Mfanyabiashara anaweza kubadilisha A kwa B, B kwa C, na C kwa D, kwa hivyo hakuna haja ya ubadilishanaji wa moja kwa moja wa jozi ya A-D.
+
+Bei kwenye masoko haya huwa zinasawazishwa, kwa sababu zinapokuwa hazijasawazishwa, inaunda fursa ya upatanishi. Fikiria, kwa mfano, tokeni tatu, A, B, na C. Kuna ubadilishanaji wa jozi tatu, moja kwa kila jozi.
+
+1. Hali ya awali
+2. Mfanyabiashara anauza tokeni 24.695 za A na anapata tokeni 25.305 za B.
+3. Mfanyabiashara anauza tokeni 24.695 za B kwa tokeni 25.305 za C, akihifadhi takriban tokeni 0.61 za B kama faida.
+4. Kisha mfanyabiashara anauza tokeni 24.695 za C kwa tokeni 25.305 za A, akihifadhi takriban tokeni 0.61 za C kama faida. Mfanyabiashara pia ana tokeni za ziada 0.61 za A (tokeni 25.305 anazopata mwishoni, ukitoa uwekezaji wa awali wa 24.695).
+
+| Hatua | Ubadilishanaji wa A-B                                                                       | Ubadilishanaji wa B-C                                                                       | Ubadilishanaji wa A-C                                                                       |
+| ----- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| 1     | A:1000 B:1050 A/B=1.05                      | B:1000 C:1050 B/C=1.05                      | A:1050 C:1000 C/A=1.05                      |
+| 2     | A:1024.695 B:1024.695 A/B=1 | B:1000 C:1050 B/C=1.05                      | A:1050 C:1000 C/A=1.05                      |
+| 3     | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1050 C:1000 C/A=1.05                      |
+| 4     | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1024.695 C:1024.695 C/A=1 |
+
+```solidity
+            (address input, address output) = (path[i], path[i + 1]);
+            (address token0,) = UniswapV2Library.sortTokens(input, output);
+            uint amountOut = amounts[i + 1];
+```
+
+Pata jozi tunayoishughulikia sasa, ipange (kwa matumizi na jozi hiyo) na upate kiasi kinachotarajiwa cha matokeo.
+
+```solidity
+            (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
+```
+
+Pata kiasi kinachotarajiwa, kikiwa kimepangwa jinsi ubadilishanaji wa jozi unavyotarajia.
+
+```solidity
+            address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
+```
+
+Je, huu ndio ubadilishanaji wa mwisho? Ikiwa ndivyo, tuma tokeni zilizopokelewa kwa ajili ya biashara hiyo kwenye eneo linalolengwa. Ikiwa sivyo, itume kwenye ubadilishanaji wa jozi unaofuata.
+
+```solidity
+
+            IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap(
+                amount0Out, amount1Out, to, new bytes(0)
+            );
+        }
+    }
+```
+
+Ita shughuli ya ubadilishanaji wa jozi ili kubadilisha tokeni. Hatuhitaji kurudishiwa taarifa kuhusu ubadilishanaji, kwa hivyo hatutumi baiti zozote katika sehemu hiyo.
+
+```solidity
+    function swapExactTokensForTokens(
+```
+
+Shughuli hii hutumiwa moja kwa moja na wafanyabiashara kubadilisha tokeni moja kwa nyingine.
+
+```solidity
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+```
+
+Kigezo hiki kina anwani za mikataba ya ERC-20. Kama ilivyoelezwa hapo juu, hii ni safu kwa sababu unaweza kuhitaji kupitia ubadilishanaji kadhaa wa jozi ili kutoka kwenye rasilimali uliyonayo hadi rasilimali unayoitaka.
+
+Kigezo cha shughuli katika Solidity kinaweza kuhifadhiwa aidha katika `memory` au `calldata`. Ikiwa shughuli ni sehemu ya kuingilia kwenye mkataba, inayoitwa moja kwa moja kutoka kwa mtumiaji (kwa kutumia muamala) au kutoka kwa mkataba tofauti, basi thamani ya kigezo inaweza kuchukuliwa moja kwa moja kutoka kwa data ya wito. Ikiwa shughuli inaitwa ndani, kama `_swap` hapo juu, basi vigezo vinapaswa kuhifadhiwa katika `memory`. Kwa mtazamo wa mkataba unaoitwa, `calldata` ni ya kusoma tu.
+
+Kwa aina za scalar kama vile `uint` au `address` mkusanyaji hutushughulikia uchaguzi wa ghala, lakini kwa safu, ambazo ni ndefu na za gharama kubwa zaidi, tunabainisha aina ya ghala itakayotumika.
+
+```solidity
+        address to,
+        uint deadline
+    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
+```
+
+Thamani za kurudisha daima hurudishwa katika memory.
+
+```solidity
+        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
+        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+```
+
+Hesabu kiasi kitakachonunuliwa katika kila ubadilishaji. Ikiwa matokeo ni chini ya kiwango cha chini ambacho mfanyabiashara yuko tayari kukubali, rudisha nyuma muamala.
+
+```solidity
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, to);
+    }
+```
+
+Hatimaye, hamisha tokeni ya awali ya ERC-20 kwenye akaunti kwa ajili ya ubadilishanaji wa jozi ya kwanza na uite `_swap`. Haya yote yanatokea katika muamala mmoja, kwa hivyo ubadilishanaji wa jozi unajua kuwa tokeni zozote zisizotarajiwa ni sehemu ya uhamisho huu.
+
+```solidity
+    function swapTokensForExactTokens(
+        uint amountOut,
+        uint amountInMax,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
+        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
+        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, to);
+    }
+```
+
+Shughuli iliyotangulia, `swapTokensForTokens`, inaruhusu mfanyabiashara kubainisha idadi kamili ya tokeni za ingizo anazotaka kutoa na idadi ya chini zaidi ya tokeni za pato anazotaka kupokea. Shughuli hii hufanya ubadilishaji kinyume, inamruhusu mfanyabiashara kubainisha idadi ya tokeni za pato anazotaka, na idadi ya juu zaidi ya tokeni za ingizo anazotaka kulipia.
+
+Katika visa vyote viwili, mfanyabiashara anapaswa kwanza kuupa mkataba huu wa pembeni ruhusa ili kuuruhusu kuhamisha.
+
+```solidity
+    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        payable
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsOut(factory, msg.value, path);
+        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+        IWETH(WETH).deposit{value: amounts[0]}();
+        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
+        _swap(amounts, path, to);
+    }
+
+
+    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
+        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, address(this));
+        IWETH(WETH).withdraw(amounts[amounts.length - 1]);
+        TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
+    }
+
+
+
+    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
+        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, address(this));
+        IWETH(WETH).withdraw(amounts[amounts.length - 1]);
+        TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
+    }
+
+
+    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        payable
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
+        require(amounts[0] <= msg.value, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
+        IWETH(WETH).deposit{value: amounts[0]}();
+        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
+        _swap(amounts, path, to);
+        // refund dust eth, if any
+        if (msg.value > amounts[0]) TransferHelper.safeTransferETH(msg.sender, msg.value - amounts[0]);
+    }
+```
+
+Aina hizi nne zote zinahusisha biashara kati ya ETH na tokeni. Tofauti pekee ni kwamba tunapokea ETH kutoka kwa mfanyabiashara na kuitumia kuunda WETH, au tunapokea WETH kutoka kwa ubadilishanaji wa mwisho katika njia na kuiteketeza, na kumrudishia mfanyabiashara ETH inayotokana.
+
+```solidity
+    // **** BADILISHA (inasaidia tokeni za ada-kwa-uhamisho) ****
+    // inahitaji kiasi cha awali kuwa tayari kimetumwa kwa jozi ya kwanza
+    function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual {
+```
+
+Hii ni shughuli ya ndani ya kubadilisha tokeni ambazo zina ada za uhamisho au ghala ili kutatua ([suala hili](https://github.com/Uniswap/uniswap-interface/issues/835)).
+
+```solidity
+        for (uint i; i < path.length - 1; i++) {
+            (address input, address output) = (path[i], path[i + 1]);
+            (address token0,) = UniswapV2Library.sortTokens(input, output);
+            IUniswapV2Pair pair = IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output));
+            uint amountInput;
+            uint amountOutput;
+            { // wigo wa kuepuka makosa ya "stack too deep"
+            (uint reserve0, uint reserve1,) = pair.getReserves();
+            (uint reserveInput, uint reserveOutput) = input == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+            amountInput = IERC20(input).balanceOf(address(pair)).sub(reserveInput);
+            amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput);
+```
+
+Kwa sababu ya ada za uhamisho, hatuwezi kutegemea shughuli ya `getAmountsOut` kutuambia ni kiasi gani tunapata kutoka kwa kila uhamisho (kama tunavyofanya kabla ya kuita `_swap` ya awali). Badala yake, inabidi tuhamishe kwanza kisha tuone ni tokeni ngapi tulipata.
+
+Kumbuka: Kinadharia tungeweza tu kutumia shughuli hii badala ya `_swap`, lakini katika hali fulani (kwa mfano, ikiwa uhamisho utaishia kurejeshwa kwa sababu hakuna kiasi cha kutosha mwishoni kufikia kiwango cha chini kinachohitajika) hiyo ingegharimu gesi zaidi. Tokeni za ada za uhamisho ni nadra sana, kwa hivyo ingawa tunahitaji kuzijumuisha, hakuna haja ya ubadilishaji wote kudhani kuwa zinapitia angalau mojawapo.
+
+```solidity
+            }
+            (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOutput) : (amountOutput, uint(0));
+            address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
+            pair.swap(amount0Out, amount1Out, to, new bytes(0));
+        }
+    }
+
+
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external virtual override ensure(deadline) {
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
+        );
+        uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
+        _swapSupportingFeeOnTransferTokens(path, to);
+        require(
+            IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
+            'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
+        );
+    }
+
+
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    )
+        external
+        virtual
+        override
+        payable
+        ensure(deadline)
+    {
+        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
+        uint amountIn = msg.value;
+        IWETH(WETH).deposit{value: amountIn}();
+        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn));
+        uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
+        _swapSupportingFeeOnTransferTokens(path, to);
+        require(
+            IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
+            'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
+        );
+    }
+
+
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    )
+        external
+        virtual
+        override
+        ensure(deadline)
+    {
+        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
+        );
+        _swapSupportingFeeOnTransferTokens(path, address(this));
+        uint amountOut = IERC20(WETH).balanceOf(address(this));
+        require(amountOut >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+        IWETH(WETH).withdraw(amountOut);
+        TransferHelper.safeTransferETH(to, amountOut);
+    }
+```
+
+Hizi ni aina zilezile zinazotumika kwa tokeni za kawaida, lakini zinaita `_swapSupportingFeeOnTransferTokens` badala yake.
+
+```solidity
+    // **** SHUGHULI ZA MAKTABA ****
+    function quote(uint amountA, uint reserveA, uint reserveB) public pure virtual override returns (uint amountB) {
+        return UniswapV2Library.quote(amountA, reserveA, reserveB);
+    }
+
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut)
+        public
+        pure
+        virtual
+        override
+        returns (uint amountOut)
+    {
+        return UniswapV2Library.getAmountOut(amountIn, reserveIn, reserveOut);
+    }
+
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut)
+        public
+        pure
+        virtual
+        override
+        returns (uint amountIn)
+    {
+        return UniswapV2Library.getAmountIn(amountOut, reserveIn, reserveOut);
+    }
+
+    function getAmountsOut(uint amountIn, address[] memory path)
+        public
+        view
+        virtual
+        override
+        returns (uint[] memory amounts)
+    {
+        return UniswapV2Library.getAmountsOut(factory, amountIn, path);
+    }
+
+    function getAmountsIn(uint amountOut, address[] memory path)
+        public
+        view
+        virtual
+        override
+        returns (uint[] memory amounts)
+    {
+        return UniswapV2Library.getAmountsIn(factory, amountOut, path);
+    }
+}
+```
+
+Shughuli hizi ni proksi tu zinazoita [shughuli za UniswapV2Library](#uniswapV2library).
+
+### UniswapV2Migrator.sol {#UniswapV2Migrator}
+
+Mkataba huu ulitumika kuhamisha ubadilishanaji kutoka v1 ya zamani hadi v2. Sasa kwa kuwa zimehamishwa, haihusiki tena.
+
+## Maktaba {#libraries}
+
+[Maktaba ya SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math) imeandikwa vizuri, kwa hivyo hakuna haja ya kuiandika hapa.
+
+### Hisabati {#Math}
+
+Maktaba hii ina baadhi ya shughuli za hisabati ambazo kwa kawaida hazihitajiki katika msimbo wa Solidity, kwa hivyo si sehemu ya lugha.
+
+```solidity
+pragma solidity =0.5.16;
+
+// maktaba ya kufanya shughuli mbalimbali za hisabati
+
+library Math {
+    function min(uint x, uint y) internal pure returns (uint z) {
+        z = x < y ? x : y;
+    }
+
+    // njia ya kibabiloni (https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
+    function sqrt(uint y) internal pure returns (uint z) {
+        if (y > 3) {
+            z = y;
+            uint x = y / 2 + 1;
+```
+
+Anza na x kama makadirio ambayo ni ya juu kuliko kipeuo cha pili (ndiyo sababu tunahitaji kushughulikia 1-3 kama kesi maalum).
+
+```solidity
+            while (x < z) {
+                z = x;
+                x = (y / x + x) / 2;
+```
+
+Pata makadirio ya karibu zaidi, wastani wa makadirio ya awali na nambari ambayo tunajaribu kupata kipeuo chake cha pili ukigawanya kwa makadirio ya awali. Rudia hadi makadirio mapya yasiwe chini ya yale yaliyopo. Kwa maelezo zaidi, [angalia hapa](https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method).
+
+```solidity
+            }
+        } else if (y != 0) {
+            z = 1;
+```
+
+Hatupaswi kamwe kuhitaji kipeuo cha pili cha sifuri. Vipeuo vya pili vya moja, mbili, na tatu ni takriban moja (tunatumia nambari kamili, kwa hivyo tunapuuza sehemu).
+
+```solidity
+        }
+    }
+}
+```
+
+### Sehemu za Nukta Zisizobadilika (UQ112x112) {#FixedPoint}
+
+Maktaba hii hushughulikia sehemu, ambazo kwa kawaida si sehemu ya hesabu za Ethereum. Hufanya hivi kwa kusimba nambari _x_ kama _x\*2^112_. Hii inaturuhusu kutumia opcodes za awali za kujumlisha na kutoa bila mabadiliko.
+
+```solidity
+pragma solidity =0.5.16;
+
+// maktaba ya kushughulikia nambari za nukta zisizobadilika za binary (https://wikipedia.org/wiki/Q_(number_format))
+
+// masafa: [0, 2**112 - 1]
+// azimio: 1 / 2**112
+
+library UQ112x112 {
+    uint224 constant Q112 = 2**112;
+```
+
+`Q112` ni usimbaji kwa moja.
+
+```solidity
+    // simba uint112 kama UQ112x112
+    function encode(uint112 y) internal pure returns (uint224 z) {
+        z = uint224(y) * Q112; // haifuriki kamwe
+    }
+```
+
+Kwa sababu y ni `uint112`, thamani yake kubwa zaidi inaweza kuwa 2^112-1. Nambari hiyo bado inaweza kusimbwa kama `UQ112x112`.
+
+```solidity
+    // gawanya UQ112x112 kwa uint112, kurudisha UQ112x112
+    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
+        z = x / uint224(y);
+    }
+}
+```
+
+Tukigawanya thamani mbili za `UQ112x112`, matokeo hayazidishwi tena na 2^112. Kwa hivyo badala yake tunachukua nambari kamili kwa ajili ya denomineta. Tungehitaji kutumia mbinu kama hiyo kufanya kuzidisha, lakini hatuhitaji kufanya kuzidisha kwa thamani za `UQ112x112`.
+
+### UniswapV2Library {#uniswapV2library}
+
+Maktaba hii inatumiwa tu na mikataba ya pembeni
+
+```solidity
+pragma solidity >=0.5.0;
+
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
+
+import "./SafeMath.sol";
+
+library UniswapV2Library {
+    using SafeMath for uint;
+
+    // inarudisha anwani za tokeni zilizopangwa, zinazotumika kushughulikia thamani za kurudisha kutoka kwa jozi zilizopangwa kwa utaratibu huu
+    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
+        require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
+        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+        require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
+    }
+```
+
+Panga tokeni mbili kwa anwani, ili tuweze kupata anwani ya ubadilishanaji wa jozi kwa ajili yao. Hii ni muhimu kwa sababu vinginevyo tungekuwa na uwezekano mbili, moja kwa vigezo A,B na nyingine kwa vigezo B,A, na kusababisha ubadilishanaji mbili badala ya moja.
+
+```solidity
+    // huhesabu anwani ya CREATE2 kwa jozi bila kufanya wito wowote wa nje
+    function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
+        (address token0, address token1) = sortTokens(tokenA, tokenB);
+        pair = address(uint(keccak256(abi.encodePacked(
+                hex'ff',
+                factory,
+                keccak256(abi.encodePacked(token0, token1)),
+                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // hashi ya msimbo wa kuanzisha
+            ))));
+    }
+```
+
+Shughuli hii huhesabu anwani ya ubadilishanaji wa jozi kwa tokeni hizo mbili. Mkataba huu umeundwa kwa kutumia [opcode ya CREATE2](https://eips.ethereum.org/EIPS/eip-1014), kwa hivyo tunaweza kuhesabu anwani kwa kutumia algoriti ileile ikiwa tunajua vigezo inavyotumia. Hii ni nafuu sana kuliko kuuliza kiwanda, na
+
+```solidity
+    // huchukua na kupanga hifadhi za jozi
+    function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
+        (address token0,) = sortTokens(tokenA, tokenB);
+        (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
+        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+    }
+```
+
+Shughuli hii inarudisha hifadhi za tokeni mbili ambazo ubadilishanaji wa jozi unazo. Kumbuka kuwa inaweza kupokea tokeni kwa mpangilio wowote, na kuzipanga kwa matumizi ya ndani.
+
+```solidity
+    // kwa kuzingatia kiasi fulani cha rasilimali na hifadhi za jozi, inarudisha kiasi sawa cha rasilimali nyingine
+    function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
+        require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
+        require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+        amountB = amountA.mul(reserveB) / reserveA;
+    }
+```
+
+Shughuli hii inakupa kiasi cha tokeni B utakachopata kwa kubadilishana na tokeni A ikiwa hakuna ada inayohusika. Hesabu hii inazingatia kwamba uhamisho hubadilisha kiwango cha ubadilishaji.
+
+```solidity
+    // kwa kuzingatia kiasi cha ingizo cha rasilimali na hifadhi za jozi, inarudisha kiasi cha juu cha pato la rasilimali nyingine
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
+```
+
+Shughuli ya `quote` hapo juu inafanya kazi vizuri ikiwa hakuna ada ya kutumia ubadilishanaji wa jozi. Hata hivyo, ikiwa kuna ada ya ubadilishaji ya 0.3%, kiasi unachopata hasa ni kidogo. Shughuli hii huhesabu kiasi baada ya ada ya ubadilishaji.
+
+```solidity
+
+        require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
+        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+        uint amountInWithFee = amountIn.mul(997);
+        uint numerator = amountInWithFee.mul(reserveOut);
+        uint denominator = reserveIn.mul(1000).add(amountInWithFee);
+        amountOut = numerator / denominator;
+    }
+```
+
+Solidity haishughulikii sehemu kwa asili, kwa hivyo hatuwezi tu kuzidisha kiasi cha pato kwa 0.997. Badala yake, tunazidisha nambari ya juu (numerator) kwa 997 na nambari ya chini (denominator) kwa 1000, na kupata athari sawa.
+
+```solidity
+    // kwa kuzingatia kiasi cha pato cha rasilimali na hifadhi za jozi, inarudisha kiasi kinachohitajika cha ingizo la rasilimali nyingine
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
+        require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
+        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+        uint numerator = reserveIn.mul(amountOut).mul(1000);
+        uint denominator = reserveOut.sub(amountOut).mul(997);
+        amountIn = (numerator / denominator).add(1);
+    }
+```
+
+Shughuli hii hufanya takribani kitu kilekile, lakini inapata kiasi cha pato na kutoa ingizo.
+
+```solidity
+
+    // hufanya hesabu za mnyororo za getAmountOut kwenye idadi yoyote ya jozi
+    function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
+        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
+        amounts = new uint[](path.length);
+        amounts[0] = amountIn;
+        for (uint i; i < path.length - 1; i++) {
+            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
+            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    // hufanya hesabu za mnyororo za getAmountIn kwenye idadi yoyote ya jozi
+    function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
+        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
+        amounts = new uint[](path.length);
+        amounts[amounts.length - 1] = amountOut;
+        for (uint i = path.length - 1; i > 0; i--) {
+            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
+            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
+        }
+    }
+}
+```
+
+Shughuli hizi mbili hushughulikia utambuzi wa thamani wakati inahitajika kupitia ubadilishanaji kadhaa wa jozi.
+
+### Msaidizi wa Uhamisho {#transfer-helper}
+
+[Maktaba hii](https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol) huongeza ukaguzi wa mafanikio karibu na uhamisho wa ERC-20 na Ethereum ili kushughulikia urejeshaji na urejeshaji wa thamani ya `false` kwa njia ileile.
+
+```solidity
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity >=0.6.0;
+
+// njia za msaada za kuingiliana na tokeni za ERC20 na kutuma ETH ambazo hazirudishi true/false kwa uthabiti
+library TransferHelper {
+    function safeApprove(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        // bytes4(keccak256(bytes('approve(address,uint256)')));
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
+
+```
+
+Tunaweza kuita mkataba tofauti kwa mojawapo ya njia mbili:
+
+- Tumia ufafanuzi wa kiolesura kuunda wito wa shughuli
+- Tumia [kiolesura cha binary cha programu (ABI)](https://docs.soliditylang.org/en/v0.8.3/abi-spec.html) "kwa mikono" kuunda wito. Hivi ndivyo mwandishi wa msimbo aliamua kuifanya.
+
+```solidity
+        require(
+            success && (data.length == 0 || abi.decode(data, (bool))),
+            'TransferHelper::safeApprove: approve failed'
+        );
+    }
+```
+
+Kwa ajili ya utangamano wa nyuma na tokeni zilizoundwa kabla ya kiwango cha ERC-20, wito wa ERC-20 unaweza kushindwa ama kwa kurejesha (ambapo `success` ni `false`) au kwa kufanikiwa na kurudisha thamani ya `false` (ambapo kuna data ya pato, na ukii-decode kama boolean unapata `false`).
+
+```solidity
+
+
+    function safeTransfer(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        // bytes4(keccak256(bytes('transfer(address,uint256)')));
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
+        require(
+            success && (data.length == 0 || abi.decode(data, (bool))),
+            'TransferHelper::safeTransfer: transfer failed'
+        );
+    }
+```
+
+Shughuli hii inatekeleza [utendaji wa uhamisho wa ERC-20](https://eips.ethereum.org/EIPS/eip-20#transfer), ambayo inaruhusu akaunti kutumia ruhusa iliyotolewa na akaunti tofauti.
+
+```solidity
+
+    function safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
+        require(
+            success && (data.length == 0 || abi.decode(data, (bool))),
+            'TransferHelper::transferFrom: transferFrom failed'
+        );
+    }
+```
+
+Shughuli hii inatekeleza [utendaji wa transferFrom wa ERC-20](https://eips.ethereum.org/EIPS/eip-20#transferfrom), ambayo inaruhusu akaunti kutumia ruhusa iliyotolewa na akaunti tofauti.
+
+```solidity
+
+    function safeTransferETH(address to, uint256 value) internal {
+        (bool success, ) = to.call{value: value}(new bytes(0));
+        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
+    }
+}
+```
+
+Shughuli hii huhamisha ether kwenye akaunti. Wito wowote kwa mkataba tofauti unaweza kujaribu kutuma ether. Kwa sababu hatuhitaji hasa kuita shughuli yoyote, hatutumi data yoyote na wito huo.
+
+## Hitimisho {#conclusion}
+
+Hii ni makala ndefu ya takriban kurasa 50. Ikiwa umefika hapa, hongera! Tunatumai sasa umeelewa mazingatio katika kuandika programu halisi ya maisha (kinyume na programu fupi za sampuli) na uko tayari zaidi kuweza kuandika mikataba kwa ajili ya matumizi yako mwenyewe.
+
+Sasa nenda ukaandike kitu muhimu na utushangaze.
+
+[Tazama hapa kwa kazi zangu zaidi](https://cryptodocguy.pro/).
diff --git a/public/content/translations/sw/developers/tutorials/using-websockets/index.md b/public/content/translations/sw/developers/tutorials/using-websockets/index.md
new file mode 100644
index 00000000000..bc606aa7f63
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/using-websockets/index.md
@@ -0,0 +1,245 @@
+---
+title: Kutumia WebSockets
+description: Mwongozo wa kutumia WebSockets na Alchemy kufanya maombi ya JSON-RPC na kujiandikisha kwa matukio.
+author: "Elan Halpern"
+lang: sw
+tags: [ "alchemy", "websockets", "kuuliza", "javascript" ]
+skill: beginner
+source: Alchemy docs
+sourceUrl: https://www.alchemy.com/docs/reference/best-practices-for-using-websockets-in-web3
+published: 2020-12-01
+---
+
+Huu ni mwongozo wa kiwango cha mwanzo wa kutumia WebSockets na Alchemy kufanya maombi kwa mnyororo wa bloku wa Ethereum.
+
+## WebSockets dhidi ya HTTP {#websockets-vs-http}
+
+Tofauti na HTTP, ukiwa na WebSockets, huhitaji kuendelea kufanya maombi unapotaka taarifa maalum. WebSockets hudumisha muunganisho wa mtandao kwa ajili yako (ikifanywa ipasavyo) na husikiliza mabadiliko.
+
+Kama ilivyo kwa muunganisho wowote wa mtandao, hupaswi kudhania kuwa WebSocket itabaki wazi milele bila kukatizwa, lakini kushughulikia ipasavyo miunganisho iliyokatika na kuunganisha upya kwa mikono kunaweza kuwa changamoto kupata usahihi. Upande mwingine mbaya wa WebSockets ni kwamba hupati misimbo ya hali ya HTTP katika jibu, bali ujumbe wa hitilafu pekee.
+
+[Alchemy Web3](https://docs.alchemy.com/reference/api-overview) huongeza kiotomatiki ushughulikiaji wa hitilafu za WebSocket na hujaribu tena bila usanidi unaohitajika.
+
+## Ijaribu {#try-it-out}
+
+Njia rahisi zaidi ya kujaribu WebSockets ni kusakinisha zana ya mstari wa amri ya kufanya maombi ya WebSocket kama vile [wscat](https://github.com/websockets/wscat). Kwa kutumia wscat, unaweza kutuma maombi kama ifuatavyo:
+
+_Kumbuka: ikiwa una akaunti ya Alchemy unaweza kubadilisha `demo` na ufunguo wako mwenyewe wa API._ [Jisajili kwa akaunti ya bure ya Alchemy hapa!](https://auth.alchemy.com/signup)_
+
+```
+wscat -c wss://eth-mainnet.ws.alchemyapi.io/ws/demo
+
+>  {"jsonrpc":  "2.0", "id": 0, "method":  "eth_gasPrice"}
+
+<  {"jsonrpc":  "2.0", "result":  "0xb2d05e00", "id": 0}
+
+```
+
+## Jinsi ya kutumia WebSockets {#how-to-use-websockets}
+
+Ili kuanza, fungua WebSocket kwa kutumia URL ya WebSocket kwa ajili ya programu yako. Unaweza kupata URL ya WebSocket ya programu yako kwa kufungua ukurasa wa programu katika [dashibodi yako](https://dashboard.alchemy.com/) na kubofya "Tazama Ufunguo". Kumbuka kwamba URL ya programu yako kwa WebSockets ni tofauti na URL yake kwa maombi ya HTTP, lakini zote zinaweza kupatikana kwa kubofya "Tazama Ufunguo".
+
+![Wapi pa kupata URL yako ya WebSocket katika dashibodi yako ya Alchemy](./use-websockets.gif)
+
+API zozote zilizoorodheshwa katika [Marejeleo ya API ya Alchemy](https://www.alchemy.com/docs/reference/api-overview) zinaweza kutumika kupitia WebSocket. Ili kufanya hivyo, tumia malipo yale yale ambayo yangetumwa kama sehemu kuu ya ombi la HTTP POST, lakini badala yake tuma malipo hayo kupitia WebSocket.
+
+## Na Web3 {#with-web3}
+
+Kubadilisha na kuanza kutumia WebSockets unapotumia maktaba ya mteja kama Web3 ni rahisi. Peleka tu URL ya WebSocket badala ya ile ya HTTP unapounda mteja wako wa Web3. Kwa mfano:
+
+```js
+const web3 = new Web3("wss://eth-mainnet.ws.alchemyapi.io/ws/your-api-key")
+
+web3.eth.getBlockNumber().then(console.log) // -> 7946893
+```
+
+## API ya Usajili {#subscription-api}
+
+Unapounganishwa kupitia WebSocket, unaweza kutumia mbinu mbili za ziada: `eth_subscribe` na `eth_unsubscribe`. Mbinu hizi zitakuruhusu kusikiliza matukio maalum na kuarifiwa mara moja.
+
+### `eth_subscribe` {#eth-subscribe}
+
+Huunda usajili mpya kwa matukio maalum. [Jifunze zaidi kuhusu `eth_subscribe`](https://docs.alchemy.com/reference/eth-subscribe).
+
+#### Vigezo {#parameters}
+
+1. Aina za usajili
+2. Vigezo vya hiari
+
+Hoja ya kwanza inabainisha aina ya tukio la kusikiliza. Hoja ya pili ina chaguo za ziada ambazo hutegemea hoja ya kwanza. Aina tofauti za maelezo, chaguo zao, na malipo ya tukio zao yameelezwa hapa chini.
+
+#### Inarejesha {#returns}
+
+Kitambulisho cha usajili: Kitambulisho hiki kitaambatanishwa na matukio yoyote yaliyopokelewa, na pia kinaweza kutumika kughairi usajili kwa kutumia `eth_unsubscribe`.
+
+#### Matukio ya usajili {#subscription-events}
+
+Wakati usajili unatumika, utapokea matukio ambayo ni vitu vyenye sehemu zifuatazo:
+
+- `jsonrpc`: Daima "2.0"
+- `method`: Daima "eth_subscription"
+- `params`: Kitu chenye sehemu zifuatazo:
+  - `subscription`: Kitambulisho cha usajili kilichorejeshwa na mwito wa `eth_subscribe` ambao uliunda usajili huu.
+  - `result`: Kitu ambacho maudhui yake hutofautiana kulingana na aina ya usajili.
+
+#### Aina za usajili {#subscription-types}
+
+1. `alchemy_newFullPendingTransactions`
+
+Hurejesha taarifa za muamala kwa miamala yote ambayo imeongezwa kwenye hali ya kusubiri. Aina hii ya usajili hujiandikisha kwa miamala inayosubiri, sawa na mwito wa kawaida wa Web3 `web3.eth.subscribe("pendingTransactions")`, lakini inatofautiana kwa kuwa inatoa _taarifa kamili ya muamala_ badala ya hashi za muamala pekee.
+
+Mfano:
+
+```json
+>  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["alchemy_newFullPendingTransactions"]}
+
+<  {"id":1,"result":"0x9a52eeddc2b289f985c0e23a7d8427c8","jsonrpc":"2.0"}
+<  {
+      "jsonrpc":"2.0",
+      "method":"eth_subscription",
+      "params":{
+          "result":{
+          "blockHash":null,
+          "blockNumber":null,
+          "from":"0xa36452fc31f6f482ad823cd1cf5515177d57667f",
+          "gas":"0x1adb0",
+          "gasPrice":"0x7735c4d40",
+          "hash":"0x50bff0736c713458c92dd1848d12f3354149be1363123dae35e94e0f2a9d56bf",
+"input":"0xa9059cbb0000000000000000000000000d0707963952f2fba59dd06f2b425ace40b492fe0000000000000000000000000000000000000000000015b1111266cfca100000",
+          "nonce":"0x0",
+          "to":"0xea38eaa3c86c8f9b751533ba2e562deb9acded40",
+          "transactionIndex":null,
+          "value":"0x0",
+          "v":"0x26",
+          "r":"0x195c2c1ed126088e12d290aa93541677d3e3b1d10f137e11f86b1b9227f01e3b",
+          "s":"0x60fc4edbf1527832a2a36dbc1e63ed6193a6eee654472fbebbf88ef1750b5344"},
+          "subscription":"0x9a52eeddc2b289f985c0e23a7d8427c8"
+      }
+  }
+
+```
+
+2. `newHeads`
+
+Hutoa tukio wakati wowote kichwa kipya kinapoongezwa kwenye mnyororo, ikiwa ni pamoja na wakati wa upangaji upya wa mnyororo.
+
+Wakati upangaji upya wa mnyororo unapotokea, usajili huu utatoa tukio lenye vichwa vyote vipya vya mnyororo mpya. Hasa, hii inamaanisha kuwa unaweza kuona vichwa vingi vikitolewa vikiwa na urefu sawa, na hili linapotokea kichwa cha baadaye kinapaswa kuchukuliwa kuwa ndicho sahihi baada ya upangaji upya.
+
+Mfano:
+
+```json
+>  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["newHeads"]}
+
+<  {"jsonrpc":"2.0","id":2,"result":"0x9ce59a13059e417087c02d3236a0b1cc"}
+<  {
+  "jsonrpc":  "2.0",
+  "method":  "eth_subscription",
+  "params":  {
+      "result":  {
+          "extraData":  "0xd983010305844765746887676f312e342e328777696e646f7773",
+          "gasLimit":  "0x47e7c4",
+          "gasUsed":  "0x38658",
+          "logsBloom":
+"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+          "nonce":  "0x084149998194cc5f",
+          "number":  "0x1348c9",
+          "parentHash":  "0x7736fab79e05dc611604d22470dadad26f56fe494421b5b333de816ce1f25701",
+          "receiptRoot":  "0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36",
+          "sha3Uncles":  "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+          "stateRoot":  "0xb3346685172db67de536d8765c43c31009d0eb3bd9c501c9be3229203f15f378",
+          "timestamp":  "0x56ffeff8",
+          "transactionsRoot":  "0x0167ffa60e3ebc0b080cdb95f7c0087dd6c0e61413140e39d94d3468d7c9689f"
+      },
+  "subscription":  "0x9ce59a13059e417087c02d3236a0b1cc"
+  }
+}
+
+```
+
+3. `logs`
+
+Hutoa kumbukumbu ambazo ni sehemu ya bloku mpya zilizoongezwa zinazolingana na vigezo maalum vya kichujio.
+
+Wakati upangaji upya wa mnyororo unapotokea, kumbukumbu ambazo ni sehemu ya bloku kwenye mnyororo wa zamani zitatolewa tena na sifa ya `removed` ikiwa imewekwa kuwa `true`. Zaidi ya hayo, kumbukumbu ambazo ni sehemu ya bloku kwenye mnyororo mpya hutolewa, ikimaanisha kwamba inawezekana kuona kumbukumbu za muamala uleule mara nyingi katika kisa cha upangaji upya.
+
+Vigezo
+
+1. Kitu chenye sehemu zifuatazo:
+   - `address` (hiari): ama mfuatano unaowakilisha anwani au safu ya mifuatano kama hiyo.
+     - Kumbukumbu zilizoundwa kutoka kwa mojawapo ya anwani hizi pekee ndizo zitatolewa.
+   - `topics`: safu ya vibainishi vya mada.
+     - Kila kibainishi cha mada ni ama `null`, mfuatano unaowakilisha mada, au safu ya mifuatano.
+     - Kila nafasi katika safu ambayo si `null` inazuia kumbukumbu zinazotolewa kwa zile tu ambazo zina moja ya mada zilizotolewa katika nafasi hiyo.
+
+Baadhi ya mifano ya vipimo vya mada:
+
+- `[]`: Mada zozote zinaruhusiwa.
+- `[A]`: A katika nafasi ya kwanza (na chochote baada yake).
+- `[null, B]`: Chochote katika nafasi ya kwanza na B katika nafasi ya pili (na chochote baada yake).
+- `[A, B]`: A katika nafasi ya kwanza na B katika nafasi ya pili (na chochote baada yake).
+- `[[A, B], [A, B]]`: (A au B) katika nafasi ya kwanza na (A au B) katika nafasi ya pili (na chochote baada yake).
+
+Mfano:
+
+```json
+>  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["logs",  {"address":  "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd",  "topics":  ["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}
+
+<  {"jsonrpc":"2.0","id":2,"result":"0x4a8a4c0517381924f9838102c5a4dcb7"}
+<  {
+  "jsonrpc":  "2.0",
+  "method":  "eth_subscription",
+  "params":  {
+      "subscription":  "0x4a8a4c0517381924f9838102c5a4dcb7",
+      "result":  {
+          "address":  "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd",
+          "blockHash":  "0x61cdb2a09ab99abf791d474f20c2ea89bf8de2923a2d42bb49944c8c993cbf04",
+          "blockNumber":  "0x29e87",
+          "data": "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000003",
+          "logIndex":"0x0",
+          "topics":["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"],
+          "transactionHash":  "0xe044554a0a55067caafd07f8020ab9f2af60bdfe337e395ecd84b4877a3d1ab4",
+          "transactionIndex":  "0x0"
+      }
+  }
+}
+
+```
+
+### `eth_unsubscribe` {#eth-unsubscribe}
+
+Hughairi usajili uliopo ili kusiwe na matukio zaidi yatakayotumwa.
+
+Vigezo
+
+1. Kitambulisho cha Usajili, kama ilivyorejeshwa awali kutoka kwa mwito wa `eth_subscribe`.
+
+Inarejesha
+
+`true` ikiwa usajili umeghairiwa kwa mafanikio, au `false` ikiwa hakuna usajili uliokuwepo na kitambulisho kilichotolewa.
+
+Mfano:
+
+**Ombi**
+
+```
+curl https://eth-mainnet.alchemyapi.io/v2/your-api-key
+-X POST
+-H "Content-Type: application/json"
+-d '{"id": 1, "method": "eth_unsubscribe", "params": ["0x9cef478923ff08bf67fde6c64013158d"]}'
+
+
+```
+
+**Matokeo**
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": true
+}
+```
+
+---
+
+[Jisajili na Alchemy](https://auth.alchemy.com) bila malipo, angalia [nyaraka zetu](https://www.alchemy.com/docs/), na kwa habari za hivi punde, tufuate kwenye [Twitter](https://x.com/AlchemyPlatform).
diff --git a/public/content/translations/sw/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md b/public/content/translations/sw/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
new file mode 100644
index 00000000000..c130edb8393
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
@@ -0,0 +1,300 @@
+---
+title: "Waffle: Uigaji unaobadilika na kupima wito wa mkataba"
+description: Mafunzo ya kina ya Waffle kwa kutumia uigaji unaobadilika na kupima wito wa mkataba
+author: "Daniel Izdebski"
+tags:
+  [
+    "waffle",
+    "mikataba erevu",
+    "uimara",
+    "majaribio",
+    "kuiga"
+  ]
+skill: intermediate
+lang: sw
+published: 2020-11-14
+---
+
+## Mafunzo haya yanahusu nini? {#what-is-this-tutorial-about}
+
+Katika mafunzo haya utajifunza jinsi ya:
+
+- kutumia uigaji unaobadilika
+- kupima mwingiliano kati ya mikataba-erevu
+
+Mawazo:
+
+- tayari unajua jinsi ya kuandika mkataba-erevu rahisi katika `Solidity`
+- unafahamu vizuri `JavaScript` na `TypeScript`
+- umefanya mafunzo mengine ya `Waffle` au unajua kitu kimoja au viwili kuihusu
+
+## Uigaji unaobadilika {#dynamic-mocking}
+
+Kwa nini uigaji unaobadilika ni muhimu? Naam, inaturuhusu kuandika majaribio ya kitengo badala ya majaribio ya ujumuishaji. Hii inamaanisha nini? Inamaanisha kuwa hatuhitaji kuwa na wasiwasi kuhusu utegemezi wa mikataba-erevu, hivyo tunaweza kupima zote kwa kujitenga kabisa. Acha nikuonyeshe jinsi unavyoweza kufanya hivyo.
+
+### **1. Mradi** {#1-project}
+
+Kabla hatujaanza tunahitaji kuandaa mradi rahisi wa node.js:
+
+```bash
+mkdir dynamic-mocking
+cd dynamic-mocking
+mkdir contracts src
+
+yarn init
+# au kama unatumia npm
+npm init
+```
+
+Tuanze kwa kuongeza typescript na tegemezi za majaribio - mocha & chai:
+
+```bash
+yarn add --dev @types/chai @types/mocha chai mocha ts-node typescript
+# au kama unatumia npm
+npm install @types/chai @types/mocha chai mocha ts-node typescript --save-dev
+```
+
+Sasa tuongeze `Waffle` na `ethers`:
+
+```bash
+yarn add --dev ethereum-waffle ethers
+# au kama unatumia npm
+npm install ethereum-waffle ethers --save-dev
+```
+
+Muundo wa mradi wako unapaswa kuonekana hivi sasa:
+
+```
+.
+├── contracts
+├── package.json
+└── test
+```
+
+### **2. Mkataba-erevu** {#2-smart-contract}
+
+Ili kuanza uigaji unaobadilika, tunahitaji mkataba-erevu wenye utegemezi. Usijali, nimekusaidia!
+
+Huu hapa ni mkataba-erevu rahisi ulioandikwa kwa `Solidity` ambao lengo lake pekee ni kuangalia kama sisi ni matajiri. Inatumia tokeni ya ERC20 kuangalia kama tuna tokeni za kutosha. Weka katika `./contracts/AmIRichAlready.sol`.
+
+```solidity
+pragma solidity ^0.6.2;
+
+interface IERC20 {
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract AmIRichAlready {
+    IERC20 private tokenContract;
+    uint public richness = 1000000 * 10 ** 18;
+
+    constructor (IERC20 _tokenContract) public {
+        tokenContract = _tokenContract;
+    }
+
+    function check() public view returns (bool) {
+        uint balance = tokenContract.balanceOf(msg.sender);
+        return balance > richness;
+    }
+}
+```
+
+Kwa vile tunataka kutumia uigaji unaobadilika hatuhitaji ERC20 nzima, ndiyo maana tunatumia kiolesura cha IERC20 chenye chaguo moja la kukokotoa.
+
+Ni wakati wa kujenga mkataba huu! Kwa ajili hiyo tutatumia `Waffle`. Kwanza, tutaenda kuunda faili rahisi ya usanidi ya `waffle.json` inayobainisha chaguo za ujenzi.
+
+```json
+{
+  "compilerType": "solcjs",
+  "compilerVersion": "0.6.2",
+  "sourceDirectory": "./contracts",
+  "outputDirectory": "./build"
+}
+```
+
+Sasa tuko tayari kujenga mkataba kwa kutumia Waffle:
+
+```bash
+npx waffle
+```
+
+Rahisi, sivyo? Katika folda ya `build/` faili mbili zinazolingana na mkataba na kiolesura zimeonekana. Tutazitumia baadaye kwa ajili ya majaribio.
+
+### **3. Kupima** {#3-testing}
+
+Tuunde faili inayoitwa `AmIRichAlready.test.ts` kwa ajili ya majaribio halisi. Kwanza kabisa, tunapaswa kushughulikia uingizaji. Tutazihitaji baadaye:
+
+```typescript
+import { expect, use } from "chai"
+import { Contract, utils, Wallet } from "ethers"
+import {
+  deployContract,
+  deployMockContract,
+  MockProvider,
+  solidity,
+} from "ethereum-waffle"
+```
+
+Isipokuwa tegemezi za JS, tunahitaji kuingiza mkataba wetu uliojengwa na kiolesura:
+
+```typescript
+import IERC20 from "../build/IERC20.json"
+import AmIRichAlready from "../build/AmIRichAlready.json"
+```
+
+Waffle hutumia `chai` kwa ajili ya majaribio. Hata hivyo, kabla hatujaweza kuitumia, tunapaswa kuingiza vilinganishi vya Waffle ndani ya chai yenyewe:
+
+```typescript
+use(solidity)
+```
+
+Tunahitaji kutekeleza chaguo la kukokotoa la `beforeEach()` litaloweka upya hali ya mkataba kabla ya kila jaribio. Tufikirie kwanza kile tunachohitaji hapo. Ili kupeleka mkataba tunahitaji vitu viwili: mkoba na mkataba wa ERC20 uliotumwa ili kuupitisha kama hoja kwa mkataba wa `AmIRichAlready`.
+
+Kwanza tunatengeneza mkoba:
+
+```typescript
+const [wallet] = new MockProvider().getWallets()
+```
+
+Kisha tunahitaji kupeleka mkataba wa ERC20. Hapa ndipo penye ugumu - tuna kiolesura pekee. Hapa ndipo Waffle inakuja kutuokoa. Waffle ina chaguo la kukokotoa la kimiujiza la `deployMockContract()` linalounda mkataba kwa kutumia _abi_ ya kiolesura pekee:
+
+```typescript
+const mockERC20 = await deployMockContract(wallet, IERC20.abi)
+```
+
+Sasa tukiwa na mkoba na ERC20 iliyopelekwa, tunaweza kuendelea na kupeleka mkataba wa `AmIRichAlready`:
+
+```typescript
+const contract = await deployContract(wallet, AmIRichAlready, [
+  mockERC20.address,
+])
+```
+
+Kwa hayo yote, chaguo letu la kukokotoa la `beforeEach()` limekamilika. Hadi sasa faili lako la `AmIRichAlready.test.ts` linapaswa kuonekana hivi:
+
+```typescript
+import { expect, use } from "chai"
+import { Contract, utils, Wallet } from "ethers"
+import {
+  deployContract,
+  deployMockContract,
+  MockProvider,
+  solidity,
+} from "ethereum-waffle"
+
+import IERC20 from "../build/IERC20.json"
+import AmIRichAlready from "../build/AmIRichAlready.json"
+
+use(solidity)
+
+describe("Am I Rich Already", () => {
+  let mockERC20: Contract
+  let contract: Contract
+  let wallet: Wallet
+
+  beforeEach(async () => {
+    ;[wallet] = new MockProvider().getWallets()
+    mockERC20 = await deployMockContract(wallet, IERC20.abi)
+    contract = await deployContract(wallet, AmIRichAlready, [mockERC20.address])
+  })
+})
+```
+
+Tuandike jaribio la kwanza kwa mkataba wa `AmIRichAlready`. Unafikiri jaribio letu linapaswa kuwa kuhusu nini? Ndio, uko sahihi! Tunapaswa kuangalia ikiwa tayari sisi ni matajiri :)
+
+Lakini subiri kidogo. Mkataba wetu ulioigwa utajuaje thamani zipi za kurudisha? Hatujatekeleza mantiki yoyote kwa chaguo la kukokotoa la `balanceOf()`. Tena, Waffle inaweza kusaidia hapa. Mkataba wetu ulioigwa una mambo mapya ya kuvutia sasa:
+
+```typescript
+await mockERC20.mock.<nameOfMethod>.returns(<value>)
+await mockERC20.mock.<nameOfMethod>.withArgs(<arguments>).returns(<value>)
+```
+
+Kwa ujuzi huu hatimaye tunaweza kuandika jaribio letu la kwanza:
+
+```typescript
+it("hurudisha uongo ikiwa mkoba una tokeni chini ya 1000000", async () => {
+  await mockERC20.mock.balanceOf.returns(utils.parseEther("999999"))
+  expect(await contract.check()).to.be.equal(false)
+})
+```
+
+Tugawanye jaribio hili katika sehemu:
+
+1. Tunaweka mkataba wetu wa kuiga wa ERC20 kurudisha salio la tokeni 999999 kila wakati.
+2. Angalia kama njia ya `contract.check()` inarudisha `uongo`.
+
+Tuko tayari kuanzisha mambo:
+
+![Jaribio moja limefaulu](./test-one.png)
+
+Kwa hiyo jaribio linafanya kazi, lakini... bado kuna nafasi ya kuboresha. Chaguo la kukokotoa la `balanceOf()` litarudisha 999999 kila wakati. Tunaweza kuiboresha kwa kubainisha mkoba ambayo chaguo la kukokotoa linapaswa kurudisha kitu - kama mkataba halisi:
+
+```typescript
+it("hurudisha uongo ikiwa mkoba una tokeni chini ya 1000001", async () => {
+  await mockERC20.mock.balanceOf
+    .withArgs(wallet.address)
+    .returns(utils.parseEther("999999"))
+  expect(await contract.check()).to.be.equal(false)
+})
+```
+
+Hadi sasa, tumejaribu tu kisa ambapo hatuna utajiri wa kutosha. Badala yake, tupime kinyume chake:
+
+```typescript
+it("hurudisha kweli ikiwa mkoba una angalau tokeni 1000001", async () => {
+  await mockERC20.mock.balanceOf
+    .withArgs(wallet.address)
+    .returns(utils.parseEther("1000001"))
+  expect(await contract.check()).to.be.equal(true)
+})
+```
+
+Unaendesha majaribio...
+
+![Majaribio mawili yamefaulu](test-two.png)
+
+...na umefika! Mkataba wetu unaonekana kufanya kazi kama ilivyokusudiwa :)
+
+## Kupima wito wa mkataba {#testing-contract-calls}
+
+Tufanye muhtasari wa kile tumefanya hadi sasa. Tumepima utendaji wa mkataba wetu wa `AmIRichAlready` na unaonekana kufanya kazi ipasavyo. Hiyo inamaanisha tumemaliza, sivyo? Sio kabisa! Waffle inaturuhusu kupima mkataba wetu hata zaidi. Lakini vipi hasa? Naam, katika safu ya Waffle kuna vilinganishi vya `calledOnContract()` na `calledOnContractWith()`. Vitatruhusu kuangalia ikiwa mkataba wetu uliita mkataba wa kuiga wa ERC20. Hili hapa ni jaribio la msingi na kimoja cha vilinganishi hivi:
+
+```typescript
+it("huangalia ikiwa mkataba uliita balanceOf kwenye tokeni ya ERC20", async () => {
+  await mockERC20.mock.balanceOf.returns(utils.parseEther("999999"))
+  await contract.check()
+  expect("balanceOf").to.be.calledOnContract(mockERC20)
+})
+```
+
+Tunaweza kwenda mbali zaidi na kuboresha jaribio hili kwa kilinganishi kingine nilichokuambia:
+
+```typescript
+it("huangalia ikiwa mkataba uliita balanceOf na mkoba fulani kwenye tokeni ya ERC20", async () => {
+  await mockERC20.mock.balanceOf
+    .withArgs(wallet.address)
+    .returns(utils.parseEther("999999"))
+  await contract.check()
+  expect("balanceOf").to.be.calledOnContractWith(mockERC20, [wallet.address])
+})
+```
+
+Hebu tuangalie kama majaribio ni sahihi:
+
+![Majaribio matatu yamefaulu](test-three.png)
+
+Safi sana, majaribio yote yamefaulu.
+
+Kupima wito wa mkataba kwa Waffle ni rahisi sana. Na hapa ndipo sehemu bora zaidi. Vilinganishi hivi hufanya kazi na mikataba ya kawaida na iliyoigwa! Hii ni kwa sababu Waffle hurekodi na kuchuja wito za EVM badala ya kuingiza msimbo, kama ilivyo kwa maktaba maarufu za majaribio kwa teknolojia nyingine.
+
+## Mstari wa Mwisho {#the-finish-line}
+
+Hongera! Sasa unajua jinsi ya kutumia Waffle kupima wito wa mkataba na kuiga mikataba kwa ubadilikaji. Kuna vipengele vingi zaidi vya kuvutia vya kugundua. Ninapendekeza kuzama katika nyaraka za Waffle.
+
+Nyaraka za Waffle zinapatikana [hapa](https://ethereum-waffle.readthedocs.io/).
+
+Msimbo chanzo wa mafunzo haya unapatikana [hapa](https://github.com/EthWorks/Waffle/tree/master/examples/dynamic-mocking-and-testing-calls).
+
+Mafunzo ambayo unaweza kupendezwa nayo pia:
+
+- [Kupima mikataba-erevu na Waffle](/developers/tutorials/waffle-test-simple-smart-contract/)
diff --git a/public/content/translations/sw/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md b/public/content/translations/sw/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
new file mode 100644
index 00000000000..e112d021c26
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
@@ -0,0 +1,204 @@
+---
+title: "Mafunzo ya Waffle ya kusema hello world kwa kutumia hardhat na ethers"
+description: Tengeneza mradi wako wa kwanza wa Waffle kwa kutumia hardhat na ethers.js
+author: "MiZiet"
+tags:
+  [
+    "waffle",
+    "mikataba erevu",
+    "uimara",
+    "majaribio",
+    "hardhat",
+    "ethers.js"
+  ]
+skill: beginner
+lang: sw
+published: 2020-10-16
+---
+
+Katika mafunzo haya ya [Waffle](https://ethereum-waffle.readthedocs.io), tutajifunza jinsi ya kuweka mradi rahisi wa mkataba-erevu wa "Hello world", kwa kutumia [hardhat](https://hardhat.org/) na [ethers.js](https://docs.ethers.io/v5/). Kisha tutajifunza jinsi ya kuongeza utendaji mpya kwenye mkataba-erevu wetu na jinsi ya kuujaribu kwa kutumia Waffle.
+
+Wacha tuanze kwa kuunda mradi mpya:
+
+```bash
+yarn init
+```
+
+au
+
+```bash
+npm init
+```
+
+na kusakinisha vifurushi vinavyohitajika:
+
+```bash
+yarn add -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
+```
+
+au
+
+```bash
+npm install -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
+```
+
+Hatua inayofuata ni kuunda mradi wa sampuli wa hardhat kwa kutumia `npx hardhat`.
+
+```bash
+888    888                      888 888               888
+888    888                      888 888               888
+888    888                      888 888               888
+8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
+888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
+888    888 .d888888 888    888  888 888  888 .d888888 888
+888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
+888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
+
+👷 Welcome to Hardhat v2.0.3 👷‍
+
+? What do you want to do? …
+❯ Create a sample project
+Create an empty hardhat.config.js
+Quit
+```
+
+Chagua `Create a sample project`
+
+Muundo wa mradi wetu unapaswa kuonekana kama hivi:
+
+```
+MyWaffleProject
+├── contracts
+│   └── Greeter.sol
+├── node_modules
+├── scripts
+│   └── sample-script.js
+├── test
+│   └── sample-test.js
+├── .gitattributes
+├── .gitignore
+├── hardhat.config.js
+└── package.json
+```
+
+### Sasa hebu tuzungumzie baadhi ya faili hizi: {#now-lets-talk}
+
+- Greeter.sol - mkataba-erevu wetu ulioandikwa kwa solidity;
+
+```solidity
+contract Greeter {
+string greeting;
+
+constructor(string memory _greeting) public {
+console.log("Deploying a Greeter with greeting:", _greeting);
+greeting = _greeting;
+}
+
+function greet() public view returns (string memory) {
+return greeting;
+}
+
+function setGreeting(string memory _greeting) public {
+console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
+greeting = _greeting;
+}
+}
+```
+
+Mkataba-erevu wetu unaweza kugawanywa katika sehemu tatu:
+
+1. constructor - ambapo tunatangaza kigezo cha aina ya string kinachoitwa `greeting`,
+2. function greet - kazi ambayo itarudisha `greeting` inapoitwa,
+3. function setGreeting - kazi inayoturuhusu kubadilisha thamani ya `greeting`.
+
+- sample-test.js - faili yetu ya majaribio
+
+```js
+describe("Greeter", function () {
+  it("Should return the new greeting once it's changed", async function () {
+    const Greeter = await ethers.getContractFactory("Greeter")
+    const greeter = await Greeter.deploy("Hello, world!")
+
+    await greeter.deployed()
+    expect(await greeter.greet()).to.equal("Hello, world!")
+
+    await greeter.setGreeting("Hola, mundo!")
+    expect(await greeter.greet()).to.equal("Hola, mundo!")
+  })
+})
+```
+
+### Hatua inayofuata inajumuisha kuandaa mkataba wetu na kuendesha majaribio: {#compiling-and-testing}
+
+Majaribio ya Waffle hutumia Mocha (mfumo wa majaribio) na Chai (maktaba ya uhakikisho). Unachotakiwa kufanya ni kuendesha `npx hardhat test` na kusubiri ujumbe ufuatao uonekane.
+
+```bash
+✓ Should return the new greeting once it's changed
+```
+
+### Kila kitu kinaonekana vizuri hadi sasa, hebu tuongeze utata zaidi kwenye mradi wetu <Emoji text=":slightly_smiling_face:" size={1}/> {#adding-complexity}
+
+Fikiria hali ambapo mtu anaongeza string tupu kama salamu. Hiyo haitakuwa salamu ya ukarimu, sawa?  
+Wacha tuhakikishe hilo halitokei:
+
+Tunataka kutumia `revert` ya solidity mtu anapopitisha string tupu. Jambo zuri ni kwamba tunaweza kujaribu utendaji huu kwa urahisi na kilinganishi cha chai cha Waffle `to.be.revertedWith()`.
+
+```js
+it("Should revert when passing an empty string", async () => {
+  const Greeter = await ethers.getContractFactory("Greeter")
+  const greeter = await Greeter.deploy("Hello, world!")
+
+  await greeter.deployed()
+  await expect(greeter.setGreeting("")).to.be.revertedWith(
+    "Greeting should not be empty"
+  )
+})
+```
+
+Inaonekana jaribio letu jipya halikufaulu:
+
+```bash
+Deploying a Greeter with greeting: Hello, world!
+Changing greeting from 'Hello, world!' to 'Hola, mundo!'
+    ✓ Should return the new greeting once it's changed (1514ms)
+Deploying a Greeter with greeting: Hello, world!
+Changing greeting from 'Hello, world!' to ''
+    1) Should revert when passing an empty string
+
+
+  1 passing (2s)
+  1 failing
+```
+
+Wacha tutekeleze utendaji huu katika mkataba-erevu wetu:
+
+```solidity
+require(bytes(_greeting).length > 0, "Greeting should not be empty");
+```
+
+Sasa, kazi yetu ya setGreeting inaonekana hivi:
+
+```solidity
+function setGreeting(string memory _greeting) public {
+require(bytes(_greeting).length > 0, "Greeting should not be empty");
+console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
+greeting = _greeting;
+}
+```
+
+Wacha tuendeshe majaribio tena:
+
+```bash
+✓ Should return the new greeting once it's changed (1467ms)
+✓ Should revert when passing an empty string (276ms)
+
+2 passing (2s)
+```
+
+Hongera! Umefaulu :)
+
+### Hitimisho {#conclusion}
+
+Tulitengeneza mradi rahisi kwa Waffle, Hardhat na ethers.js. Tulijifunza jinsi ya kuweka mradi, kuongeza jaribio na kutekeleza utendaji mpya.
+
+Kwa vilinganishi bora zaidi vya chai vya kujaribu mikataba-erevu yako, angalia [hati rasmi za Waffle](https://ethereum-waffle.readthedocs.io/en/latest/matchers.html).
diff --git a/public/content/translations/sw/developers/tutorials/waffle-test-simple-smart-contract/index.md b/public/content/translations/sw/developers/tutorials/waffle-test-simple-smart-contract/index.md
new file mode 100644
index 00000000000..24233e3b5ec
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/waffle-test-simple-smart-contract/index.md
@@ -0,0 +1,199 @@
+---
+title: Kujaribu mkataba-erevu rahisi kwa kutumia maktaba ya Waffle
+description: Mafunzo kwa wanaoanza
+author: Ewa Kowalska
+tags: [ "mikataba erevu", "uimara", "Waffle", "majaribio" ]
+skill: beginner
+lang: sw
+published: 2021-02-26
+---
+
+## Katika mafunzo haya utajifunza jinsi ya {#in-this-tutorial-youll-learn-how-to}
+
+- Jaribu mabadiliko ya salio la mkoba
+- Jaribu utoaji wa matukio na hoja maalum
+- Thibitisha kuwa muamala ulirejeshwa
+
+## Dhana {#assumptions}
+
+- Unaweza kuunda mradi mpya wa JavaScript au TypeScript
+- Una uzoefu wa kimsingi na majaribio katika JavaScript
+- Umetumia wasimamizi wengine wa vifurushi kama vile yarn au npm
+- Una ufahamu wa kimsingi sana wa mikataba-erevu na Solidity
+
+## Kuanza {#getting-started}
+
+Mafunzo haya yanaonyesha usanidi na uendeshaji wa jaribio kwa kutumia yarn, lakini hakuna shida ikiwa unapendelea npm - nitatoa marejeleo sahihi kwa [nyaraka](https://ethereum-waffle.readthedocs.io/en/latest/index.html) rasmi za Waffle.
+
+## Sakinisha Vitegemezi {#install-dependencies}
+
+[Ongeza](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation) vitegemezi vya ethereum-waffle na typescript kwenye vitegemezi vya dev vya mradi wako.
+
+```bash
+yarn add --dev ethereum-waffle ts-node typescript @types/jest
+```
+
+## Mfano wa mkataba-erevu {#example-smart-contract}
+
+Wakati wa mafunzo haya tutafanyia kazi mfano rahisi wa mkataba-erevu - EtherSplitter. Haufanyi mengi isipokuwa kuruhusu mtu yeyote kutuma wei fulani na kuigawanya sawasawa kati ya wapokeaji wawili waliobainishwa awali.
+Kitendaji cha kugawanya kinahitaji namba ya wei iwe shufwa, vinginevyo kitarejeshwa. Kwa wapokeaji wote wawili hufanya uhamisho wa wei ikifuatiwa na utoaji wa tukio la Uhamisho.
+
+Weka kipande cha msimbo wa EtherSplitter katika `src/EtherSplitter.sol`.
+
+```solidity
+pragma solidity ^0.6.0;
+
+contract EtherSplitter {
+    address payable receiver1;
+    address payable receiver2;
+
+    event Transfer(address from, address to, uint256 amount);
+
+    constructor(address payable _address1, address payable _address2) public {
+        receiver1 = _address1;
+        receiver2 = _address2;
+    }
+
+    function split() public payable {
+        require(msg.value % 2 == 0, 'Uneven wei amount not allowed');
+        receiver1.transfer(msg.value / 2);
+        emit Transfer(msg.sender, receiver1, msg.value / 2);
+        receiver2.transfer(msg.value / 2);
+        emit Transfer(msg.sender, receiver2, msg.value / 2);
+    }
+}
+```
+
+## Kusanya mkataba {#compile-the-contract}
+
+Ili [kukusanya](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#compiling-the-contract) mkataba ongeza ingizo lifuatalo kwenye faili la package.json:
+
+```json
+"scripts": {
+    "build": "waffle"
+  }
+```
+
+Ifuatayo, unda faili la usanidi la Waffle katika saraka kuu ya mradi - `waffle.json` - na kisha ubandike usanidi ufuatao hapo:
+
+```json
+{
+  "compilerType": "solcjs",
+  "compilerVersion": "0.6.2",
+  "sourceDirectory": "./src",
+  "outputDirectory": "./build"
+}
+```
+
+Endesha `yarn build`. Kama matokeo, saraka ya `build` itaonekana na mkataba wa EtherSplitter uliokusanywa katika muundo wa JSON.
+
+## Usanidi wa Jaribio {#test-setup}
+
+Kujaribu na Waffle kunahitaji kutumia vilinganishi vya Chai na Mocha, kwa hivyo unahitaji [kuwaongeza](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests) kwenye mradi wako. Sasisha faili yako ya package.json na ongeza ingizo la `test` katika sehemu ya scripts:
+
+```json
+"scripts": {
+    "build": "waffle",
+    "test": "export NODE_ENV=test && mocha -r ts-node/register 'test/**/*.test.ts'"
+  }
+```
+
+Ikiwa unataka [kutekeleza](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#running-tests) majaribio yako, endesha tu `yarn test` .
+
+## Kujaribu {#testing}
+
+Sasa unda saraka ya `test` na unda faili mpya `test\EtherSplitter.test.ts`.
+Nakili kipande kilicho hapa chini na ukibandike kwenye faili letu la majaribio.
+
+```ts
+import { expect, use } from "chai"
+import { Contract } from "ethers"
+import { deployContract, MockProvider, solidity } from "ethereum-waffle"
+import EtherSplitter from "../build/EtherSplitter.json"
+
+use(solidity)
+
+describe("Ether Splitter", () => {
+  const [sender, receiver1, receiver2] = new MockProvider().getWallets()
+  let splitter: Contract
+
+  beforeEach(async () => {
+    splitter = await deployContract(sender, EtherSplitter, [
+      receiver1.address,
+      receiver2.address,
+    ])
+  })
+
+  // add the tests here
+})
+```
+
+Maneno machache kabla ya kuanza.
+`MockProvider` huja na toleo la mfano la mnyororo wa bloku. Pia hutoa mikoba ya mfano ambayo itatusaidia kwa kujaribu mkataba wa EtherSplitter. Tunaweza kupata hadi mikoba kumi kwa kuita mbinu ya `getWallets()` kwenye mtoa huduma. Katika mfano, tunapata mikoba mitatu - kwa mtumaji na kwa wapokeaji wawili.
+
+Ifuatayo, tunatangaza kigezo kinachoitwa 'splitter' - huu ni mkataba wetu wa mfano wa EtherSplitter. Inaundwa kabla ya kila utekelezaji wa jaribio moja kwa mbinu ya `deployContract`. Mbinu hii inaiga upelekaji wa mkataba kutoka kwenye mkoba uliopitishwa kama kigezo cha kwanza (mkoba wa mtumaji katika kesi yetu). Kigezo cha pili ni ABI na bytecode ya mkataba unaojaribiwa - tunapitisha hapo faili la json la mkataba wa EtherSplitter uliokusanywa kutoka kwenye saraka ya `build`. Kigezo cha tatu ni safu yenye hoja za kiunda mkataba, ambazo katika kesi yetu, ni anwani mbili za wapokeaji.
+
+## changeBalances {#changebalances}
+
+Kwanza, tutaangalia ikiwa mbinu ya kugawanya inabadilisha salio kweli la mikoba ya wapokeaji. Ikiwa tutagawanya wei 50 kutoka kwa akaunti ya mtumaji, tutarajia salio la wapokeaji wote wawili kuongezeka kwa wei 25. Tutatumia kilinganishi cha `changeBalances` cha Waffle:
+
+```ts
+it("Changes accounts balances", async () => {
+  await expect(() => splitter.split({ value: 50 })).to.changeBalances(
+    [receiver1, receiver2],
+    [25, 25]
+  )
+})
+```
+
+Kama kigezo cha kwanza cha kilinganishi, tunapitisha safu ya mikoba ya wapokeaji, na kama ya pili - safu ya ongezeko linalotarajiwa kwenye akaunti husika.
+Ikiwa tungetaka kuangalia salio la mkoba mmoja maalum, tungeweza pia kutumia kilinganishi cha `changeBalance`, ambacho hakihitaji kupitisha safu, kama katika mfano hapa chini:
+
+```ts
+it("Changes account balance", async () => {
+  await expect(() => splitter.split({ value: 50 })).to.changeBalance(
+    receiver1,
+    25
+  )
+})
+```
+
+Kumbuka kuwa katika visa vyote viwili vya `changeBalance` na `changeBalances` tunapitisha kitendaji cha kugawanya kama simurejeshi kwa sababu kilinganishi kinahitaji kufikia hali ya salio kabla na baada ya wito.
+
+Ifuatayo, tutajaribu ikiwa tukio la Uhamisho lilitolewa baada ya kila uhamisho wa wei. Tutaelekea kwenye kilinganishi kingine kutoka Waffle:
+
+## Emit {#emit}
+
+```ts
+it("Emits event on the transfer to the first receiver", async () => {
+  await expect(splitter.split({ value: 50 }))
+    .to.emit(splitter, "Transfer")
+    .withArgs(sender.address, receiver1.address, 25)
+})
+
+it("Emits event on the transfer to the second receiver", async () => {
+  await expect(splitter.split({ value: 50 }))
+    .to.emit(splitter, "Transfer")
+    .withArgs(sender.address, receiver2.address, 25)
+})
+```
+
+Kilinganishi cha `emit` kinaturuhusu kuangalia ikiwa mkataba ulitoa tukio wakati wa kuita mbinu. Kama vigezo vya kilinganishi cha `emit`, tunatoa mkataba wa mfano ambao tunatabiri utatoa tukio, pamoja na jina la tukio hilo. Katika kesi yetu, mkataba wa mfano ni `splitter` na jina la tukio - `Transfer`. Tunaweza pia kuthibitisha thamani kamili za hoja ambazo tukio lilitolewa nazo - tunapitisha hoja nyingi kwenye kilinganishi cha `withArgs`, kama tamko letu la tukio linavyotarajia. Katika kesi ya mkataba wa EtherSplitter, tunapitisha anwani za mtumaji na mpokeaji pamoja na kiasi cha wei kilichohamishwa.
+
+## revertedWith {#revertedwith}
+
+Kama mfano wa mwisho, tutaangalia ikiwa muamala ulirejeshwa ikiwa nambari ya wei si shufwa. Tutatumia kilinganishi cha `revertedWith`:
+
+```ts
+it("Reverts when Vei amount uneven", async () => {
+  await expect(splitter.split({ value: 51 })).to.be.revertedWith(
+    "Uneven wei amount not allowed"
+  )
+})
+```
+
+Jaribio, likifaulu, litatuhakikishia kwamba muamala ulirejeshwa kweli. Hata hivyo, lazima pia kuwe na mlingano kamili kati ya ujumbe tuliouweka katika taarifa ya `require` na ujumbe tunaotarajia katika `revertedWith`. Tukirudi kwenye msimbo wa mkataba wa EtherSplitter, katika taarifa ya `require` kwa kiasi cha wei, tunatoa ujumbe: 'Uneven wei amount not allowed'. Huu unalingana na ujumbe tunaotarajia katika jaribio letu. Kama hazingekuwa sawa, jaribio lingefeli.
+
+## Hongera! {#congratulations}
+
+Umechukua hatua yako kubwa ya kwanza kuelekea kujaribu mikataba-erevu na Waffle!
diff --git a/public/content/translations/sw/developers/tutorials/yellow-paper-evm/index.md b/public/content/translations/sw/developers/tutorials/yellow-paper-evm/index.md
new file mode 100644
index 00000000000..265e02b3d54
--- /dev/null
+++ b/public/content/translations/sw/developers/tutorials/yellow-paper-evm/index.md
@@ -0,0 +1,278 @@
+---
+title: Kuelewa Vigezo vya EVM vya Karatasi ya Njano
+description: Kuelewa sehemu ya Karatasi ya Njano, vigezo rasmi vya Ethereum, ambayo inaeleza mashine halisi ya ethereum (EVM).
+author: "qbzzt"
+tags: [ "evm" ]
+skill: intermediate
+lang: sw
+published: 2022-05-15
+---
+
+[Karatasi ya Njano](https://ethereum.github.io/yellowpaper/paper.pdf) ndicho kigezo rasmi cha Ethereum. Isipokuwa pale inapofanyiwa marekebisho na [mchakato wa EIP](/eips/), ina maelezo kamili ya jinsi kila kitu kinavyofanya kazi. Imeandikwa kama karatasi ya kihisabati, ambayo inajumuisha istilahi ambazo waandaaji wa programu wanaweza wasizifahamu. Katika karatasi hii unajifunza jinsi ya kuisoma, na kwa nyongeza karatasi zingine zinazohusiana za kihisabati.
+
+## Karatasi ya Njano ipi? {#which-yellow-paper}
+
+Kama karibu kila kitu kingine katika Ethereum, Karatasi ya Njano hubadilika kadri muda unavyopita. Ili kuweza kurejelea toleo maalum, nilipakia [toleo la sasa wakati wa kuandika](yellow-paper-berlin.pdf). Nambari za sehemu, ukurasa, na milinganyo ninazotumia zitarejelea toleo hilo. Ni wazo zuri kuifungua kwenye dirisha tofauti unaposoma waraka huu.
+
+### Kwa nini EVM? {#why-the-evm}
+
+Karatasi ya njano ya asili iliandikwa mwanzoni kabisa mwa maendeleo ya Ethereum. Inaelezea utaratibu wa makubaliano wa asili unaotegemea uthibitisho-wa-kazi ambao ulitumiwa hapo awali kulinda mtandao. Hata hivyo, Ethereum ilizima uthibitisho-wa-kazi na kuanza kutumia makubaliano yanayotegemea uthibitisho-wa-hisa mnamo Septemba 2022. Mafunzo haya yatazingatia sehemu za karatasi ya njano zinazofafanua Mashine Halisi ya Ethereum. EVM haikubadilika kutokana na mpito wa kwenda kwenye uthibitisho-wa-hisa (isipokuwa kwa thamani ya kurudisha ya opcode ya DIFFICULTY).
+
+## 9 Mfumo wa utekelezaji {#9-execution-model}
+
+Sehemu hii (uk. 12-14) inajumuisha ufafanuzi mwingi wa EVM.
+
+Neno _hali ya mfumo_ linajumuisha kila kitu unachohitaji kujua kuhusu mfumo ili kuuendesha. Katika kompyuta ya kawaida, hii inamaanisha kumbukumbu, maudhui ya rejista, n.k.
+
+[Mashine ya Turing](https://en.wikipedia.org/wiki/Turing_machine) ni mfumo wa kikokotozi. Kimsingi, ni toleo lililorahisishwa la kompyuta, ambalo limethibitishwa kuwa na uwezo sawa wa kufanya makokotoo kama kompyuta ya kawaida (kila kitu ambacho kompyuta inaweza kukokotoa, mashine ya Turing inaweza kukokotoa na kinyume chake). Mfumo huu hurahisisha kuthibitisha nadharia mbalimbali kuhusu kile kinachoweza na kisichoweza kukokotolewa.
+
+Neno [Turing-complete](https://en.wikipedia.org/wiki/Turing_completeness) linamaanisha kompyuta inayoweza kufanya makokotoo sawa na mashine ya Turing. Mashine za Turing zinaweza kuingia kwenye mizunguko isiyo na kikomo, na EVM haiwezi kwa sababu ingeishiwa na gesi, kwa hivyo ni quasi-Turing-complete pekee.
+
+## 9.1 Misingi {#91-basics}
+
+Sehemu hii inatoa misingi ya EVM na jinsi inavyolinganishwa na mifumo mingine ya kikokotozi.
+
+[Mashine ya mrundikano](https://en.wikipedia.org/wiki/Stack_machine) ni kompyuta inayohifadhi data za kati si katika rejista, bali katika [**mrundikano**](https://en.wikipedia.org/wiki/Stack_\(abstract_data_type\)). Huu ndio usanifu unaopendelewa kwa mashine halisi kwa sababu ni rahisi kutekeleza ikimaanisha kuwa hitilafu, na udhaifu wa kiusalama, haviwezekani sana. Kumbukumbu katika mrundikano imegawanywa katika maneno ya biti-256. Hii ilichaguliwa kwa sababu inafaa kwa shughuli za msingi za kriptografia za Ethereum kama vile uhashishaji wa Keccak-256 na makokotoo ya mzingo duaradufu. Ukubwa wa juu wa mrundikano ni vipengee 1024 (biti 1024 x 256). Wakati opcode zinapotekelezwa kwa kawaida hupata vigezo vyao kutoka kwenye mrundikano. Kuna opcode mahususi za kupanga upya vipengele katika mrundikano kama vile `POP` (huondoa kipengee kutoka juu ya mrundikano), `DUP_N` (kipengee cha N' kilichorudiwa katika mrundikano), n.k.
+
+EVM pia ina nafasi tete inayoitwa **kumbukumbu** ambayo hutumika kuhifadhi data wakati wa utekelezaji. Kumbukumbu hii imepangwa katika maneno ya baiti 32. Maeneo yote ya kumbukumbu yanaanzishwa hadi sifuri. Ukiitekeleza msimbo huu wa [Yul](https://docs.soliditylang.org/en/latest/yul.html) ili kuongeza neno kwenye kumbukumbu, itajaza baiti 32 za kumbukumbu kwa kujaza nafasi tupu katika neno na sufuri, yaani, inaunda neno moja - lenye sufuri katika maeneo 0-29, 0x60 hadi 30, na 0xA7 hadi 31.
+
+```yul
+mstore(0, 0x60A7)
+```
+
+`mstore` ni moja ya opcode tatu ambazo EVM hutoa kwa ajili ya kuingiliana na kumbukumbu - hupakia neno kwenye kumbukumbu. Nyingine mbili ni `mstore8` ambayo hupakia baiti moja kwenye kumbukumbu, na `mload` ambayo huhamisha neno kutoka kwenye kumbukumbu hadi kwenye mrundikano.
+
+EVM pia ina mfumo tofauti wa **hifadhi** isiyo tete ambao hudumishwa kama sehemu ya hali ya mfumo - kumbukumbu hii imepangwa katika safu za maneno (kinyume na safu za baiti zinazoweza kushughulikiwa na maneno kwenye mrundikano). Hifadhi hii ndipo mikataba huhifadhi data za kudumu - mkataba unaweza tu kuingiliana na hifadhi yake yenyewe. Hifadhi imepangwa katika ramani za thamani muhimu.
+
+Ingawa haijatajwa katika sehemu hii ya Karatasi ya Njano, ni muhimu pia kujua kuna aina ya nne ya kumbukumbu. **Calldata** ni kumbukumbu ya kusoma tu inayoweza kushughulikiwa na baiti inayotumiwa kuhifadhi thamani iliyopitishwa na kigezo cha `data` cha muamala. EVM ina opcode maalum za kudhibiti `calldata`. `calldatasize` hurudisha ukubwa wa data. `calldataload` hupakia data kwenye mrundikano. `calldatacopy` hunakili data kwenye kumbukumbu.
+
+Usanifu wa kawaida wa [Von Neumann](https://en.wikipedia.org/wiki/Von_Neumann_architecture) huhifadhi msimbo na data katika kumbukumbu moja. EVM haifuati kiwango hiki kwa sababu za kiusalama - kushiriki kumbukumbu tete hufanya iwezekane kubadilisha msimbo wa programu. Badala yake, msimbo huhifadhiwa kwenye hifadhi.
+
+Kuna visa viwili tu ambavyo msimbo hutekelezwa kutoka kwa kumbukumbu:
+
+- Wakati mkataba unaunda mkataba mwingine (kwa kutumia [`CREATE`](https://www.evm.codes/#f0) au [`CREATE2`](https://www.evm.codes/#f5)), msimbo wa mjenzi wa mkataba hutoka kwenye kumbukumbu.
+- Wakati wa uundaji wa mkataba _wowote_, msimbo wa mjenzi huendeshwa na kisha hurudi na msimbo wa mkataba halisi, pia kutoka kwenye kumbukumbu.
+
+Neno utekelezaji wa kipekee linamaanisha tukio la kipekee linalosababisha utekelezaji wa mkataba wa sasa kusitishwa.
+
+## 9.2 Muhtasari wa ada {#92-fees-overview}
+
+Sehemu hii inaeleza jinsi ada za gesi zinavyokokotolewa. Kuna gharama tatu:
+
+### Gharama ya opcode {#opcode-cost}
+
+Gharama ya asili ya opcode maalum. Ili kupata thamani hii, pata kikundi cha gharama cha opcode katika Kiambatisho H (uk. 28, chini ya mlinganyo (327)), na pata kikundi cha gharama katika mlinganyo (324). Hii inakupa kazi ya gharama, ambayo katika hali nyingi hutumia vigezo kutoka Kiambatisho G (uk. 27).
+
+Kwa mfano, opcode [`CALLDATACOPY`](https://www.evm.codes/#37) ni mwanachama wa kikundi _W<sub>nakala</sub>_. Gharama ya opcode kwa kikundi hicho ni _G<sub>chinichini</sub>+G<sub>nakala</sub>×⌈μ<sub>s</sub>[2]÷32⌉_. Tukiangalia Kiambatisho G, tunaona kwamba vibaki vyote viwili ni 3, ambayo inatupa _3+3×⌈μ<sub>s</sub>[2]÷32⌉_.
+
+Bado tunahitaji kufafanua usemi _⌈μ<sub>s</sub>[2]÷32⌉_. Sehemu ya nje kabisa, _⌈ \<thamani\> ⌉_ ni kazi ya dari, kazi ambayo ikipewa thamani hurudisha nambari kamili ndogo zaidi ambayo bado si ndogo kuliko thamani. Kwa mfano, _⌈2.5⌉ = ⌈3⌉ = 3_. Sehemu ya ndani ni _μ<sub>s</sub>[2]÷32_. Tukiangalia sehemu ya 3 (Mikataba) kwenye uk. 3, _μ_ ni hali ya mashine. Hali ya mashine imefafanuliwa katika sehemu ya 9.4.1 kwenye uk. 13. Kulingana na sehemu hiyo, moja ya vigezo vya hali ya mashine ni _s_ kwa ajili ya mrundikano. Tukiweka yote pamoja, inaonekana kwamba _μ<sub>s</sub>[2]_ ni eneo #2 kwenye mrundikano. Tukiangalia [opcode](https://www.evm.codes/#37), eneo #2 kwenye mrundikano ni ukubwa wa data katika baiti. Tukiangalia opcode zingine katika kikundi W<sub>nakala</sub>, [`CODECOPY`](https://www.evm.codes/#39) na [`RETURNDATACOPY`](https://www.evm.codes/#3e), pia zina ukubwa wa data katika eneo lile lile. Kwa hivyo _⌈μ<sub>s</sub>[2]÷32⌉_ ni idadi ya maneno ya baiti 32 yanayohitajika kuhifadhi data inayakiliwa. Tukiweka kila kitu pamoja, gharama ya asili ya [`CALLDATACOPY`](https://www.evm.codes/#37) ni gesi 3 pamoja na 3 kwa kila neno la data inayakiliwa.
+
+### Gharama ya kuendesha {#running-cost}
+
+Gharama ya kuendesha msimbo tunaouita.
+
+- Katika kisa cha [`CREATE`](https://www.evm.codes/#f0) na [`CREATE2`](https://www.evm.codes/#f5), mjenzi wa mkataba mpya.
+- Katika kisa cha [`CALL`](https://www.evm.codes/#f1), [`CALLCODE`](https://www.evm.codes/#f2), [`STATICCALL`](https://www.evm.codes/#fa), au [`DELEGATECALL`](https://www.evm.codes/#f4), mkataba tunaouita.
+
+### Kupanua gharama ya kumbukumbu {#expanding-memory-cost}
+
+Gharama ya kupanua kumbukumbu (ikiwa ni lazima).
+
+Katika mlinganyo wa 324, thamani hii imeandikwa kama _C<sub>mem</sub>(μ<sub>i</sub>')-C<sub>mem</sub>(μ<sub>i</sub>)_. Tukiangalia tena sehemu ya 9.4.1, tunaona kwamba _μ<sub>i</sub>_ ni idadi ya maneno katika kumbukumbu. Kwa hivyo _μ<sub>i</sub>_ ni idadi ya maneno katika kumbukumbu kabla ya opcode na _μ<sub>i</sub>'_ ni idadi ya maneno katika kumbukumbu baada ya opcode.
+
+Kazi _C<sub>mem</sub>_ imefafanuliwa katika mlinganyo wa 326: _C<sub>mem</sub>(a) = G<sub>kumbukumbu</sub> × a + ⌊a<sup>2</sup> ÷ 512⌋_. _⌊x⌋_ ni kazi ya sakafu, kazi ambayo ikipewa thamani hurudisha nambari kamili kubwa zaidi ambayo bado si kubwa kuliko thamani. Kwa mfano, _⌊2.5⌋ = ⌊2⌋ = 2._ Wakati _a < √512_, _a<sup>2</sup> < 512_, na matokeo ya kazi ya sakafu ni sifuri. Kwa hivyo kwa maneno 22 ya kwanza (baiti 704), gharama huongezeka kwa mstari na idadi ya maneno ya kumbukumbu yanayohitajika. Zaidi ya hapo _⌊a<sup>2</sup> ÷ 512⌋_ ni chanya. Wakati kumbukumbu inayohitajika ni ya juu vya kutosha gharama ya gesi ni sawia na mraba wa kiasi cha kumbukumbu.
+
+**Kumbuka** kwamba vipengele hivi huathiri tu gharama ya gesi ya _asili_ - haizingatii soko la ada au vidokezo kwa wathibitishaji ambavyo huamua ni kiasi gani mtumiaji wa mwisho anahitajika kulipa - hii ni gharama ghafi tu ya kuendesha operesheni fulani kwenye EVM.
+
+[Soma zaidi kuhusu gesi](/developers/docs/gas/).
+
+## 9.3 Mazingira ya utekelezaji {#93-execution-env}
+
+Mazingira ya utekelezaji ni jozi, _I_, inayojumuisha taarifa ambazo si sehemu ya hali ya mnyororo wa bloku au EVM.
+
+| Kigezo          | Opcode ya kufikia data                                                                                                   | Msimbo wa Solidity wa kufikia data                      |
+| --------------- | ------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------- |
+| _I<sub>a</sub>_ | [`ADDRESS`](https://www.evm.codes/#30)                                                                                   | `anwani(this)`                                          |
+| _I<sub>o</sub>_ | [`ORIGIN`](https://www.evm.codes/#32)                                                                                    | `tx.origin`                                             |
+| _I<sub>p</sub>_ | [`GASPRICE`](https://www.evm.codes/#3a)                                                                                  | `tx.gasprice`                                           |
+| _I<sub>d</sub>_ | [`CALLDATALOAD`](https://www.evm.codes/#35), nk.                                                         | `msg.data`                                              |
+| _I<sub>s</sub>_ | [`CALLER`](https://www.evm.codes/#33)                                                                                    | `msg.sender`                                            |
+| _I<sub>v</sub>_ | [`CALLVALUE`](https://www.evm.codes/#34)                                                                                 | `msg.value`                                             |
+| _I<sub>b</sub>_ | [`CODECOPY`](https://www.evm.codes/#39)                                                                                  | `address(this).code`                                    |
+| _I<sub>H</sub>_ | Sehemu za kichwa cha bloku, kama vile [`NUMBER`](https://www.evm.codes/#43) na [`DIFFICULTY`](https://www.evm.codes/#44) | `block.number`, `block.difficulty`, nk. |
+| _I<sub>e</sub>_ | Kina cha mrundikano wa simu kwa simu kati ya mikataba (pamoja na uundaji wa mkataba)                  |                                                         |
+| _I<sub>w</sub>_ | Je, EVM inaruhusiwa kubadilisha hali, au inaendeshwa kitakwimu                                                           |                                                         |
+
+Vigezo vingine vichache ni muhimu kuelewa salio la sehemu ya 9:
+
+| Kigezo | Imefafanuliwa katika sehemu                                     | Maana                                                                                                                                                                                                                                                  |
+| ------ | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| _σ_    | 2 (uk. 2, mlinganyo 1)       | Hali ya mnyororo wa bloku                                                                                                                                                                                                                              |
+| _g_    | 9.3 (uk. 13) | Gesi iliyobaki                                                                                                                                                                                                                                         |
+| _A_    | 6.1 (uk. 8)  | Hali ndogo iliyokusanywa (mabadiliko yaliyopangwa kwa wakati muamala unapoisha)                                                                                                                                                     |
+| _o_    | 9.3 (uk. 13) | Matokeo - matokeo yaliyorudishwa katika kisa cha muamala wa ndani (wakati mkataba mmoja unapopiga simu mwingine) na simu za kutazama kazi (wakati unauliza tu habari, kwa hivyo hakuna haja ya kusubiri muamala) |
+
+## 9.4 Muhtasari wa utekelezaji {#94-execution-overview}
+
+Sasa kwa kuwa tuna matayarisho yote, hatimaye tunaweza kuanza kufanyia kazi jinsi EVM inavyofanya kazi.
+
+Milinganyo 137-142 inatupa hali za awali za kuendesha EVM:
+
+| Alama            | Thamani ya awali                                                                 | Maana                                                                                                                                                                                                                                                                                                         |
+| ---------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| _μ<sub>g</sub>_  | _g_                                                                              | Gesi iliyobaki                                                                                                                                                                                                                                                                                                |
+| _μ<sub>pc</sub>_ | _0_                                                                              | Kaunta ya programu, anwani ya maagizo yafuatayo ya kutekeleza                                                                                                                                                                                                                                                 |
+| _μ<sub>m</sub>_  | _(0, 0, ...)_ | Kumbukumbu, iliyoanzishwa kwa sufuri zote                                                                                                                                                                                                                                                                     |
+| _μ<sub>i</sub>_  | _0_                                                                              | Eneo la juu zaidi la kumbukumbu lililotumika                                                                                                                                                                                                                                                                  |
+| _μ<sub>s</sub>_  | _()_                                                          | Mrundikano, awali ulikuwa tupu                                                                                                                                                                                                                                                                                |
+| _μ<sub>o</sub>_  | _∅_                                                                              | Matokeo, seti tupu hadi na isipokuwa tusimame ama na data ya kurudi ([`RETURN`](https://www.evm.codes/#f3) au [`REVERT`](https://www.evm.codes/#fd)) au bila hiyo ([`STOP`](https://www.evm.codes/#00) au [`SELFDESTRUCT`](https://www.evm.codes/#ff)). |
+
+Mlinganyo wa 143 unatuambia kuna hali nne zinazowezekana wakati wowote wakati wa utekelezaji, na nini cha kufanya nazo:
+
+1. `Z(σ,μ,A,I)`. Z inawakilisha kazi inayojaribu ikiwa operesheni inaunda mpito wa hali batili (tazama [kusitishwa kwa kipekee](#942-exceptional-halting)). Ikiwa itatathmini kuwa Kweli, hali mpya ni sawa na ile ya zamani (isipokuwa gesi inachomwa) kwa sababu mabadiliko hayajatekelezwa.
+2. Ikiwa opcode inayotekelezwa ni [`REVERT`](https://www.evm.codes/#fd), hali mpya ni sawa na hali ya zamani, gesi fulani inapotea.
+3. Ikiwa mfuatano wa operesheni umekamilika, kama inavyoonyeshwa na [`RETURN`](https://www.evm.codes/#f3)), hali inasasishwa kuwa hali mpya.
+4. Ikiwa hatuko katika mojawapo ya hali za mwisho 1-3, endelea kuendesha.
+
+## 9.4.1 Hali ya Mashine {#941-machine-state}
+
+Sehemu hii inaeleza hali ya mashine kwa undani zaidi. Inabainisha kuwa _w_ ni opcode ya sasa. Ikiwa _μ<sub>pc</sub>_ ni chini ya _||I<sub>b</sub>||_, urefu wa msimbo, basi baiti hiyo (_I<sub>b</sub>[μ<sub>pc</sub>]_) ni opcode. Vinginevyo, opcode inafafanuliwa kama [`STOP`](https://www.evm.codes/#00).
+
+Kwa kuwa hii ni [mashine ya mrundikano](https://en.wikipedia.org/wiki/Stack_machine), tunahitaji kufuatilia idadi ya vipengee vilivyotolewa (_δ_) na kusukumwa ndani (_α_) na kila opcode.
+
+## 9.4.2 Kusitishwa kwa Kipekee {#942-exceptional-halt}
+
+Sehemu hii inafafanua kazi ya _Z_, ambayo inabainisha wakati tuna usitishwaji usio wa kawaida. Hii ni kazi ya [Boolean](https://en.wikipedia.org/wiki/Boolean_data_type), kwa hivyo hutumia [_∨_ kwa mantiki au](https://en.wikipedia.org/wiki/Logical_disjunction) na [_∧_ kwa mantiki na](https://en.wikipedia.org/wiki/Logical_conjunction).
+
+Tuna usitishwaji wa kipekee ikiwa mojawapo ya hali hizi ni kweli:
+
+- **_μ<sub>g</sub> < C(σ,μ,A,I)_**
+  Kama tulivyoona katika sehemu ya 9.2, _C_ ni kazi inayobainisha gharama ya gesi. Hakuna gesi ya kutosha iliyobaki kufunika opcode inayofuata.
+
+- **_δ<sub>w</sub>=∅_**
+  Ikiwa idadi ya vipengee vilivyotolewa kwa opcode haijafafanuliwa, basi opcode yenyewe haijafafanuliwa.
+
+- **_|| μ<sub>s</sub> || < δ<sub>w</sub>_**
+  Mrundikano chini ya mtiririko, hakuna vipengee vya kutosha katika mrundikano kwa opcode ya sasa.
+
+- **_w = JUMP ∧ μ<sub>s</sub>[0]∉D(I<sub>b</sub>)_**
+  Opcode ni [`JUMP`](https://www.evm.codes/#56) na anwani si [`JUMPDEST`](https://www.evm.codes/#5b). Miruko ni halali _tu_ wakati lengo ni [`JUMPDEST`](https://www.evm.codes/#5b).
+
+- **_w = JUMPI ∧ μ<sub>s</sub>[1]≠0 ∧ μ<sub>s</sub>[0] ∉ D(I<sub>b</sub>)_**
+  Opcode ni [`JUMPI`](https://www.evm.codes/#57), hali ni kweli (sio sifuri) kwa hivyo mruko unapaswa kutokea, na anwani si [`JUMPDEST`](https://www.evm.codes/#5b). Miruko ni halali _tu_ wakati lengo ni [`JUMPDEST`](https://www.evm.codes/#5b).
+
+- **_w = RETURNDATACOPY ∧ μ<sub>s</sub>[1]+μ<sub>s</sub>[2]>|| μ<sub>o</sub> ||_**
+  Opcode ni [`RETURNDATACOPY`](https://www.evm.codes/#3e). Katika opcode hii kipengele cha mrundikano _μ<sub>s</sub>[1]_ ni kukabiliana na kusoma kutoka kwenye bafa ya data ya kurudi, na kipengele cha mrundikano _μ<sub>s</sub>[2]_ ni urefu wa data. Hali hii hutokea unapojaribu kusoma zaidi ya mwisho wa bafa ya data ya kurudi. Kumbuka kuwa hakuna hali sawa kwa calldata au kwa msimbo wenyewe. Unapojaribu kusoma zaidi ya mwisho wa bafa hizo unapata tu sifuri.
+
+- **_|| μ<sub>s</sub> || - δ<sub>w</sub> + α<sub>w</sub> > 1024_**
+
+  Kufurika kwa mrundikano. Ikiwa kuendesha opcode kutasababisha mrundikano wa zaidi ya vipengee 1024, sitisha.
+
+- **_¬I<sub>w</sub> ∧ W(w,μ)_**
+  Je, tunaendesha kitakwimu ([¬ ni ukanushaji](https://en.wikipedia.org/wiki/Negation) na _I<sub>w</sub>_ ni kweli tunaporuhusiwa kubadilisha hali ya mnyororo wa bloku)? Ikiwa ndivyo, na tunajaribu operesheni ya kubadilisha hali, haiwezi kutokea.
+
+  Kazi _W(w,μ)_ imefafanuliwa baadaye katika mlinganyo wa 150. _W(w,μ)_ ni kweli ikiwa mojawapo ya hali hizi ni kweli:
+
+  - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_**
+    Opcode hizi hubadilisha hali, ama kwa kuunda mkataba mpya, kuhifadhi thamani, au kuharibu mkataba wa sasa.
+
+  - **_LOG0≤w ∧ w≤LOG4_**
+    Ikiwa tunaitwa kitakwimu hatuwezi kutoa maingizo ya kumbukumbu.
+    Opcode za kumbukumbu zote ziko katika safu kati ya [`LOG0` (A0)](https://www.evm.codes/#a0) na [`LOG4` (A4)](https://www.evm.codes/#a4).
+    Nambari baada ya opcode ya kumbukumbu inabainisha ni mada ngapi ingizo la kumbukumbu lina.
+
+  - **_w=CALL ∧ μ<sub>s</sub>[2]≠0_**
+    Unaweza kuita mkataba mwingine ukiwa katika hali tuli, lakini ukifanya hivyo huwezi kuhamisha ETH kwake.
+
+- **_w = SSTORE ∧ μ<sub>g</sub> ≤ G<sub>callstipend</sub>_**
+  Huwezi kuendesha [`SSTORE`](https://www.evm.codes/#55) isipokuwa uwe na zaidi ya G<sub>callstipend</sub> (iliyofafanuliwa kama 2300 katika Kiambatisho G) gesi.
+
+## 9.4.3 Uhalali wa Lengo la Mruko {#943-jump-dest-valid}
+
+Hapa tunafafanua rasmi ni zipi opcode za [`JUMPDEST`](https://www.evm.codes/#5b). Hatuwezi tu kutafuta thamani ya baiti 0x5B, kwa sababu inaweza kuwa ndani ya PUSH (na kwa hivyo data na si opcode).
+
+Katika mlinganyo (153) tunafafanua kazi, _N(i,w)_. Kigezo cha kwanza, _i_, ni eneo la opcode. Ya pili, _w_, ni opcode yenyewe. Ikiwa _w∈[PUSH1, PUSH32]_ hiyo inamaanisha opcode ni PUSH (mabano ya mraba hufafanua safu inayojumuisha ncha za mwisho). Ikiwa kisa hicho opcode inayofuata iko kwenye _i+2+(w−PUSH1)_. Kwa [`PUSH1`](https://www.evm.codes/#60) tunahitaji kusonga mbele kwa baiti mbili (PUSH yenyewe na thamani ya baiti moja), kwa [`PUSH2`](https://www.evm.codes/#61) tunahitaji kusonga mbele kwa baiti tatu kwa sababu ni thamani ya baiti mbili, nk. Opcode zingine zote za EVM zina urefu wa baiti moja tu, kwa hivyo katika visa vingine vyote _N(i,w)=i+1_.
+
+Kazi hii inatumiwa katika mlinganyo (152) kufafanua _D<sub>J</sub>(c,i)_, ambayo ni [seti](https://en.wikipedia.org/wiki/Set_\(mathematics\)) ya malengo yote halali ya mruko katika msimbo _c_, kuanzia na eneo la opcode _i_. Kazi hii inafafanuliwa kwa kujirudia. Ikiwa _i≥||c||_, hiyo inamaanisha kuwa tuko mwisho au baada ya mwisho wa msimbo. Hatutapata malengo mengine yoyote ya mruko, kwa hivyo rudisha tu seti tupu.
+
+Katika visa vingine vyote tunaangalia salio la msimbo kwa kwenda kwenye opcode inayofuata na kupata seti kuanzia hapo. _c[i]_ ni opcode ya sasa, kwa hivyo _N(i,c[i])_ ni eneo la opcode inayofuata. _D<sub>J</sub>(c,N(i,c[i]))_ kwa hivyo ni seti ya malengo halali ya mruko inayoanzia kwenye opcode inayofuata. Ikiwa opcode ya sasa si `JUMPDEST`, rudisha tu seti hiyo. Ikiwa ni `JUMPDEST`, ijumuishwe kwenye seti ya matokeo na urudishe hiyo.
+
+## 9.4.4 Kusitishwa kwa kawaida {#944-normal-halt}
+
+Kazi ya kusitisha _H_, inaweza kurudisha aina tatu za thamani.
+
+- Ikiwa hatuko katika opcode ya kusitisha, rudisha _∅_, seti tupu. Kwa mkataba, thamani hii inatafsiriwa kama Boolean ya uongo.
+- Ikiwa tuna opcode ya kusitisha ambayo haitoi matokeo (ama [`STOP`](https://www.evm.codes/#00) au [`SELFDESTRUCT`](https://www.evm.codes/#ff)), rudisha mfuatano wa baiti za ukubwa sifuri kama thamani ya kurudi. Kumbuka kuwa hii ni tofauti sana na seti tupu. Thamani hii inamaanisha kuwa EVM kweli ilisitisha, ni kwamba tu hakuna data ya kurudi ya kusoma.
+- Ikiwa tuna opcode ya kusitisha ambayo inatoa matokeo (ama [`RETURN`](https://www.evm.codes/#f3) au [`REVERT`](https://www.evm.codes/#fd)), rudisha mfuatano wa baiti zilizobainishwa na opcode hiyo. Mfuatano huu unachukuliwa kutoka kwenye kumbukumbu, thamani iliyo juu ya mrundikano (_μ<sub>s</sub>[0]_) ni baiti ya kwanza, na thamani baada yake (_μ<sub>s</sub>[1]_) ni urefu.
+
+## H.2 Seti ya maagizo {#h2-instruction-set}
+
+Kabla ya kwenda kwenye kifungu kidogo cha mwisho cha EVM, 9.5, hebu tuangalie maagizo yenyewe. Yamefafanuliwa katika Kiambatisho H.2 kinachoanzia uk. 29. Chochote ambacho hakijabainishwa kuwa kinabadilika na opcode hiyo maalum kinatarajiwa kubaki vile vile. Vigezo vinavyobadilika vinabainishwa na kama \<something\>′.
+
+Kwa mfano, hebu tuangalie opcode ya [`ADD`](https://www.evm.codes/#01).
+
+| Thamani | Mnemonic | δ | α | Maelezo                                                                                                                                                                                                               |
+| ------: | -------- | - | - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|    0x01 | ADD      | 2 | 1 | Operesheni ya kuongeza.                                                                                                                                                                               |
+|         |          |   |   | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[0] + μ<sub>s</sub>[1]_ |
+
+_δ_ ni idadi ya thamani tunazotoa kutoka kwenye mrundikano. Katika kisa hiki mbili, kwa sababu tunaongeza thamani mbili za juu.
+
+_α_ ni idadi ya thamani tunazosukuma nyuma. Katika kisa hiki moja, jumla.
+
+Kwa hivyo juu mpya ya mrundikano (_μ′<sub>s</sub>[0]_) ni jumla ya juu ya zamani ya mrundikano (_μ<sub>s</sub>[0]_) na thamani ya zamani chini yake (_μ<sub>s</sub>[1]_).
+
+Badala ya kupitia opcode zote kwa "orodha inayochosha macho", makala hii inaeleza tu opcode zinazoanzisha kitu kipya.
+
+| Thamani | Mnemonic  | δ | α | Maelezo                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| ------: | --------- | - | - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|    0x20 | KECCAK256 | 2 | 1 | Kokotoa hashi ya Keccak-256.                                                                                                                                                                                                                                                                                                                                                                                                                         |
+|         |           |   |   | _μ′<sub>s</sub>[0] ≡ KEC(μ<sub>m</sub>[μ<sub>s</sub>[0] . . . (μ<sub>s</sub>[0] + μ<sub>s</sub>[1] − 1)])_ |
+|         |           |   |   | _μ′<sub>i</sub> ≡ M(μ<sub>i</sub>,μ<sub>s</sub>[0],μ<sub>s</sub>[1])_                                                                                                                                                                                                                                                                     |
+
+Hii ni opcode ya kwanza inayofikia kumbukumbu (katika kisa hiki, kusoma tu). Hata hivyo, inaweza kupanuka zaidi ya mipaka ya sasa ya kumbukumbu, kwa hivyo tunahitaji kusasisha _μ<sub>i</sub>._ Tunafanya hivi kwa kutumia kazi ya _M_ iliyofafanuliwa katika mlinganyo wa 328 kwenye uk. 29.
+
+| Thamani | Mnemonic | δ | α | Maelezo                                             |
+| ------: | -------- | - | - | --------------------------------------------------- |
+|    0x31 | BALANCE  | 1 | 1 | Pata salio la akaunti uliyopewa.    |
+|         |          |   |   | ... |
+
+Anwani ambayo salio lake tunahitaji kupata ni _μ<sub>s</sub>[0] mod 2<sup>160</sup>_. Juu ya mrundikano ni anwani, lakini kwa sababu anwani zina biti 160 tu, tunakokotoa thamani [modulo](https://en.wikipedia.org/wiki/Modulo_operation) 2<sup>160</sup>.
+
+Ikiwa _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] ≠ ∅_, inamaanisha kuwa kuna habari kuhusu anwani hii. Katika kisa hicho, _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>]<sub>b</sub>_ ni salio la anwani hiyo. Ikiwa _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] = ∅_, inamaanisha kuwa anwani hii haijaanzishwa na salio ni sifuri. Unaweza kuona orodha ya sehemu za habari za akaunti katika sehemu ya 4.1 kwenye uk. 4.
+
+Mlinganyo wa pili, _A'<sub>a</sub> ≡ A<sub>a</sub> ∪ \{μ<sub>s</sub>[0] mod 2<sup>160</sup>}_, unahusiana na tofauti ya gharama kati ya ufikiaji wa hifadhi ya joto (hifadhi ambayo imefikiwa hivi karibuni na inawezekana kuhifadhiwa kwenye kache) na hifadhi ya baridi (hifadhi ambayo haijafikiwa na inawezekana kuwa katika hifadhi ya polepole ambayo ni ghali zaidi kuirejesha). _A<sub>a</sub>_ ni orodha ya anwani zilizofikiwa hapo awali na muamala, ambayo kwa hivyo inapaswa kuwa rahisi kufikia, kama ilivyofafanuliwa katika sehemu ya 6.1 kwenye uk. 8. Unaweza kusoma zaidi kuhusu mada hii katika [EIP-2929](https://eips.ethereum.org/EIPS/eip-2929).
+
+| Thamani | Mnemonic | δ  | α  | Maelezo                                                                                                                                         |
+| ------: | -------- | -- | -- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+|    0x8F | DUP16    | 16 | 17 | Rudufu kipengee cha 16 cha mrundikano.                                                                                          |
+|         |          |    |    | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[15]_ |
+
+Kumbuka kuwa ili kutumia kipengee chochote cha mrundikano, tunahitaji kukitoa, ambayo inamaanisha tunahitaji pia kutoa vipengee vyote vya mrundikano vilivyo juu yake. Katika kisa cha [`DUP<n>`](https://www.evm.codes/#8f) na [`SWAP<n>`](https://www.evm.codes/#9f), hii inamaanisha kulazimika kutoa na kisha kusukuma hadi thamani kumi na sita.
+
+## 9.5 Mzunguko wa utekelezaji {#95-exec-cycle}
+
+Sasa kwa kuwa tuna sehemu zote, hatimaye tunaweza kuelewa jinsi mzunguko wa utekelezaji wa EVM unavyoandikwa.
+
+Mlinganyo (155) unasema kwamba ukipewa hali:
+
+- _σ_ (hali ya mnyororo wa bloku wa kimataifa)
+- _μ_ (hali ya EVM)
+- _A_ (hali ndogo, mabadiliko ya kutokea wakati muamala unapoisha)
+- _I_ (mazingira ya utekelezaji)
+
+Hali mpya ni _(σ', μ', A', I')_.
+
+Milinganyo (156)-(158) inafafanua mrundikano na mabadiliko ndani yake kutokana na opcode (_μ<sub>s</sub>_). Mlinganyo (159) ni mabadiliko ya gesi (_μ<sub>g</sub>_). Mlinganyo (160) ni mabadiliko katika kaunta ya programu (_μ<sub>pc</sub>_). Hatimaye, milinganyo (161)-(164) inabainisha kuwa vigezo vingine vinabaki vile vile, isipokuwa vimebadilishwa waziwazi na opcode.
+
+Kwa hili EVM imefafanuliwa kikamilifu.
+
+## Hitimisho {#conclusion}
+
+Nukuu za kihisabati ni sahihi na imeruhusu Karatasi ya Njano kubainisha kila undani wa Ethereum. Hata hivyo, ina hasara kadhaa:
+
+- Inaweza kueleweka tu na wanadamu, ambayo inamaanisha kuwa [majaribio ya kufuata](https://github.com/ethereum/tests) lazima yaandikwe kwa mkono.
+- Waandaaji wa programu wanaelewa msimbo wa kompyuta.
+  Wanaweza au wasielewe nukuu za kihisabati.
+
+Labda kwa sababu hizi, [vigezo vipya vya safu ya makubaliano](https://github.com/ethereum/consensus-specs/blob/dev/tests/core/pyspec/README.md) vimeandikwa katika Python. Kuna [vigezo vya safu ya utekelezaji katika Python](https://ethereum.github.io/execution-specs), lakini havijakamilika. Hadi na isipokuwa Karatasi nzima ya Njano itafsiriwe pia kwa Python au lugha sawa, Karatasi ya Njano itaendelea kutumika, na ni muhimu kuweza kuisoma.
diff --git a/public/content/translations/sw/eips/index.md b/public/content/translations/sw/eips/index.md
index dc23bf44011..08196ddd167 100644
--- a/public/content/translations/sw/eips/index.md
+++ b/public/content/translations/sw/eips/index.md
@@ -1,63 +1,75 @@
 ---
 title: Pendekezo la Uboreshaji wa Ethereum(EIPs)
-description: Maelezo ya msingi unayohitaji kuelewa Mapendekezo ya Uboreshaji wa Ethereum (EIPs).
+description: Taarifa za msingi unazohitaji kuelewa pendekezo la uendelezaji wa Ethereum.
 lang: sw
 ---
 
-# Utangulizi wa Mapendekezo ya Uboreshaji wa Ethereum (EIPs) {#introduction-to-ethereum-improvement-proposals-eips}
+# Utangulizi wa Mapendekezo ya Kuboresha Ethereum (EIPs) {#introduction-to-ethereum-improvement-proposals}
 
 ## EIPs ni nini? {#what-are-eips}
 
-[Mapendekezp ya Uboreshajhi wa Ethereum (EIPs)](https://eips.ethereum.org/) ni viwango vinavyobainisha vipengele vipya vinavyowezekana au michakato ya Ethereum. EIPs zina maelezo ya kiufundi ya mabadiliko yanayopendekezwa na hufanya kama "chanzo cha ukweli" kwa jumuiya. Visasisho vya mtandao na viwango vya matumizi ya Ethereum vinajadiliwa na kuendelezwa kupitia mchakato wa EIP.
+[Mapendekezo ya Kuboresha Ethereum (EIPs)](https://eips.ethereum.org/) ni viwango vinavyobainisha vipengele vipya vinavyowezekana au michakato ya Ethereum. EIPs zina maelezo ya kiufundi ya mabadiliko yanayopendekezwa na hufanya kama "chanzo cha ukweli" kwa jumuiya. Visasisho vya mtandao na viwango vya matumizi ya Ethereum vinajadiliwa na kuendelezwa kupitia mchakato wa EIP.
 
-Mtu yeyote ndani ya jumuiya ya Ethereum ana uwezo wa kuunda EIP. Miongozo ya kuandika EIP imejumuishwa kwenye [EIP1](https://eips.ethereum.org/EIPS/eip-1). EIP inapaswa kutoa maelezo mafupi ya kiufundi ya kipengele na mantiki yake. Mwandishi wa EIP anawajibu wa kujenga maelewano ndani ya jumuiya na kuandika maoni yanayopingana. Kwa kuzingatia upau wa juu wa kiufundi wa kuwasilisha EIP iliyoundwa vizuri, kihistoria, waandishi wengi wa EIP wamekuwa wasanidi programu au itifaki.
+Mtu yeyote ndani ya jumuiya ya Ethereum ana uwezo wa kuunda EIP. Miongozo ya kuandika EIP imejumuishwa katika [EIP-1](https://eips.ethereum.org/EIPS/eip-1). Pendekezo la uendelezaji wa Ethereum inapaswa kwanza kutoa maelezo ya kiufundi kwa ufupi pamoja na kiasi kidogo cha sababu ya msingi.  Mwandishi wa pendekezo la uendelezaji wa Ethereum ana jukumu la kufanikisha makubaliano ndani ya jumuiya na kuandika maoni mbadala. Kutokana na kizuizi kubwa kiufundi cha kuwasilisha pendekezo la uendeleshaji wa Ethereum iliyoandikwa vizuri, waandishi wengi wa pendekezo la uendelezaji wa Ethereum kwa kawaida ni waendelezaji wa maombi rasmi au watengenezaji wa itifaki.
 
 ## Kwa nini EIPs ni muhimu? {#why-do-eips-matter}
 
-EIPs huchukua jukumu kuu katika mabadiliko yanavyotokea na kurekodiwa kwenye Ethereum. Ndio njia ya watu kupendekeza, kujadili na kupitsha mabadiliko. Kuna [aina tofauti za EIPs](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1.md#eip-types) ikijumuisha EIP za msingi kwa ajili ya mabadiliko ya itifaki ya kiwango cha chini ambayo yanaathiri makubaliano na kuhitaji usasishaji wa mtandao pamoja na ERCs kwa viwango vya maombi. Kwa mfano, viwango vya kutengeneza tokeni, kama [ERC20](https://eips.ethereum.org/EIPS/eip-20)ama[ERC721](https://eips.ethereum.org/EIPS/eip-721) hurusu programu zinazoingiliana na hizi tokeni kushughulikia tokeni zotye kwa kutumia masharti yaleyale, ambayo hurahisisha uundaji wa programu zinazoingiliana.
+EIPs huchukua jukumu kuu katika mabadiliko yanavyotokea na kurekodiwa kwenye Ethereum. Ni njia ya watu kupendekeza, kujadili, na kupitisha mabadiliko. Kuna [aina tofauti za EIP](https://eips.ethereum.org/EIPS/eip-1#eip-types), ikiwa ni pamoja na EIP za msingi za mabadiliko ya itifaki ya kiwango cha chini ambayo huathiri makubaliano na kuhitaji uboreshaji wa mtandao kama vile [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), na ERC za viwango vya programu kama vile [EIP-20](https://eips.ethereum.org/EIPS/eip-20) na [EIP-721](https://eips.ethereum.org/EIPS/eip-721).
 
-Kila boresha/sasisho la mtandao hujumuisha na seti ya EIPs amabazo zinahitaji utekelezaji kwa kila [ mteja/programu ya Ethereum](/learn/#clients-and-nodes) ilioko kwenye mtandao. Hii inamaana kwamba ili kuwa na makubaliano na programu zingine juu ya Mtandao mkuu wa Ethereum, wasanidi programu wanatakiwa kuhakikisha kua wametekeleza EIPs zote zinazohitajika.
+Kila uboreshaji wa mtandao unajumuisha seti ya EIP ambazo zinahitaji kutekelezwa na kila [mteja wa Ethereum](/learn/#clients-and-nodes) kwenye mtandao. Hii inamaanisha kuwa ili ubaki kwenye makubaliano na wateja wengine kwenye mtandao mkuu wa Ethereum, watengenezaji wa wateja wanahitaji kuhakikisha kuwa wote wameutekeleza pendekezo la uendelezaji wa Ethereum zinazohitajika.
 
-Pamaoja na kutoa maelezo ya kiufundi kwa ajili ya mabadiliko, EIPs ni kitengo amabacho usimamizi wake hufanyika ndani ya Ethereum: mtu yeyote yuko huru kutoa pendekezo, na kisha wadau mbalimbali katika jamii watajadiliana ili kubaini kama inafaa kupitishwa kama kiwango au kujumuishwa katika uboreshaji wa mtandao. Kwa kua EIPs ambazo sio za msingi hazihitaji kuwekwa kwenye kila programu (kwa mfano, unaweza kuunada tokeni isyo-[ERC20](https://eips.ethereum.org/EIPS/eip-20)), lakini EIP za msingi lazima zipitishwe kw upana (maana nodi zote lazima zisasishwe ili ziwe sehemu ya mtandao mmoja), EIPs za msingi huzingatia mipaka ya makubaliano ndani ya jamii kuliko zile ambazo sii za msingi.
+Pamaoja na kutoa maelezo ya kiufundi kwa ajili ya mabadiliko, EIPs ni kitengo amabacho usimamizi wake hufanyika ndani ya Ethereum: mtu yeyote yuko huru kutoa pendekezo, na kisha wadau mbalimbali katika jamii watajadiliana ili kubaini kama inafaa kupitishwa kama kiwango au kujumuishwa katika uboreshaji wa mtandao. Kwa kuwa pendekezo la uendelezaji wa Ethereum zisizo za msingi hazihitzjiki kuzuiliwa maombi rasmi wowote ( mfano, inawezekana kuunda tokeni inayoweza kubadilishwa ambayo haitekelezi pendekezo la uendelezaji wa Ethereum-20) lakini pendekezo la uendelezaji wa Ethereum za msingi lazima zikubalike kwa wingi (kwa kuwa vituo zote lazima zipate masasisho ili kubaki sehemu ya wavu mmoja) Pendekezo la uendelezaji wa Ethereum za msingi zinahitaji makubaliano pana zaidi ndani ya jumuiya kuliko pendekezo la uendelezaji wa Ethereum zisizo za msingi.
 
-## Historia ya EIPs {#history-of-eips}
+## Historia ya EIP {#history-of-eips}
 
-[Hazina ya Mapendekezo ya Uboreshwaji wa Ethereum (EIPs)yalioko GitHub](https://github.com/ethereum/EIPs)yaliundwa mwezi Oktoba, 2015. Mchakato wa EIP unategemea/ kuangalia [ Mapendekezo ya Uboreshwaji wa Bitcoin (BIPs)](https://github.com/bitcoin/bips), ambayo yenyewe inajilinganisha /kutegemea mabadiliko yanayoendelea kwenye mchakato wa [ Mapendekezo ya Uboreshwaji wa Python (PEPs)](https://www.python.org/dev/peps/).
+[Hazina ya GitHub ya Mapendekezo ya Kuboresha Ethereum (EIPs)](https://github.com/ethereum/EIPs) iliundwa mnamo Oktoba 2015. Mchakato wa EIP unatokana na mchakato wa [Mapendekezo ya Kuboresha Bitcoin (BIPs)](https://github.com/bitcoin/bips), ambao nao unatokana na mchakato wa [Mapendekezo ya Kuboresha Python (PEPs)](https://www.python.org/dev/peps/).
 
-Wahariri wa EIP wanapewa jukumu la kufanya mchakato wa uhakiki wa kiufundi, sarufi/tahjia, na aina ya msimbo sahihi. Martin Becze, Vitalik Buterin, Gavin Wood na wengine wachache ndio wahariri waanzilishi wa EIP kutoka mwaka 2015 kwenda mwishoni mwa mwaka 2016. Wahariri wa sasa wa EIP ni:
+Wahariri wa pendekezo la uendelezaji wa Ethereum wanapewa jukumu la kuchunguza pendekezo la uendelezaji wa Ethereum kwa usahihi wa kiufundi, masuala ya muundo, na kusahihisha tahajia, sarufi, na mtindo wa maandiko ya programu. Martin Becze, Vitalik Buterin, Gavin Wood na wengine wachache ndio wahariri waanzilishi wa EIP kutoka mwaka 2015 kwenda mwishoni mwa mwaka 2016.
 
-- Alex Beregszaszi (EWASM/Msingi wa Ethereum)
-- Greg Colvin (Jamii)
-- Caseu Detrio (EWASM Msingi wa Ethereum)
-- Matt Garnett (Mto)
-- Hudson James (Msingi wa Ethereum)
-- Nick Johnson (ENS)
-- Nick Savers (Jamii)
-- Micah Zoltu (Jamii)
+Wahariri wa sasa wa EIP ni
 
-Wahariri wa EIP pamoja na wanachama wa jamii ya [Ethereum Cat Herders](https://ethereumcatherders.com/) na [Ethereum Magicians](https://ethereum-magicians.org/) wataamua EIP zipi zifanyiwe kazi, wanawajibu wa uwezeshaji wa EIPs pamoja na kuhamisha EIPs kwenda kwenye hatua ya "Mwisho" ama "Iliyotolewa".
+- Alex Beregszaszi (@axic)
+- Gavin John (@Pandapip1)
+- Greg Colvin (@gcolvin)
+- Matt Garnett (@lightclient)
+- Sam Wilson (@SamWilsn)
 
-Mchakato kamili wa usanifishaji pamoja na chati umeelezewa ndani ya [EIP-1](https://eips.ethereum.org/EIPS/eip-1)
+Wahariri wa pendekezo la uendelezaji wa Ethereum wa heshima ni.
 
-## Jifunze zaidi {#learn-more}
+- Casey Detrio (@cdetrio)
+- Hudson Jameson (@Souptacular)
+- Martin Becze (@wanderer)
+- Micah Zoltu (@MicahZoltu)
+- Nick Johnson (@arachnid)
+- Nick Savers (@nicksavers)
+- Vitalik Buterin (@vbuterin)
 
-Kama ungependa kusoma zaidi juu ya EIPs, nenda kwenye [tovuti ya EIPs](https://eips.ethereum.org/)unaweza kupata taarifa zaidi, pamoja na:
+Ikiwa ungependa kuwa mhariri wa EIP, tafadhali angalia [EIP-5069](https://eips.ethereum.org/EIPS/eip-5069).
 
-- [Aina tofauti za EIPs](https://eips.ethereum.org/)
-- [Orodha ya kila EIPs iliyokwisha tengenezwa](https://eips.ethereum.org/all)
-- [Takwimu za EIP na maana zake](https://eips.ethereum.org/)
+Wahariri wa pendekezo la uendelezaji wa Ethereum wanaamua ni lini pendekezo liko tayari kuwa pendekezo la uendelezaji wa Ethereum, na kuwasaidia waandishi wa pendekezo la uendelezaji wa Ethereum kusogeza pendekezo lao mbele. [Ethereum Cat Herders](https://www.ethereumcatherders.com/) husaidia kuandaa mikutano kati ya wahariri wa EIP na jumuiya (tazama [EIPIP](https://github.com/ethereum-cat-herders/EIPIP)).
 
-## Shiriki {#participate}
+Mchakato kamili wa usanifishaji pamoja na chati umeelezwa katika [EIP-1](https://eips.ethereum.org/EIPS/eip-1)
+
+## Jifunze zaidi {#learn-more}
 
-Mtu yeyote anaweza kuunda EIP ama ERC japo wanapaswa kusoma [EIP-1](https://eips.ethereum.org/EIPS/eip-1)inayotoa muhtasari wa mchakato wa EIP, EIP ni nini, aina za EIP, nini kinapaswa kuewepo kwenye hati ya EIP, muundfo wa EIP na kielezo, orodha ya Wahariri wa EIp na yote unayohitaji kujua kuhusu EIP kabla ya kutenegeza ya kwako. EIP yako mpya inapaswa kufafanua kipengele kipya ambacho si changamani sana bado si nafasi kuu na kinaweza kutumiwa na miradi katika mfumo ikolojia wa Ethereum. Sehemu ngumu zaidi ni uwezeshaji, wewe kama mwandishi unahitaji kuwezesha watu karibu na EIP yako, kukusanya maoni, kuandika makala kuelezea matatizo ambayo EIP yako inasuluhisha na ushirikiane na miradi ili kutekeleza EIP yako.
+Ikiwa ungependa kusoma zaidi kuhusu EIP, angalia [tovuti ya EIP](https://eips.ethereum.org/) na [EIP-1](https://eips.ethereum.org/EIPS/eip-1). Hapa kuna viungo vya muhimu.:
 
-Kama umevutiwa fuata mjadala au toa mawazo juu ya EIP, angalia [Ethereum Magicians Forums](https://ethereum-magicians.org/), sehemu EIPs zinapojadiliwa na jamii.
+- [Orodha ya kila Pendekezo la Kuboresha Ethereum](https://eips.ethereum.org/all)
+- [Maelezo ya aina zote za EIP](https://eips.ethereum.org/EIPS/eip-1#eip-types)
+- [Maelezo ya hali zote za EIP](https://eips.ethereum.org/EIPS/eip-1#eip-process)
 
-Pia tazama:
+### Miradi ya elimu ya jumuiya {#community-projects}
+
+- [PEEPanEIP](https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F) — _PEEPanEIP ni mfululizo wa video za elimu unaojadili Mapendekezo ya Kuboresha Ethereum (EIPs) na sifa muhimu za maboresho yajayo._
+- [EIPs.wtf](https://www.eips.wtf/) — _EIPs.wtf hutoa maelezo ya ziada kwa ajili ya Mapendekezo ya Kuboresha Ethereum (EIPs), ikiwa ni pamoja na hali zake, maelezo ya utekelezaji, pull requests zinazohusiana, na maoni ya jumuiya._
+- [EIP.Fun](https://eipfun.substack.com/) — _EIP.Fun hutoa habari za hivi punde kuhusu Mapendekezo ya Kuboresha Ethereum (EIPs), masasisho kuhusu mikutano ya EIP, na zaidi._
+- [EIPs Insight](https://eipsinsight.com/) — _EIPs Insight ni uwakilishi wa hali ya mchakato wa Mapendekezo ya Kuboresha Ethereum (EIPs) na takwimu kulingana na taarifa zilizokusanywa kutoka vyanzo tofauti._
+
+## Shiriki {#participate}
 
-- [Jinsi ya kuunda EIP](https://eips.ethereum.org/EIPS/eip-1)
+Kila mtu anaweza kuunda pendekezo la uendelezaji wa Ethereum. Kabla ya kuwasilisha pendekezo, ni lazima mtu asome [EIP-1](https://eips.ethereum.org/EIPS/eip-1) ambayo inaelezea mchakato wa EIP na jinsi ya kuandika EIP, na kutafuta maoni kwenye [Ethereum Magicians](https://ethereum-magicians.org/), ambapo mapendekezo hujadiliwa kwanza na jumuiya kabla ya rasimu kuwasilishwa.
 
-## Kumbukumbu {#references}
+## Marejeleo {#references}
 
 <cite class="citation">
 
diff --git a/public/content/translations/sw/energy-consumption/index.md b/public/content/translations/sw/energy-consumption/index.md
new file mode 100644
index 00000000000..dbf113c350d
--- /dev/null
+++ b/public/content/translations/sw/energy-consumption/index.md
@@ -0,0 +1,86 @@
+---
+title: Matumizi ya umeme ya Ethereum
+description: Maelezo ya msingi unayohitaji kuelewa matumizi ya nishati ya Ethereum.
+lang: sw
+---
+
+# Matumizi ya nishati ya Ethereum {#proof-of-stake-energy}
+
+Ethereum ni Mnyororo wa bloku ambao ni nafuu kwa mazingara. Utaratibu wa makubaliano wa [uthibitishaji-wa-dau](/developers/docs/consensus-mechanisms/pos) wa Ethereum hutumia ETH badala ya [nishati kuulinda mtandao](/developers/docs/consensus-mechanisms/pow). Matumizi ya nishati ya Ethereum ni takribani [~0.0026 TWh/mwaka](https://carbon-ratings.com/eth-report-2022) katika mtandao mzima wa kimataifa.
+
+Makadirio ya matumizi ya nishati kwa Ethereum yanatokana na utafiti wa [CCRI (Crypto Carbon Ratings Institute)](https://carbon-ratings.com). Walitoa makadirio ya chini-juu ya matumizi ya umeme na kiwango cha kaboni cha mtandao wa Ethereum ([tazama ripoti](https://carbon-ratings.com/eth-report-2022)). Walipima matumizi ya umeme ya nodi tofauti zenye usanidi mbalimbali wa maunzi na programu za wateja. Makadirio ya **2,601 MWh** (0.0026 TWh) kwa matumizi ya umeme ya kila mwaka ya mtandao yanalingana na utoaji wa kaboni wa kila mwaka wa **tani 870 za CO2e** kwa kutumia vipengele vya kiwango cha kaboni maalum kwa eneo. Thamani hii hubadilika nodi zinapoingia na kutoka kwenye mtandao - unaweza kufuatilia kwa kutumia makadirio ya wastani wa siku 7 kutoka kwa [Cambridge Blockchain network Sustainability Index](https://ccaf.io/cbnsi/ethereum) (kumbuka kuwa wanatumia mbinu tofauti kidogo kwa makadirio yao - maelezo yanapatikana kwenye tovuti yao).
+
+Ili kuweka matumizi ya nishati ya Ethereum katika muktadha, tunaweza kulinganisha makadirio ya mwaka kwa baadhi ya bidhaa na viwanda vingine. Hii hutusaidia kuelewa vizuri zaidi kama makadirio ya Ethereum ni ya juu au ya chini.
+
+<EnergyConsumptionChart />
+
+Chati iliyo hapo juu inaonyesha makadirio ya matumizi ya nishati katika TWh/mwaka kwa Ethereum, ikilinganishwa na bidhaa na viwanda vingine kadhaa. Makadirio yaliyotolewa yanatokana na maelezo yanayopatikana hadharani, yaliyofikiwa Julai 2023, pamoja na viungo vya vyanzo vinavyopatikana kwenye jedwali lililo hapa chini.
+
+|                                    | Matumizi ya nishati ya mwaka (TWh) | Ulinganisho na PoS Ethereum |                                                                                       Chanzo                                                                                      |
+| :--------------------------------- | :---------------------------------------------------: | :-------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| Kituo cha data cha Kimataifa       |                          190                          |           73,000x           |                                    [chanzo](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches)                                    |
+| Bitcoin                            |                          149                          |           53,000x           |                                                                 [chanzo](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
+| Uchimbaji wa Dhahabu               |                          131                          |           50,000x           |                                                                 [chanzo](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
+| Michezo ya video nchini Marekani\* |                           34                          |           13,000x           |                 [chanzo](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential)                 |
+| PoW Ethereum                       |                           21                          |            8,100x           |                                                                     [chanzo](https://ccaf.io/cbnsi/ethereum/1)                                                                    |
+| Google                             |                           19                          |            7,300x           |                                           [chanzo](https://www.gstatic.com/gumdrop/sustainability/google-2022-environmental-report.pdf)                                           |
+| Netflix                            |                 0.457                 |             176x            | [chanzo](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) |
+| PayPal                             |                  0.26                 |             100x            |                                  [chanzo](https://s202.q4cdn.com/805890769/files/doc_downloads/global-impact/CDP_Climate_Change_PayPal-\(1\).pdf)                                 |
+| AirBnB                             |                  0.02                 |              8x             |                              [chanzo](https://s26.q4cdn.com/656283129/files/doc_downloads/governance_doc_updated/Airbnb-ESG-Factsheet-\(Final\).pdf)                              |
+| **PoS Ethereum**                   |               **0.0026**              |            **1x**           |                                                                [chanzo](https://carbon-ratings.com/eth-report-2022)                                                               |
+
+\*Inajumuisha vifaa vya watumiaji wa mwisho kama vile Kompyuta, kompyuta mpakato, na koni za michezo.
+
+Kupata makadirio sahihi ya matumizi ya nishati ni ngumu, hasa wakati kile kinachopimwa kina mnyororo mgumu wa ugavi au maelezo ya upelekaji ambayo huathiri ufanisi wake. Kwa mfano, makadirio ya matumizi ya nishati kwa Netflix na Google hutofautiana kulingana na kama yanajumuisha tu nishati inayotumiwa kudumisha mifumo yao na kuwasilisha maudhui kwa watumiaji (_matumizi ya moja kwa moja_) au kama yanajumuisha matumizi yanayohitajika kutengeneza maudhui, kuendesha ofisi za kampuni, kutangaza, n.k. (_matumizi yasiyo ya moja kwa moja_). Matumizi yasiyo ya moja kwa moja yanaweza pia kujumuisha nishati inayohitajika kutumia maudhui kwenye vifaa vya mtumiaji wa mwisho kama vile runinga, kompyuta na simu za mkononi.
+
+Makadirio yaliyo hapo juu si ulinganisho kamili. Kiasi cha matumizi yasiyo ya moja kwa moja kinachohesabiwa hutofautiana kulingana na chanzo, na mara chache hujumuisha nishati kutoka kwa vifaa vya mtumiaji wa mwisho. Kila chanzo msingi kinajumuisha maelezo zaidi kuhusu kile kinachopimwa.
+
+Jedwali na chati hapo juu pia zinajumuisha ulinganisho na Bitcoin na Ethereum ya uthibitishaji-wa-kazi. Ni muhimu kutambua kuwa matumizi ya nishati ya mitandao ya uthibitishaji-wa-kazi si thabiti na hubadilika kila siku. Makadirio yanaweza pia kutofautiana sana kati ya vyanzo. Mada hii huvutia [mjadala](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/) wenye undani, sio tu kuhusu kiasi cha nishati inayotumiwa, lakini pia kuhusu vyanzo vya nishati hiyo na maadili yanayohusiana. Matumizi ya nishati si lazima yalingane moja kwa moja na athari za kimazingira kwa sababu miradi tofauti inaweza kutumia vyanzo tofauti vya nishati, ikiwa ni pamoja na sehemu ndogo au kubwa zaidi ya nishati mbadala. Kwa mfano, [Cambridge Bitcoin Electricity Consumption Index](https://ccaf.io/cbnsi/cbeci/comparisons) inaonyesha kuwa mahitaji ya mtandao wa Bitcoin kinadharia yanaweza kuendeshwa kwa gesi inayochomwa au umeme ambao ungepotea katika usafirishaji na usambazaji. Njia ya Ethereum kuelekea uendelevu ilikuwa ni kubadilisha sehemu ya mtandao inayotumia nishati nyingi na mbadala wa kijani.
+
+Unaweza kuvinjari makadirio ya matumizi ya nishati na utoaji wa kaboni kwa viwanda vingi kwenye tovuti ya [Cambridge Blockchain Network Sustainability Index](https://ccaf.io/cbnsi/ethereum).
+
+## Makadirio kwa kila muamala {#per-transaction-estimates}
+
+Makala nyingi hukadiria matumizi ya nishati \"kwa kila muamala\" kwa minyororo ya bloku. Hii inaweza kupotosha kwa sababu nishati inayohitajika kupendekeza na kuthibitisha bloku haitegemei idadi ya miamala ndani yake. Kitengo cha matumizi ya nishati kwa kila muamala kinamaanisha kuwa miamala michache ingesababisha matumizi madogo ya nishati na kinyume chake, jambo ambalo si kweli. Pia, makadirio ya kila muamala ni nyeti sana kwa jinsi upitishaji wa miamala wa mnyororo wa bloku unavyofafanuliwa, na kurekebisha ufafanuzi huu kunaweza kutumiwa vibaya ili kufanya thamani ionekane kubwa au ndogo.
+
+Kwenye Ethereum, kwa mfano, upitishaji wa miamala sio tu ule wa safu ya msingi - pia ni jumla ya upitishaji wa miamala wa [unda-mpya](/layer-2/) zake zote za \"safu ya 2\". Safu za 2 kwa ujumla hazijumuishwi katika mahesabu, lakini kujumuisha nishati ya ziada inayotumiwa na waratibu wa mfuatano (kidogo) na idadi ya miamala wanayochakata (kubwa) kunaweza kupunguza sana makadirio ya kila muamala. Hii ni sababu mojawapo kwa nini ulinganisho wa matumizi ya nishati kwa kila muamala katika mifumo tofauti unaweza kupotosha.
+
+## Deni la kaboni la Ethereum {#carbon-debt}
+
+Matumizi ya nishati ya Ethereum ni ya chini sana, lakini haikuwa hivi siku zote. Ethereum hapo awali ilitumia uthibitishaji-wa-kazi ambayo ilikuwa na gharama kubwa zaidi ya kimazingira kuliko utaratibu wa sasa wa uthibitishaji-wa-dau.
+
+Tangu mwanzo kabisa, Ethereum ilipanga kutekeleza utaratibu wa makubaliano unaotegemea uthibitishaji-wa-dau, lakini kufanya hivyo bila kuathiri usalama na ugatuzi kulichukua miaka ya utafiti na maendeleo ya kina. Kwa hivyo, utaratibu wa uthibitishaji-wa-kazi ulitumika kuanzisha mtandao. Uthibitishaji-wa-kazi huhitaji wachimbaji kutumia vifaa vyao vya kompyuta kukokotoa thamani, wakitumia nishati katika mchakato huo.
+
+![Kulinganisha matumizi ya nishati ya Ethereum kabla na baada ya Muungano, kwa kutumia Mnara wa Eiffel (urefu wa mita 330) upande wa kushoto kuashiria matumizi makubwa ya nishati kabla ya Muungano, na sanamu ndogo ya Lego ya urefu wa sentimita 4 upande wa kulia kuwakilisha upungufu mkubwa wa matumizi ya nishati baada ya Muungano](energy_consumption_pre_post_merge.png)
+
+CCRI inakadiria kuwa Muungano ulipunguza matumizi ya umeme ya mwaka ya Ethereum kwa zaidi ya **99.988%**. Vile vile, kiwango cha kaboni cha Ethereum kilipungua kwa takribani **99.992%** (kutoka tani 11,016,000 hadi tani 870 za CO2e). Ili kuweka hili katika muktadha, upungufu wa hewa chafu ni kama kutoka urefu wa Mnara wa Eiffel hadi sanamu ndogo ya kuchezea ya plastiki, kama inavyoonyeshwa kwenye mchoro ulio hapo juu. Matokeo yake, gharama ya kimazingira ya kuulinda mtandao imepungua sana. Wakati huo huo, usalama wa mtandao unaaminika kuboreka.
+
+## Safu ya programu ya kijani {#green-applications}
+
+Wakati matumizi ya nishati ya Ethereum ni ya chini sana, pia kuna jumuiya kubwa, inayokua, na yenye shughuli nyingi ya [**fedha za kuzalisha upya (ReFi)**](/refi/) inayojengwa kwenye Ethereum. Programu za ReFi hutumia vipengele vya DeFi kujenga programu za kifedha ambazo zina athari chanya za nje zinazofaidisha mazingira. ReFi ni sehemu ya harakati pana ya [\"solarpunk\"](https://en.wikipedia.org/wiki/Solarpunk) ambayo inalingana kwa karibu na Ethereum na inalenga kuunganisha maendeleo ya kiteknolojia na utunzaji wa mazingira. Hali ya ugatuzi, isiyo na ruhusa, na inayoweza kuundwa ya Ethereum inaifanya kuwa safu ya msingi inayofaa kwa jumuiya za ReFi na solarpunk.
+
+Mifumo asili ya Web3 ya kufadhili bidhaa za umma kama vile [Gitcoin](https://gitcoin.co) huendesha raundi za hali ya hewa ili kuchochea ujenzi unaozingatia mazingira kwenye safu ya programu ya Ethereum. Kupitia maendeleo ya mipango hii (na mingine, k.m., [DeSci](/desci/)), Ethereum inakuwa teknolojia yenye matokeo chanya kwa mazingira na jamii.
+
+<Alert variant="update">
+<AlertEmoji text=":evergreen_tree:" />
+<AlertContent>
+<AlertDescription>
+  Ikiwa unafikiri ukurasa huu unaweza kufanywa sahihi zaidi, tafadhali fungua suala au PR. Takwimu kwenye ukurasa huu ni makadirio kulingana na data inayopatikana hadharani - haziwakilishi taarifa rasmi au ahadi kutoka kwa timu ya ethereum.org, au Msingi wa Ethereum.
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## Masomo zaidi {#further-reading}
+
+- [Faharasa ya Uendelevu ya Mtandao wa Mnyororo wa bloku ya Cambridge](https://ccaf.io/cbnsi/ethereum)
+- [Ripoti ya Ikulu ya Marekani kuhusu minyororo ya bloku ya uthibitishaji-wa-kazi](https://web.archive.org/web/20221109005700/https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf)
+- [Utoaji wa Hewa Chafu wa Ethereum: Makadirio ya Chini-Juu](https://kylemcdonald.github.io/ethereum-emissions/) - _Kyle McDonald_
+- [Faharasa ya Matumizi ya Nishati ya Ethereum](https://digiconomist.net/ethereum-energy-consumption/) - _Digiconomist_
+- [ETHMerge.com](https://ethmerge.com/) - _[@InsideTheSim](https://twitter.com/InsideTheSim)_
+- [Muungano - Madhara kwa Matumizi ya Umeme na Kiwango cha Kaboni cha Mtandao wa Ethereum](https://carbon-ratings.com/eth-report-2022) - _CCRI_
+- [Matumizi ya nishati ya Ethereum](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8)
+
+## Mada zinazohusiana {#related-topics}
+
+- [Mnyororo Kioleza](/roadmap/beacon-chain)
+- [Muungano](/roadmap/merge/)
diff --git a/public/content/translations/sw/eth/supply/index.md b/public/content/translations/sw/eth/supply/index.md
new file mode 100644
index 00000000000..ded49c17ce0
--- /dev/null
+++ b/public/content/translations/sw/eth/supply/index.md
@@ -0,0 +1,80 @@
+---
+title: Kuelewa Ugavi na Utoaji wa ETH
+description: Mwongozo wa mwanzo wa usambazaji na utoaji wa ETH, unaojumuisha dhana muhimu kama vile EIPs, PoS, na EIP-1559.
+lang: sw
+---
+
+# Ugavi na Utoaji wa ETH {#eth-utoaji-na-ugavi}
+
+## Mahitaji ya awali {#prerequisites}
+
+Nakala hii imeandikwa kwa Kompyuta na hakuna maarifa ya awali. Hata hivyo, ili kuelewa mada kikamilifu, inafaa kuwa na uelewa wa kimsingi wa dhana kama vile [Mapendekezo ya Uboreshaji ya Ethereum (EIPs)](/eips/#introduction-to-ethereum-improvement-proposals), [Uthibitisho-wa-kazi (PoW)](/developers/docs/consensus-mechanisms/pow/), [Uthibitisho-wa-Hisa (PoS)](/developers/docs/consensus-mechanisms/pos/), na [Sasisho la London](/ethereum-forks/#london).
+
+## Je, kuna Tokeni ngapi za ETH Leo? "Ugavi wa sasa wa Eth"
+
+Ugavi wa jumla wa ETH ni wa nguvu na hubadilika kila mara kutokana na sababu kuu mbili:
+
+1. **Utoaji wa Uthibitisho wa Hisa (PoS)**: ETH mpya imeundwa kama zawadi kwa waidhinishaji wanaolinda mtandao
+2. **EIP-1559 Inachoma**: Sehemu ya ada za muamala huondolewa kabisa kutoka kwa mzunguko
+
+Unaweza kufuatilia usambazaji wa sasa na mabadiliko haya katika muda halisi kwenye mifumo kama vile [Ultrasound Money](https://ultrasound.money).
+
+Ugavi na utoaji wa Ethereum ni vipimo muhimu vya kuelewa afya na mustakabali wa mtandao. Lakini utoaji wa ETH unamaanisha nini hasa? Hebu tuivunje.
+
+## Kwa nini Ugavi na Utoaji wa ETH ni Muhimu
+
+Katika fedha za jadi, benki kuu hudhibiti usambazaji wa pesa, mara nyingi huchapisha zaidi ili kuchochea uchumi. Ethereum, kwa upande mwingine, inafanya kazi kwa mfumo wa uwazi na unaotabirika unaotawaliwa na kanuni zake. Kujua ni ETH ngapi zipo na jinsi ETH mpya inavyotolewa husaidia:
+
+- **Jenga Uaminifu**: Jumuiya ya Ethereum inaweza kuthibitisha ugavi na utoaji wa data moja kwa moja kutoka kwa kiambajengo.
+- **Elewa Thamani**: Uhusiano kati ya utoaji na viwango vya kuchomwa vya ETH huathiri mfumuko wa bei au mpunguzo wa bei wa ETH, na kuathiri thamani yake baada ya muda.
+- Fuatilia Afya ya Mtandao: Mabadiliko katika viwango vya utoaji na upotezaji yanaonyesha shughuli na usalama wa mtandao.
+
+## Utoaji wa ETH ni nini? {#eth-utoaji}
+
+Utoaji wa ETH unarejelea mchakato wa kuunda ETH mpya kama zawadi kwa wathibitishaji wanaolinda mtandao wa Ethereum. Ni tofauti na jumla ya usambazaji, ambayo ni jumla ya kiasi cha ETH katika mzunguko.
+
+### Kwa maneno rahisi:
+
+- **Utoaji** huongeza ETH mpya kwenye mtandao.
+- **Kuungua** (iliyoletwa na EIP-1559) huondoa ETH kutoka kwa mtandao kwa kuharibu sehemu ya ada za ununuzi.
+
+Nguvu hizi mbili huamua ikiwa usambazaji wa Ethereum unakua (mfumko wa bei) au hupungua (kupungua kwa bei) baada ya muda.
+
+## Ugavi na Utoaji wa ETH Leo {#eth-ugavi-leo}
+
+Mfumo wa Uthibitisho wa Hisa (PoS) wa Ethereum umepunguza kwa kiasi kikubwa utoaji wa ETH ikilinganishwa na muundo wake wa awali wa Uthibitisho wa Kazi (PoW). Vithibitishaji—ambao hufunga ETH ili kulinda mtandao—jipatie ETH kama zawadi. Unaweza kuona kiwango cha sasa cha utoaji kwenye [Ultrasound Money](https://ultrasound.money).
+
+Hata hivyo, nambari hii ni kinyumbulisho. Shukrani kwa EIP-1559, wakati shughuli za mtandao ziko juu, viwango vya kuchomwa vya ETH vinaweza kuzidi utoaji, na kusababisha athari ya kupungua. Kwa mfano, wakati wa mahitaji makubwa, kama vile uzinduzi wa NFT au shughuli za DeFi, ETH zaidi inaweza kuchomwa kuliko iliyotolewa.
+
+### Zana za Kufuatilia Ugavi na Utoaji wa ETH:
+
+- [Ultrasound Money](https://ultrasound.money) - Ufuatiliaji wa wakati halisi wa usambazaji wa ETH, utoaji na viwango vya upotezaji
+- [Etherscan](https://etherscan.io) - Zuia kigunduzi kwa kutumia vip
+
+## Mambo Yanayoathiri Ugavi na Utoaji wa ETH ya Baadaye {#future-eth-supply}
+
+Ugavi wa siku zijazo wa Ethereum haujarekebishwa-inategemea tofauti kadhaa:
+
+1. **Kushiriki kwa kushikilia**:
+   - Waidhinishaji zaidi wanaojiunga na mtandao inamaanisha zawadi zaidi za ETH zinasambazwa.
+   - Wathibitishaji wachache wanaoshiriki wanaweza kupunguza utoaji.
+   - Pata maelezo zaidi kuhusu [staking](/roadmap/).
+
+2. **Shughuli ya Mtandao**:
+   - Kiasi kikubwa cha miamala husababisha ETH zaidi kuchomwa, uwezekano wa kukomesha au kuzidi utoaji.
+   - Soma kuhusu [ada za muamala](/watengenezaji/hati/ada/) na jinsi zinavyoathiri upotezaji.
+
+3. **Maboresho ya Itifaki**:
+   - Mabadiliko yajayo kwa msimbo wa Ethereum yanaweza kurekebisha zawadi kubwa au mifumo ya upotezaji, na kuchagiza zaidi mienendo ya usambazaji.
+   - Endelea kusasishwa na [mpango wa maendeleo wa Ethereum](/map/map/).
+
+## Muhtasari: Ugavi wa ETH, Utoaji, na Nini Kinachofuata {#recap}
+
+Hapa kuna muhtasari wa haraka wa kile unachohitaji kujua kuhusu usambazaji na utoaji wa ETH:
+
+- **Ugavi wa ETH**: Inabadilika na inabadilika kila mara, inayoweza kufuatiliwa kwa wakati halisi kupitia zana kama vile [Pesa ya Ultrasound](https://ultrasound.money)
+- **Utoaji Chini ya PoS**: Imepunguzwa kwa kiasi kikubwa ikilinganishwa na PoW, huku zawadi zikienda kwa wathibitishaji. Angalia viwango vya sasa kwenye [Ultrasound Money](https://ultrasound.money)
+- **Jukumu la EIP-1559**: Upotezaji wa ETH unaweza kufanya mtandao upungue bei wakati wa shughuli nyingi
+- **Mitindo ya Wakati Ujao**: Ushiriki thabiti, mahitaji ya mtandao, na masasisho ya itifaki yote yataunda usambazaji wa ETH
+
+Kuelewa utoaji wa ETH husaidia kufifisha thamani ya Ethereum na uwezo wake kama mali iliyopunguzwa bei, katika mfumo mtawanyo. Kwa maelezo zaidi kuhusu jinsi muunganiko ulivyoathiri usambazaji wa ETH, angalia [uchanganuzi wetu wa kina](/roadmap/merge/issuance/). Je! ungependa kujua mustakabali wa ETH? Piga mbizi zaidi ukitumia zana kama vile [Ultrasound Money](https://ultrasound.money) au chunguza [miongozo yetu ya staking](/staking/).
\ No newline at end of file
diff --git a/public/content/translations/sw/ethereum-forks/index.md b/public/content/translations/sw/ethereum-forks/index.md
new file mode 100644
index 00000000000..ff923b7b7fd
--- /dev/null
+++ b/public/content/translations/sw/ethereum-forks/index.md
@@ -0,0 +1,659 @@
+---
+title: Mfuatano wa matukio ya uma zote za Ethereum (2014 hadi sasa)
+description: Historia ya blockchain ya Ethereum ikijumuisha hatua kuu, matoleo, na migawanyiko (forks).
+lang: sw
+sidebarDepth: 1
+---
+
+# Mfuatano wa matukio ya uma zote za Ethereum (2014 hadi sasa) {#the-history-of-ethereum}
+
+Mfuatano wa matukio yote makuu, migawanyiko (forks), na masasisho ya blockchain ya Ethereum.
+
+<ExpandableCard title="Uma ni nini?" contentPreview="Mabadiliko kwenye kanuni za itifaki ya Ethereum yanayojumuisha masasisho ya kiufundi.">
+
+Uma ni wakati masasisho makubwa ya kiufundi au mabadiliko yanahitajika kufanywa kwenye mtandao - kwa kawaida hutokana na [Mapendekezo ya Uboreshaji wa Ethereum (EIPs)](/eips/) na kubadilisha "sheria" za itifaki.
+
+Wakati masasisho yanapohitajika katika programu za kiasili zinazodhibitiwa na kituo kimoja, kampuni huchapisha tu toleo jipya kwa mtumiaji wa mwisho Blockchains hufanya kazi tofauti kwa sababu hakuna mmiliki mmoja wa kati. [Ethereum clients](/developers/docs/nodes-and-clients/) lazima wasasishe programu zao ili kutekeleza sheria mpya za uma. Zaidi ya hayo, waundaji wa blok (wachimbaji katika mfumo wa Proof-of-Work, validators katika mfumo wa Proof-of-Stake) na nodi lazima waweke blok na kuthibitisha kulingana na kanuni mpya. [Zaidi kuhusu taratibu za makubaliano](/developers/docs/consensus-mechanisms/)
+
+Mabadiliko haya ya sheria yanaweza kuunda mgawanyiko wa muda katika mtandao. Mabadiliko haya ya kanuni yanaweza kusababisha mgawanyiko wa muda mfupi katika mtandao. Migawanyiko kwa kawaida hukubaliana mapema ili wateja wa mtandao wakubali mabadiliko kwa wakati mmoja, na fork yenye masasisho inakuwa mnyororo mkuu. Hata hivyo, katika matukio machache, kutokubaliana kuhusu migawanyiko kunaweza kusababisha mtandao kugawanyika kudumu – mfano maarufu ni kuundwa kwa Ethereum Classic kupitia <a href="#dao-fork">DAO fork</a>
+</ExpandableCard>
+
+<ExpandableCard title="Kwa nini masasisho mengine yana majina mengi?" contentPreview="Majina ya masasisho hufuata mtindo">
+
+Programu inayounga mkono Ethereum imeundwa kwa sehemu mbili, zinazojulikana kama tabaka la utekelezaji na tabaka la makubaliano
+
+**Utoaji majina wa sasisho la utekelezaji**
+
+Tangu 2021, masasisho ya **safu ya utekelezaji** yanaitwa kulingana na majina ya miji ya [maeneo ya awali ya Devcon](https://devcon.org/en/past-events/) kwa mfuatano wa matukio:
+
+| Jina la Sasisho | Mwaka wa Devcon | Namba ya Devcon | Tarehe ya Sasisho |
+| --------------- | --------------- | --------------- | ----------------- |
+| Berlin          | 2014            | 0               | Aprili 15, 2021   |
+| London          | 2015            | I               | Agosti 5, 2021    |
+| Shanghai        | 2016            | II              | Aprili 12, 2023   |
+| Cancun          | 2017            | III             | Machi 13, 2024    |
+| **Prague**      | 2018            | IV              | TBD - Ifuatayo    |
+| _Osaka_         | 2019            | V               | TBD               |
+| _Bogota_        | 2022            | VI              | TBD               |
+| _Bangkok_       | 2024            | VII             | TBD               |
+
+**Utoaji majina wa sasisho la makubaliano**
+
+Tangu kuzinduliwa kwa [Mnyororo Kioleza](/glossary/#beacon-chain), masasisho ya **safu ya makubaliano** yanaitwa kwa majina ya nyota za angani yanayoanza na herufi zinazofuata kwa mpangilio wa alfabeti:
+
+| Jina la Sasisho                                               | Tarehe ya Sasisho |
+| ------------------------------------------------------------- | ----------------- |
+| Mwanzo wa Mnyororo wa Beacon                                  | Desemba 1, 2020   |
+| [Altair](https://en.wikipedia.org/wiki/Altair)                | Oktoba 27, 2021   |
+| [Bellatrix](https://en.wikipedia.org/wiki/Bellatrix)          | Septemba 6, 2022  |
+| [Capella](https://en.wikipedia.org/wiki/Capella)              | Aprili 12, 2023   |
+| [Deneb](https://en.wikipedia.org/wiki/Deneb)                  | Machi 13, 2024    |
+| [**Electra**](https://en.wikipedia.org/wiki/Electra_\(star\)) | TBD - Ifuatayo    |
+| [_Fulu_](https://en.wikipedia.org/wiki/Fulu_\(star\))         | TBD               |
+
+**Utoaji majina uliounganishwa**
+
+Masasisho ya utekelezaji na makubaliano awali yalitolewa kwa nyakati tofauti, lakini baada ya [Muungano](/roadmap/merge/) mnamo 2022 yametekelezwa kwa wakati mmoja. Kwa hivyo, maneno ya kawaida yameibuka ili kurahisisha kurejelea masasisho haya kwa kutumia neno moja lililounganishwa Hii ilianza na masasisho ya Shanghai-Capella, ambayo kwa kawaida hujulikana kama 'Shapella', na inaendelea na masasisho ya Cancun-Deneb (Dencun), pamoja na Prague-Electra (Pectra).
+
+| Sasisho la Utekelezaji | Sasisho la Makubaliano | Jina Fupi  |
+| ---------------------- | ---------------------- | ---------- |
+| Shanghai               | Capella                | "Shapella" |
+| Cancun                 | Deneb                  | "Dencun"   |
+| Prague                 | Electra                | "Pectra"   |
+| Osaka                  | Fulu                   | "Fusaka"   |
+</ExpandableCard>
+
+Nenda moja kwa moja kwenye taarifa kuhusu baadhi ya masasisho muhimu yaliyopita: [Mnyororo Kioleza](/roadmap/beacon-chain/); [Muungano](/roadmap/merge/); na [EIP-1559](#london)
+
+Je, unatafuta visasisho vya itifaki vya siku zijazo? [Jifunze kuhusu masasisho yajayo kwenye ramani ya Ethereum](/roadmap/).
+
+<Divider />
+
+## 2025 {#2025}
+
+### Fulu-Osaka ("Fusaka") {#fusaka}
+
+<NetworkUpgradeSummary name="fusaka" />
+
+[Zaidi kuhusu Fusaka](/roadmap/fusaka/)
+
+### Prague-Electra ("Pectra") {#pectra}
+
+<NetworkUpgradeSummary name="pectra" />
+
+Sasisho la Prague-Electra ("Pectra") lilijumuisha maboresho kadhaa kwenye itifaki ya Ethereum yaliyozalisha uzoefu bora kwa watumiaji wote, mitandao ya safu ya 2, stakers, na waendeshaji wa nodi.
+
+Staking ilipata uboreshaji kwa kuunganisha akaunti za wathibitishaji, na kuboresha udhibiti wa fedha zilizowekwa kwenye hisa kwa kutumia anwani ya uondoaji ya utekelezaji. EIP-7251 iliongeza usawa bora zaidi kwa kithibitishaji kimoja hadi 2048, kuboresha ufanisi wa mtaji kwa wadau. EIP-7002 iliruhusu akaunti ya utekelezaji kuanzisha kwa usalama hatua za wathibitishaji, ikiwa ni pamoja na kutoka kwenye staking au kutoa sehemu ya fedha, ikiboresha uzoefu wa stakers wa ETH, huku ikisaidia kuimarisha uwajibikaji kwa waendeshaji wa nodi.
+
+Sehemu zingine za uboreshaji zililenga kuboresha matumizi kwa watumiaji wa kawaida. EIP-7702 ilileta uwezo kwa akaunti ya kawaida isiyo ya mkataba-erevu ([EOA](/glossary/#eoa)) kutekeleza msimbo unaofanana na ule wa mkataba-erevu. Hii ilifungua uwezo usio na kikomo kwa akaunti za kawaida za Ethereum, kama vile kuunganisha miamala, ufadhili wa gharama za miamala, uthibitishaji mbadala, udhibiti wa matumizi wa fedha kwa mpango, mifumo ya urejeshaji akaunti, na mengine mengi.
+
+<ExpandableCard title="Pectra EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+Uzoefu bora wa mtumiaji:
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7702">EIP-7702</a> - <em>Set EOA account code</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7691">EIP-7691</a> - <em>Blob throughput increase</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7623">EIP-7623</a> - <em>Increase calldata cost</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7840">EIP-7840</a> - <em>Add blob schedule to EL config files</em></li>
+</ul>
+
+Uzoefu bora wa staking:
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7251">EIP-7251</a> - <em>Increase the <code>MAX_EFFECTIVE_BALANCE</code></em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7002">EIP-7002</a> - <em>Execution layer triggerable exits</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7685">EIP-7685</a> - <em>General purpose execution layer requests</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-6110">EIP-6110</a> - <em>Supply validator deposits on chain</em></li>
+</ul>
+
+Maboresho ya ufanisi na usalama wa itifaki:
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2537">EIP-2537</a> - <em>Precompile for BLS12-381 curve operations</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2935">EIP-2935</a> - <em>Save historical block hashes in state</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7549">EIP-7549</a> - <em>Move committee index outside Attestation</em></li>
+</ul>
+</ExpandableCard>
+
+- [Pectra.wtf](https://pectra.wtf)
+- [Jinsi Pectra itakavyoboresha uzoefu wa kusimamisha](https://www.kiln.fi/post/next-ethereum-upgrade-how-pectra-will-enhance-the-staking-experience)
+- [Soma vigezo vya sasisho la Electra](https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/)
+- [Maswali Yanayoulizwa Mara kwa Mara kuhusu Prague-Electra ("Pectra")](/roadmap/pectra/)
+
+<Divider />
+
+## 2024 {#2024}
+
+### Cancun-Deneb ("Dencun") {#dencun}
+
+<NetworkUpgradeSummary name="dencun" />
+
+#### Muhtasari wa Cancun {#cancun-summary}
+
+Sasisho la Cancun lina seti ya maboresho kwa _utekelezaji_ wa Ethereum yanayolenga kuboresha uongezekaji, kwa pamoja na masasisho ya makubaliano ya Deneb.
+
+Hasa, hili linajumuisha EIP-4844, inayojulikana kama **Proto-Danksharding**, ambayo inapunguza kwa kiasi kikubwa gharama ya uhifadhi wa data kwa unda-mpya za safu ya 2. Hili linaafikiwa kupitia kuanzishwa kwa "blobs" za data ambazo huwezesha rollups ya kuchapisha data kwa Mainnet kwa muda mfupi. Hii inasababisha ada za ununuzi za chini sana kwa watumiaji wa safu ya 2 ya rollups.
+
+<ExpandableCard title="Cancun EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1153">EIP-1153</a> - <em>Transient storage opcodes</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4788">EIP-4788</a> - <em>Beacon block root in the EVM</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4844">EIP-4844</a> - <em>Shard blob transactions (Proto-Danksharding)</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-5656">EIP-5656</a> - <em><code>MCOPY</code> - Memory copying instruction</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-6780">EIP-6780</a> - <em><code>SELFDESTRUCT</code> only in same transaction</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7516">EIP-7516</a> - <em><code>BLOBBASEFEE</code> opcode</em></li>
+</ul>
+</ExpandableCard>
+
+- [Unda-mpya za safu ya 2](/layer-2/)
+- [Proto-Danksharding](/roadmap/scaling/#proto-danksharding)
+- [Danksharding](/roadmap/danksharding/)
+- [Soma vigezo vya sasisho la Cancun](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md)
+
+#### Muhtasari wa Deneb {#deneb-summary}
+
+Sasisho la Deneb lina seti ya maboresho kwa _makubaliano_ ya Ethereum yanayolenga kuboresha uongezekaji. Uboreshaji huu unafanyika sambamba na maboresho ya utekelezaji ya Cancun ili kuwezesha Proto-Danksharding (EIP-4844), pamoja na maboresho mengine kwenye Mnyororo wa Beacon.
+
+Ujumbe uliosainiwa wa “kutoka hiari” uliotengenezwa mapema hauendi tena, hivyo kuipa watumiaji udhibiti zaidi juu ya fedha zao zinazoshikiliwa na mtoaji wa nodi wa mtu wa tatu. Kwa kutumia ujumbe huu uliosainiwa wa kutoka, **watumiaji wanaoshiriki staking** wanaweza kuwapisha wengine kuendesha nodi huku wakiwa na uwezo wa kuondoka salama na kutoa fedha zao wakati wowote, bila kuhitaji ruhusa kutoka kwa mtu yeyote.
+
+EIP-7514 inaleta ukaguzi kwenye utoaji wa ETH kwa kuweka kikomo cha kiwango cha “churn”, yaani idadi ya wakaguzi wanaoweza kujiunga na mitandao, hadi (8) kwa kila epoch. Kwa kuwa utoaji wa ETH unalingana na jumla ya ETH iliyosimamishwa, kuweka kikomo kwa idadi ya wathibitishaji wanaojiunga kunapunguza _kasi ya ukuaji_ wa ETH mpya iliyotolewa, huku pia ikipunguza mahitaji ya maunzi kwa waendeshaji wa nodi, na kusaidia ugatuzi.
+
+<ExpandableCard title="Deneb EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4788">EIP-4788</a> - <em>Beacon block root in the EVM</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4844">EIP-4844</a> - <em>Shard blob transactions</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7044">EIP-7044</a> - <em>Perpetually valid signed voluntary exits</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7045">EIP-7045</a> - <em>Increase max attestation inclusion slot</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7514">EIP-7514</a> - <em>Add max epoch churn limit</em></li>
+</ul>
+</ExpandableCard>
+
+- [Soma vigezo vya sasisho la Deneb](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/)
+- [Maswali Yanayoulizwa Mara kwa Mara kuhusu Cancun-Deneb ("Dencun")](/roadmap/dencun/)
+
+<Divider />
+
+## 2023 {#2023}
+
+### Shanghai-Capella ("Shapella") {#shapella}
+
+<NetworkUpgradeSummary name="shapella" />
+
+#### Muhtasari wa Shanghai {#shanghai-summary}
+
+Uboreshaji wa Shanghai ulipeleka utoaji wa staking kwenye safu ya utekelezaji. Sambamba na uboreshaji wa Capella, hii iliruhusu vitalu kupokea operesheni za uondoaji, ambazo zinawawezesha watumiaji wa staking kutoa ETH zao kutoka mnyororo wa Beacon kwenda safu ya utekelezaji.
+
+<ExpandableCard title="Shanghai EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3651">EIP-3651</a> – <em>Starts the <code>COINBASE</code> address warm</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3855">EIP-3855</a> – <em>New <code>PUSH0</code> instruction</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3860">EIP-3860</a> – <em>Limit and meter initcode</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4895">EIP-4895</a> – <em>Beacon chain push withdrawals as operations</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-6049">EIP-6049</a> - <em>Deprecate <code>SELFDESTRUCT</code></em></li>
+</ul>
+</ExpandableCard>
+
+- [Soma vigezo vya sasisho la Shanghai](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md)
+
+#### Muhtasari wa Capella {#capella-summary}
+
+Uboreshaji wa Capella ulikuwa uboresaji mkubwa wa tatu wa safu ya makubaliano ( mnyororo wa Beacon) na uliwezesha utoaji wa staking. Capella ilitokea kwa usawa na uboreshaji wa safu ya utekelezaji, Shanghai, na kuwezesha utendakazi wa uondoaji wa staking.
+
+Uboreshaji huu wa safu ya makubaliano ulileta uwezo kwa watumiaji wa staking ambao hawakutoa sifa za kujiondoa pamoja na amana zao za awali kufanya hivyo, hivyo kuwezesha utoaji.
+
+Uboreshaji pia uliweka uwezo wa kufutwa kwa akaunti moja kwa moja, ambao unaendelea kuchambua akaunti za wadhibiti kwa malipo yoyote ya tuzo zilizopo au uondoaji kamili.
+
+- [Zaidi kuhusu uondoaji wa kusimamisha](/staking/withdrawals/).
+- [Soma vigezo vya sasisho la Capella](https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/)
+
+<Divider />
+
+## 2022 {#2022}
+
+### Paris (Muungano) {#paris}
+
+<NetworkUpgradeSummary name="paris" />
+
+#### Muhtasari {#paris-summary}
+
+Sasisho la Paris lilianzishwa na mnyororo wa bloku wa uthibitishaji-wa-kazi kupita [ugumu wa jumla wa mwisho](/glossary/#terminal-total-difficulty) wa 58750000000000000000000. Hili lilitokea katika kitalu 15537393 mnamo 15 Septemba 2022, likichochea uboreshaji wa Paris katika kitalu kilichofuata. Paris ulikuwa mpito wa [Muungano](/roadmap/merge/) - sifa yake kuu ilikuwa kuzima algoriti ya uchimbaji ya [uthibitishaji-wa-kazi](/developers/docs/consensus-mechanisms/pow) na mantiki ya makubaliano husika na kuwasha [proof-of-stake](/developers/docs/consensus-mechanisms/pos) badala yake. Paris yenyewe ilikuwa sasisho kwa [programu za utekelezaji](/developers/docs/nodes-and-clients/#execution-clients) (sawa na Bellatrix kwenye safu ya makubaliano) iliyowawezesha kuchukua maagizo kutoka kwa [programu zao za makubaliano](/developers/docs/nodes-and-clients/#consensus-clients) zilizounganishwa nao. Hii ilihitaji seti mpya ya mbinu za ndani za API, zinazojulikana kwa pamoja kama [Engine API](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md), kuwashwa. Bila shaka hili lilikuwa sasisho muhimu zaidi katika historia ya Ethereum tangu [Homestead](#homestead)!
+
+- [Soma vigezo vya sasisho la Paris](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md)
+
+<ExpandableCard title="Paris EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3675">EIP-3675</a> – <em>Upgrade consensus to Proof-of-Stake</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4399">EIP-4399</a> – <em>Supplant DIFFICULTY opcode with PREVRANDAO</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### Bellatrix {#bellatrix}
+
+<NetworkUpgradeSummary name="bellatrix" />
+
+#### Muhtasari {#bellatrix-summary}
+
+Sasisho la Bellatrix lilikuwa sasisho la pili lililopangwa kwa [Mnyororo Kioleza](/roadmap/beacon-chain), likiandaa mnyororo kwa ajili ya [Muungano](/roadmap/merge/). Huleta adhabu za waidhinishaji kwa maadili yao kamili kwa kutokuwa na shughuli na makosa yanayoweza kupunguzwa. Bellatrix pia inajumuisha sasisho kwa sheria za uchaguzi wa umma ili kuandaa mnyororo wa Kuunganisha na mpito kutoka kizuizi cha mwisho cha uthibitisho wa kazi hadi kizuizi cha kwanza cha uthibitisho wa kitalu. Hii inajumuisha kuzifanya programu za makubaliano zifahamu kuhusu [ugumu wa jumla wa mwisho](/glossary/#terminal-total-difficulty) wa 58750000000000000000000.
+
+- [Soma vigezo vya sasisho la Bellatrix](https://github.com/ethereum/consensus-specs/tree/dev/specs/bellatrix)
+
+---
+
+### Gray Glacier {#gray-glacier}
+
+<NetworkUpgradeSummary name="grayGlacier" />
+
+#### Muhtasari {#gray-glacier-summary}
+
+Sasisho la mtandao la Gray Glacier lilisogeza nyuma [bomu la ugumu](/glossary/#difficulty-bomb) kwa miezi mitatu. Hili ndilo badiliko pekee lililoletwa katika sasisho hili, na linafanana kiasili na masasisho ya [Arrow Glacier](#arrow-glacier) na [Muir Glacier](#muir-glacier). Mabadiliko kama hayo yamefanywa kwenye masasisho ya mtandao ya [Byzantium](#byzantium), [Constantinople](#constantinople) na [London](#london).
+
+- [Blogu ya EF - Tangazo la Sasisho la Gray Glacier](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement/)
+
+<ExpandableCard title="Gray Glacier EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-5133">EIP-5133</a> – <em>delays the difficulty bomb until September 2022</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2021 {#2021}
+
+### Arrow Glacier {#arrow-glacier}
+
+<NetworkUpgradeSummary name="arrowGlacier" />
+
+#### Muhtasari {#arrow-glacier-summary}
+
+Sasisho la mtandao la Arrow Glacier lilisogeza nyuma [bomu la ugumu](/glossary/#difficulty-bomb) kwa miezi kadhaa. Hili ndilo badiliko pekee lililoletwa katika sasisho hili, na linafanana kiasili na sasisho la [Muir Glacier](#muir-glacier). Mabadiliko kama hayo yamefanywa kwenye masasisho ya mtandao ya [Byzantium](#byzantium), [Constantinople](#constantinople) na [London](#london).
+
+- [Blogu ya EF - Tangazo la Sasisho la Arrow Glacier](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement/)
+- [Ethereum Cat Herders - Sasisho la Ethereum Arrow Glacier](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002)
+
+<ExpandableCard title="Arrow Glacier EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4345">EIP-4345</a> – <em>delays the difficulty bomb until June 2022</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### Altair {#altair}
+
+<NetworkUpgradeSummary name="altair" />
+
+#### Muhtasari {#altair-summary}
+
+Sasisho la Altair lilikuwa sasisho la kwanza lililopangwa kwa [Mnyororo Kioleza](/roadmap/beacon-chain). Iliongeza usaidizi kwa "kamati za kusawazisha" - kuwezesha wateja wepesi, na kuongezeka kwa kutotumika kwa kiidhinisha na kupunguza adhabu kadiri maendeleo yanavyosonga mbele kuelekea Kuunganisha.
+
+- [Soma vigezo vya sasisho la Altair](https://github.com/ethereum/consensus-specs/tree/dev/specs/altair)
+
+#### <Emoji text=":tada:" size={1} className="me-2" />Ukweli wa kufurahisha! {#altair-fun-fact}
+
+Altair ilikuwa sasisho kuu la kwanza la mtandao ambalo lilikuwa na wakati kamili wa uchapishaji. Kila sasisho la awali lilitokana na nambari ya kitalu iliyotangazwa kwenye mnyororo wa uthibitisho wa kazi, ambapo nyakati za vitalu hutofautiana. Mnyororo wa Beacon hauhitaji kusuluhishwa kwa uthibitisho wa kazi, na badala yake hufanya kazi kwa mfumo wa enzi unaotegemea wakati unaojumuisha "nafasi" 32 za sekunde kumi na mbili ambapo wathibitishaji wanaweza kupendekeza vizuizi. Hii ndiyo sababu tulijua ni lini hasa tungepiga epoch 74,240 na Altair ikawa moja kwa moja!
+
+- [Wakati wa bloku](/developers/docs/blocks/#block-time)
+
+---
+
+### London {#london}
+
+<NetworkUpgradeSummary name="london" />
+
+#### Muhtasari {#london-summary}
+
+Sasisho la London lilianzisha [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), ambalo lilifanyia marekebisho soko la ada za miamala, pamoja na mabadiliko ya jinsi marejesho ya gesi yanavyoshughulikiwa na ratiba ya [Zama za Barafu](/glossary/#ice-age).
+
+#### Uboreshaji wa London / EIP-1559 ulikuwa nini? {#eip-1559}
+
+Kabla ya Uboreshaji wa London, Ethereum ilikuwa na vitalu vya ukubwa usiobadilika. Wakati wa mahitaji ya juu ya mtandao, vitalu hivi vilifanya kazi kwa uwezo kamili. Kama matokeo, watumiaji mara nyingi walilazimika kungoja mahitaji yapunguzwe ili kujumuishwa kwenye kitalu, ambayo ilisababisha uzoefu mbaya wa mtumiaji. Uboreshaji wa London ulianzisha vitalu vya ukubwa tofauti kwa Ethereum.
+
+Jinsi ada za miamala kwenye mtandao wa Ethereum zilivyokokotolewa ilibadilika na [Sasisho la London](/ethereum-forks/#london) la Agosti 2021. Kabla ya sasisho la London, ada zilikokotolewa bila kutenganisha ada za `msingi` na `kipaumbele`, kama ifuatavyo:
+
+Wacha tuseme Alice alilazimika kumlipa Bob 1 ETH. Katika shughuli hiyo, kikomo cha gharama ni 21,000, na bei ya gharama za miamalani 200 gwei.
+
+Ada ya jumla ingekuwa: `Vizio vya gesi (kikomo) * Bei ya gesi kwa kizio` yaani `21,000 * 200 = 4,200,000 gwei` au 0.0042 ETH
+
+Utekelezaji wa [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) katika Sasisho la London ulifanya utaratibu wa ada ya muamala kuwa mgumu zaidi, lakini ulifanya ada za gesi zitabirike zaidi, na kusababisha soko la ada ya muamala lenye ufanisi zaidi. Watumiaji wanaweza kuwasilisha miamala na `maxFeePerGas` inayolingana na kiasi wanachotaka kulipa ili muamala utekelezwe, wakijua kuwa hawatalipa zaidi ya bei ya soko ya gesi (`baseFeePerGas`), na watarejeshewa kiasi chochote cha ziada, ukiondoa bakshishi yao.
+
+Video hii inaelezea EIP-1559 na manufaa yake: [EIP-1559 Imefafanuliwa](https://www.youtube.com/watch?v=MGemhK9t44Q)
+
+- [Je, wewe ni mjenzi wa dapp? Hakikisha unasasisha maktaba na zana zako.](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/london-ecosystem-readiness.md)
+- [Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement/)
+- [Soma ufafanuzi wa Ethereum Cat Herder](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41)
+
+<ExpandableCard title="London EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1559">EIP-1559</a> – <em>improves the transaction fee market</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3198">EIP-3198</a> – <em>returns the <code>BASEFEE</code> from a block</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3529">EIP-3529</a> - <em>reduces gas refunds for EVM operations</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3541">EIP-3541</a> - <em>prevents deploying contracts starting with <code>0xEF</code></em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3554">EIP-3554</a> – <em>delays the Ice Age until December 2021</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### Berlin {#berlin}
+
+<NetworkUpgradeSummary name="berlin" />
+
+#### Muhtasari {#berlin-summary}
+
+Uboreshaji wa Berlin uliboresha gharama za miamala kwa baadhi ya vitendo vya EVM, na kuongeza msaada kwa aina nyingi za miamala.
+
+- [Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement/)
+- [Soma ufafanuzi wa Ethereum Cat Herder](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80)
+
+<ExpandableCard title="Berlin EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye sasisho hili.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2565">EIP-2565</a> – <em>lowers ModExp gas cost</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2718">EIP-2718</a> – <em>enables easier support for multiple transaction types</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2929">EIP-2929</a> – <em>gas cost increases for state access opcodes</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2930">EIP-2930</a> – <em>adds optional access lists</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2020 {#2020}
+
+### Mwanzo wa Mnyororo Kioleza {#beacon-chain-genesis}
+
+<NetworkUpgradeSummary name="beaconChainGenesis" />
+
+#### Muhtasari {#beacon-chain-genesis-summary}
+
+[Mnyororo Kioleza](/roadmap/beacon-chain/) ulihitaji amana 16384 za ETH 32 zilizosimamishwa ili uzinduliwe kwa usalama. Hili lilitokea Novemba 27, na Mnyororo Kioleza ulianza kutoa bloku mnamo Desemba 1, 2020.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2020/11/27/eth2-quick-update-no-21/)
+
+<DocLink href="/roadmap/beacon-chain/">
+  Mnyororo Kioleza
+</DocLink>
+
+---
+
+### Mkataba wa amana wa kusimamisha watekelezwa {#staking-deposit-contract}
+
+<NetworkUpgradeSummary name="stakingDepositContractDeployed" />
+
+#### Muhtasari {#deposit-contract-summary}
+
+Mkataba wa amana wa kusimamisha ulianzisha [kusimamisha](/glossary/#staking) kwenye mfumo-ikolojia wa Ethereum. Ingawa ni mkataba wa [Mtandao Mkuu](/glossary/#mainnet), ulikuwa na athari ya moja kwa moja kwenye mfuatano wa matukio ya uzinduzi wa [Mnyororo Kioleza](/roadmap/beacon-chain/), [sasisho muhimu la Ethereum](/roadmap/).
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2020/11/04/eth2-quick-update-no-19/)
+
+<DocLink href="/staking/">Kusimamisha</DocLink>
+
+---
+
+### Muir Glacier {#muir-glacier}
+
+<NetworkUpgradeSummary name="muirGlacier" />
+
+#### Muhtasari {#muir-glacier-summary}
+
+Uma wa Muir Glacier ulianzisha ucheleweshaji wa [bomu la ugumu](/glossary/#difficulty-bomb). Kuongezeka kwa ugumu wa bloku wa utaratibu wa makubaliano wa [uthibitishaji-wa-kazi](/developers/docs/consensus-mechanisms/pow/) kulitishia kudhoofisha utumiaji wa Ethereum kwa kuongeza muda wa kusubiri wa kutuma miamala na kutumia mfumo mtawanyo wa kimamlaka.
+
+- [Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement/)
+- [Soma ufafanuzi wa Ethereum Cat Herder](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210)
+
+<ExpandableCard title="Muir Glacier EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2384">EIP-2384</a> – <em>delays the difficulty bomb for another 4,000,000 blocks, or ~611 days.</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2019 {#2019}
+
+### Istanbul {#istanbul}
+
+<NetworkUpgradeSummary name="istanbul" />
+
+#### Muhtasari {#istanbul-summary}
+
+The Istanbul fork:
+
+- Iliboresha gharama ya [gesi](/glossary/#gas) ya vitendo fulani katika [EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine).
+- Ustahimilivu ulioboreshwa wa shambulio la kunyimwa huduma.
+- Ilifanya suluhu za [uongezekaji wa Safu ya 2](/developers/docs/scaling/#layer-2-scaling) zinazotegemea SNARKs na STARKs kuwa na utendaji bora zaidi.
+- Imewezeshwa Ethereum na Zcash kuingiliana.
+- Kandarasi zinazoruhusiwa ili kuanzisha kazi zaidi za ubunifu.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement/)
+
+<ExpandableCard title="Istanbul EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-152">EIP-152</a> – <em>allow Ethereum to work with privacy-preserving currency like Zcash.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1108">EIP-1108</a> – <em>cheaper cryptography to improve [gas](/glossary/#gas) costs.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1344">EIP-1344</a> – <em>protects Ethereum against replay attacks by adding <code>CHAINID</code> [opcode](/developers/docs/ethereum-stack/#ethereum-virtual-machine).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1884">EIP-1884</a> – <em>optimising opcode gas prices based on consumption.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2028">EIP-2028</a> – <em>reduces the cost of CallData to allow more data in blocks – good for [Layer 2 scaling](/developers/docs/scaling/#layer-2-scaling).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2200">EIP-2200</a> – <em>other opcode gas price alterations.</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### Constantinople {#constantinople}
+
+<NetworkUpgradeSummary name="constantinople" />
+
+#### Muhtasari {#constantinople-summary}
+
+The Constantinople fork:
+
+- Ilipunguza zawadi za [uchimbaji](/developers/docs/consensus-mechanisms/pow/mining/) wa bloku kutoka ETH 3 hadi 2.
+- Ilihakikisha mnyororo wa bloku haukuganda kabla ya [proof-of-stake kutekelezwa](#beacon-chain-genesis).
+- Iliboresha gharama ya [gesi](/glossary/#gas) ya vitendo fulani katika [EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine).
+- Imeongeza uwezo wa kuingiliana na anwani ambazo bado hazijaundwa.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement/)
+
+<ExpandableCard title="Constantinople EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-145">EIP-145</a> – <em>optimises cost of certain onchain actions.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1014">EIP-1014</a> – <em>allows you to interact with addresses that have yet to be created.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1052">EIP-1052</a> – <em>introduces the <code>EXTCODEHASH</code> instruction to retrieve the hash of another contract's code.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1234">EIP-1234</a> – <em>makes sure the blockchain doesn&#39;t freeze before proof-of-stake and reduces block reward from 3 to 2 ETH.</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2017 {#2017}
+
+### Byzantium {#byzantium}
+
+<NetworkUpgradeSummary name="byzantium" />
+
+#### Muhtasari {#byzantium-summary}
+
+Fork ya Byzantium:
+
+- Ilipunguza zawadi za [uchimbaji](/developers/docs/consensus-mechanisms/pow/mining/) wa bloku kutoka ETH 5 hadi 3.
+- Ilichelewesha [bomu la ugumu](/glossary/#difficulty-bomb) kwa mwaka mmoja.
+- Imeongezwa uwezo wa kufanya simu zisizobadilisha hali kwa mikataba mingine.
+- Iliongeza mbinu fulani za kriptografia kuruhusu [uongezekaji wa safu ya 2](/developers/docs/scaling/#layer-2-scaling).
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement/)
+
+<ExpandableCard title="Byzantium EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-140">EIP-140</a> – <em>adds <code>REVERT</code> opcode.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-658">EIP-658</a> – <em>status field added to transaction receipts to indicate success or failure.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-196">EIP-196</a> – <em>adds elliptic curve and scalar multiplication to allow for [ZK-Snarks](/developers/docs/scaling/zk-rollups/).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-197">EIP-197</a> – <em>adds elliptic curve and scalar multiplication to allow for [ZK-Snarks](/developers/docs/scaling/zk-rollups/).</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-198">EIP-198</a> – <em>enables RSA signature verification.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-211">EIP-211</a> – <em>adds support for variable length return values.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-214">EIP-214</a> – <em>adds <code>STATICCALL</code> opcode, allowing non-state-changing calls to other contracts.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-100">EIP-100</a> – <em>changes difficulty adjustment formula.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-649">EIP-649</a> – <em>delays [difficulty bomb](/glossary/#difficulty-bomb) by 1 year and reduces block reward from 5 to 3 ETH.</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2016 {#2016}
+
+### Spurious Dragon {#spurious-dragon}
+
+<NetworkUpgradeSummary name="spuriousDragon" />
+
+#### Muhtasari {#spurious-dragon-summary}
+
+Uma wa Joka la Uongo lilikuwa jibu la pili kwa mashambulizi ya kunyimwa huduma (DoS) kwenye mtandao (Septemba/Oktoba 2016) ikiwa ni pamoja na:
+
+- kupanga bei ya msimbo ili kuzuia mashambulizi ya baadaye kwenye mtandao.
+- kuwezesha "debloat" ya hali ya kiambajengo.
+- kuongeza ulinzi wa mashambulizi ya kurudiwa.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/)
+
+<ExpandableCard title="Spurious Dragon EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-155">EIP-155</a> - <em>huzuia miamala kutoka kwa msururu mmoja wa Ethereum kutangazwa tena kwenye msururu mbadala, kwa mfano muamala wa testnet unaochezwa tena kwenye msururu mkuu wa Ethereum.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-160">EIP-160</a> - <em>hurekebisha bei za <code>EXP</code> opcode - hufanya iwe vigumu zaidi kupunguza kasi ya mtandao kupitia utendakazi wa gharama kubwa wa kimahesabu.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-161">EIP-161</a> – <em>allows for removal of empty accounts added via the DOS attacks.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-170">EIP-170</a> – <em>changes the maximum code size that a contract on the blockchain can have – to 24576 bytes.</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### Tangerine whistle {#tangerine-whistle}
+
+<NetworkUpgradeSummary name="tangerineWhistle" />
+
+#### Muhtasari {#tangerine-whistle-summary}
+
+The Tangerine Whistle fork lilikuwa jibu la kwanza kwa mashambulizi ya kunyimwa huduma (DoS) kwenye mtandao (Septemba/Oktoba 2016) ikijumuisha:
+
+- kushughulikia masuala ya dharura ya afya ya mtandao kuhusu misimbo ya uendeshaji ya bei ya chini.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork/)
+
+<ExpandableCard title="Tangerine Whistle EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-150">EIP-150</a> – <em>increases gas costs of opcodes that can be used in spam attacks.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-158">EIP-158</a> - <em>hupunguza ukubwa wa jimbo kwa kuondoa idadi kubwa ya akaunti tupu ambazo ziliwekwa katika jimbo hilo kwa gharama ya chini sana kutokana na dosari katika matoleo ya awali ya itifaki ya Ethereum.</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### Uma wa DAO {#dao-fork}
+
+<NetworkUpgradeSummary name="daoFork" />
+
+#### Muhtasari {#dao-fork-summary}
+
+Uma wa DAO ulikuwa jibu kwa [shambulio la DAO la 2016](https://www.coindesk.com/learn/understanding-the-dao-attack/) ambapo mkataba usio salama wa [DAO](/glossary/#dao) uliporwa zaidi ya ETH milioni 3.6 katika udukuzi. Uma ulihamisha fedha kutoka kwa mkataba wenye hitilafu hadi [mkataba mpya](https://eth.blockscout.com/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754) wenye kazi moja tu: kutoa. Mtu yeyote aliyepoteza pesa anaweza kutoa ETH 1 kwa kila tokeni 100 za DAO kwenye pochi zao.
+
+Njia hii ya utekelezaji iliamuliwa kwa kura na jamii ya Ethereum. Mmiliki yeyote wa ETH aliweza kupiga kura kupitia muamala kwenye [jukwaa la kupigia kura](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). Uamuzi wa kugawanya ilifika zaidi ya asilimia 85 ya kura.
+
+Baadhi ya wachimbaji walikataa kutumia uma kwa sababu tukio la DAO halikuwa na kasoro katika itifaki. Waliendelea na kuunda [Ethereum Classic](https://ethereumclassic.org/).
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2016/07/20/hard-fork-completed/)
+
+---
+
+### Homestead {#homestead}
+
+<NetworkUpgradeSummary name="homestead" />
+
+#### Muhtasari {#homestead-summary}
+
+Uma wa Nyumbani ambao uliangalia siku zijazo. Ilijumuisha mabadiliko kadhaa ya itifaki na mabadiliko ya mtandao ambayo yalimpa Ethereum uwezo wa kufanya uboreshaji zaidi wa mtandao.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2016/02/29/homestead-release/)
+
+<ExpandableCard title="Homestead EIPs" contentPreview="Maboresho rasmi yaliyojumuishwa kwenye uma huu.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2">EIP-2</a> – <em>makes edits to contract creation process.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7">EIP-7</a> – <em>adds new opcode: <code>DELEGATECALL</code></em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-8">EIP-8</a> – <em>introduces devp2p forward compatibility requirements</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2015 {#2015}
+
+### Uyeyukaji wa Frontier {#frontier-thawing}
+
+<NetworkUpgradeSummary name="frontierThawing" />
+
+#### Muhtasari {#frontier-thawing-summary}
+
+Uma wa uyeyukaji wa Frontier uliondoa [kikomo cha gesi](/glossary/#gas) 5,000 kwa kila [bloku](/glossary/#block) na kuweka bei chaguo-msingi ya gesi kuwa [gwei](/glossary/#gwei) 51. Hii inaruhusiwa kwa shughuli - shughuli zinahitaji gharama ya muamala ya 21,000. [Bomu la ugumu](/glossary/#difficulty-bomb) lilianzishwa ili kuhakikisha uma mgumu wa baadaye kwenda [proof-of-stake](/glossary/#pos).
+
+- [Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2015/08/04/the-thawing-frontier/)
+- [Soma Sasisho la 1 la Itifaki ya Ethereum](https://blog.ethereum.org/2015/08/04/ethereum-protocol-update-1/)
+
+---
+
+### Frontier {#frontier}
+
+<NetworkUpgradeSummary name="frontier" />
+
+#### Muhtasari {#frontier-summary}
+
+Frontier ilikuwa hai, lakini utekelezaji wa mradi wa Ethereum. Ilifuata awamu ya majaribio ya Olimpiki yenye mafanikio. Ilikusudiwa kwa watumiaji wa kiufundi, haswa watengenezaji. [Bloku](/glossary/#block) zilikuwa na [kikomo cha gesi](/glossary/#gas) cha 5,000. Kipindi hiki cha ‘kuyeyusha’ kiliwawezesha wachimbaji kuanza shughuli zao na kwa watumiaji wa awali kufunga wateja wao bila ‘kuharakisha’.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2015/07/22/frontier-is-coming-what-to-expect-and-how-to-prepare/)
+
+<Divider />
+
+## 2014 {#2014}
+
+### Uuzaji wa Ether {#ether-sale}
+
+<NetworkUpgradeSummary name="etherSale" />
+
+Ether officially went on sale for 42 days. Unaweza kuinunua na BTC.
+
+[Soma tangazo la Msingi wa Ethereum](https://blog.ethereum.org/2014/07/22/launching-the-ether-sale/)
+
+---
+
+### Yellowpaper imetolewa {#yellowpaper}
+
+<NetworkUpgradeSummary name="yellowpaperRelease" />
+
+Karatasi ya Njano, iliyoandikwa na Dk. Gavin Wood, ni ufafanuzi wa kiufundi wa itifaki ya Ethereum.
+
+[Angalia Yellow Paper](https://github.com/ethereum/yellowpaper)
+
+<Divider />
+
+## 2013 {#2013}
+
+### Karatasi nyeeupe imetolewa {#whitepaper}
+
+<NetworkUpgradeSummary name="whitepaperRelease" />
+
+Karatasi ya utangulizi, iliyochapishwa mnamo 2013 na Vitalik Buterin, mwanzilishi wa Ethereum, kabla ya uzinduzi wa mradi mnamo 2015.
+
+<DocLink href="/whitepaper/">Karatasi nyeeupe</DocLink>
diff --git a/public/content/translations/sw/foundation/index.md b/public/content/translations/sw/foundation/index.md
new file mode 100644
index 00000000000..4a0983dcbf5
--- /dev/null
+++ b/public/content/translations/sw/foundation/index.md
@@ -0,0 +1,33 @@
+---
+title: Msingi wa Ethereum
+description: Jifunze kuhusu msingi wa Ethereum (EF), shirika lisilo la faida linalojitolea kusaidia Ethereum na teknolojia zinazohusiana.
+hideEditButton: true
+lang: sw
+---
+
+# Msingi wa Ethereum {#ethereum-foundation}
+
+<Logo/>
+
+[Msingi wa Ethereum](http://ethereum.foundation/) (EF) ni shirika lisilo la faida linalosaidia mfumo ikolojia wa Ethereum. Hufadhili uendelezaji wa itifaki, hukuza mfumo ikolojia, na kutetea Ethereum.
+
+EF si kampuni, wala hata shirika lisilo la faida la kawaida. Haidhibiti au kuongoza Ethereum, wala sio shirika pekee linalofadhili maendeleo muhimu ya teknolojia zinazohusiana na Ethereum. EF ni sehemu moja ya [mfumo ikolojia](/community/) mkubwa zaidi.
+
+## Mambo yanayofanywa na EF {#what-the-ef-does}
+
+- **Uendelezaji wa Itifaki** – Kusaidia timu zinazofanyia kazi itifaki kuu ya Ethereum, ikiwa ni pamoja na uendelezaji wa mteja, utafiti, maboresho, na [mpango wa zawadi za hitilafu](/bug-bounty/)
+- **Ufadhili wa Mfumo Ikolojia** – Kutoa ruzuku na usaidizi kwa miradi inayojengwa kwenye Ethereum kupitia [Mpango wa Usaidizi wa Mfumo Ikolojia](https://esp.ethereum.foundation/)
+- **Utafiti** – Kufadhili utafiti katika kriptografia, makubaliano, upanuzi, faragha na usalama
+
+## Programu na mipango {#programs-and-initiatives}
+
+- **[Mpango wa Usaidizi wa Mfumo Ikolojia](https://esp.ethereum.foundation/)** – Ruzuku na usaidizi kwa miradi ya chanzo-wazi inayojengwa kwenye Ethereum
+- **[Ruzuku za Kitaaluma](https://esp.ethereum.foundation/academic-grants)** – Kusaidia utafiti wa kitaaluma unaohusiana na Ethereum
+- **[Devcon](https://devcon.org/)** – Mkutano wa mwaka kwa wasanidi programu wa Ethereum, watafiti na wajenzi
+- **[Mpango wa Zawadi za Hitilafu](/bug-bounty/)** – Zawadi za kupata udhaifu katika itifaki ya Ethereum
+
+## Jifunze zaidi {#learn-more}
+
+- [ethereum.foundation](https://ethereum.foundation/) – Tovuti rasmi ya EF
+- [Blogu ya EF](https://blog.ethereum.org/) – Habari na matangazo
+- [Mpango wa Usaidizi wa Mfumo Ikolojia](https://esp.ethereum.foundation/) – Ruzuku na usaidizi
diff --git a/public/content/translations/sw/gaming/index.md b/public/content/translations/sw/gaming/index.md
new file mode 100644
index 00000000000..debc5636360
--- /dev/null
+++ b/public/content/translations/sw/gaming/index.md
@@ -0,0 +1,70 @@
+---
+title: Michezo ya Kwenye Mnyororo
+lang: sw
+template: use-cases
+image: /images/robot-help-bar.png
+sidebarDepth: 2
+summaryPoint1: Sheria za mchezo na hali zinaweza kutekelezwa na mnyororo wa bloku, sio seva za studio
+summaryPoint2: Mtu yeyote anaweza kuunda mods, boti, au michezo mipya kabisa inayounganishwa kwenye data ileile ya kwenye mnyororo
+summaryPoint3: L2s zilizoundwa kwa makusudi, kama Redstone, na mifumo, kama MUD, hupunguza gharama vya kutosha kuunga mkono uchezaji wa wakati halisi
+buttons:
+  - content: Pata maelezo zaidi
+    toId: how-gaming-on-ethereum-works
+  - content: Programu za kuchunguza
+    toId: popular-games-built-on-ethereum
+    isSecondary: false
+---
+
+## Jinsi michezo kwenye Ethereum inavyofanya kazi {#how-gaming-on-ethereum-works}
+
+Michezo kwenye Ethereum huja katika aina mbalimbali, kutoka michezo inayojumuisha mnyororo wa bloku kwa ajili ya vipengele maalum hadi ile ambapo ulimwengu wote wa mchezo unaishi kwenye mnyororo. Michezo mingi hutumia Ethereum kudhibiti mali za ndani ya mchezo kama NFTs (Tokeni Zisizoweza Kubadilishwa). Hii inaruhusu wachezaji kumiliki kweli vitu vya kipekee vya kidijitali, ambavyo vinaweza kuuzwa waziwazi, kuuzwa, au kutolewa kama zawadi nje ya mipaka ya mfumo wa ikolojia wa msanidi programu mmoja wa mchezo. Ingawa mali hizi zinatoa aina mpya za uwakala wa wachezaji, mantiki ya msingi ya mchezo mara nyingi hubaki kwenye seva za kati.
+
+Michezo iliyo kwenye mnyororo kikamilifu ni michezo ambapo mbinu za msingi, na mara nyingi ulimwengu mzima wa mchezo, hutawaliwa moja kwa moja na mikataba-erevu kwenye mnyororo wa bloku wa Ethereum (au Tabaka zake za 2). Hii inahakikisha uwazi usio na kifani. Hakuna seva za kati, hakuna wapatanishi—ni uzoefu na uchumi wa uwazi unaoendeshwa na wachezaji pekee.
+
+- Wachezaji wanamiliki mali zao kama NFTs.
+- Vitu vinaweza kuuzwa, kutolewa kama zawadi, au kuuzwa kwa uhuru.
+- Mnyororo wa bloku huhakikisha mali zinabaki kupatikana milele.
+
+## Hali ya sasa ya michezo {#the-current-state-of-gaming}
+
+- **Ufungaji wa Michezo wa Mara kwa Mara:** Katika mwaka wa 2023 pekee, [michezo 60+ ilifungwa](https://tech4gamers.com/game-studios-shut-down-2023/), na studio 11 za michezo zilifungwa kabisa, na kuwaacha wachezaji bila chochote cha kuonyesha kwa uwekezaji wao wa ndani ya mchezo. Michezo ya kwenye mnyororo, pamoja na mantiki na mali zake kwenye mtandao uliogatuliwa, inaweza kudumu mradi tu mnyororo wa bloku upo, ikitoa kiwango cha juu cha udumu.
+- **Kukata tamaa juu ya mali zilizofungwa:** [51% ya wachezaji wanahisi wamekata tamaa](https://www.starknet.io/blog/blockchain-gaming/) kwamba hawawezi kutoa zawadi au kuuza tena vitu vya ndani ya mchezo wanavyonunua, na 23% wanakasirishwa na jinsi ilivyo vigumu kurejesha pesa kutoka kwa ununuzi wa ndani ya mchezo. Wachezaji huwekeza muda na pesa nyingi katika kupata vitu vya ndani ya mchezo, na kugundua tu kuwa hawavimiliki kweli. Kiwango cha NFT cha Ethereum kinatoa umiliki wa kidijitali unaoweza kuthibitishwa, na kuhakikisha wachezaji wanadhibiti mali zao.
+- **Matumizi ya Juu Bila Marejesho:** [Wachezaji hutumia wastani wa \$6,425](https://www.starknet.io/blog/blockchain-gaming/) kwenye vitu pepe maishani mwao, huku \$8.74 zikitumika kwa mwezi au \$104 kwa mwaka. Umiliki wa kwenye mnyororo hubadilisha matumizi hayo kutoka gharama isiyoweza kurejeshwa na kuwa uwekezaji katika mali ya kidijitali ambayo inaweza kuuzwa, kubadilishwa, au kutolewa kama zawadi, kama vile mkusanyiko wa kimwili.
+
+## Michezo maarufu iliyoundwa kwenye Ethereum {#popular-games-built-on-ethereum}
+
+Wasanidi programu wanachunguza njia mpya za kufanya michezo ishirikishe zaidi na kwenda zaidi ya mbinu rahisi za zawadi ili kuimarisha uchezaji unaotegemea ujuzi.
+
+<OnchainGamingProductList list="game" />
+
+## Cheza-ili-upate (P2E) {#play-to-earn-p2e}
+
+Kwa michezo ya Cheza-ili-upate (P2E), unaweza kupata mali za ndani ya mchezo zenye thamani ya ulimwengu halisi. Tofauti na mifumo ya awali ya P2E iliyotegemea zawadi zisizo endelevu, michezo mipya inazingatia thamani ya muda mrefu. Kwa mfano, [Wolf Game](https://gam3s.gg/wolf-game/) inachanganya uchezaji wa kimkakati na umiliki halisi wa mali za kidijitali. Wachezaji hudhibiti kondoo na mbwa mwitu pepe, wakipata sarafu ya ndani ya mchezo WOOL, ambayo inaweza kubadilishwa au kuuzwa.
+
+<OnchainGamingProductList list="p2e" />
+
+## Ushirikiano & uchezaji wa minyororo-tofauti {#interoperability-and-cross-chain-play}
+
+Moja ya sifa zenye nguvu zaidi za Ethereum kwa ajili ya michezo ni usaidizi wake wa asili wa ushirikiano na utungaji. Michezo ya jadi hufanya kazi katika "bustani zenye kuta," ikifungia mali za ndani ya mchezo na maendeleo kwa jina moja. Mali za ndani ya mchezo, na hata mantiki ya msingi ya mchezo, iliyojengwa kwenye Ethereum inaweza kuingiliana katika programu na minyororo tofauti—bila kuathiri usalama. Ingawa huu bado ni mfumo wa ikolojia unaoendelea, baadhi ya mitandao ya michezo inayotegemea Ethereum tayari inaweza kushirikiana na inaruhusu vitu vya ndani ya mchezo (NFTs) vitumike katika michezo mingi.
+
+Kwa mfano, katika Illuvium, [wachezaji wanaweza kukusanya viumbe wanaoitwa Illuvials](https://gam3s.gg/news/illuvium-three-web3-games/), ambao ni NFTs. Hawa Illuvials wanaweza kutumika katika michezo mbalimbali ndani ya ulimwengu wa Illuvium. Illuvial aliyekamatwa katika Illuvium Overworld anaweza pia kutumika katika Illuvium Arena kwa ajili ya mapigano.
+
+Mfano mwingine ni Galaxy Fight Club. Katika mchezo huu, [wachezaji wanaweza kutumia makusanyo tofauti ya NFT](https://gam3s.gg/galaxy-fight-club/) kushiriki katika mapigano, kumaanisha NFTs kutoka miradi mbalimbali zinaweza kutumika ndani ya mchezo.
+
+## Uboreshaji wa uwezo wa kuongezeka & ada ya gesi {#scalability-and-gas-fee-improvements}
+
+Ukosoaji wa zamani wa michezo ya kwenye mnyororo ulikuwa kwamba minyororo ya bloku ni tata sana na ya polepole kuwapa wachezaji uzoefu wanaotarajia. Lakini kadiri Ethereum imekomaa, suluhu za kupunguza kwa kiasi kikubwa gharama na kuimarisha utendaji wa michezo ya kwenye mnyororo zimejitokeza, na kufanya uzoefu wa mwingiliano na wa kasi uwezekane.
+
+Maendeleo haya yanapatikana hasa kupitia:
+
+- **Miamala isiyo na Gesi:** Baadhi ya majukwaa na itifaki, ikiwa ni pamoja na zile zinazotumia Immutable X, hutoa uwezo wa kufanya miamala kama vile biashara au kutoa NFTs bila ada kwa mtumiaji, na kurahisisha zaidi uzoefu wa mchezaji.
+- **Suluhu za Kuongeza Ukubwa:** Ethereum L2s kama Arbitrum, zkSync na Starknet zinakuza kikamilifu mifumo ya ikolojia kwa ajili ya michezo ya kwenye mnyororo kutokana na upitishaji wake wa juu na gharama nafuu.
+- **[Mfumo wa ikolojia wa MUD](https://mud.dev/):** MUD huboresha zana za maendeleo ya programu zinazotegemea Ethereum kwa ajili ya maendeleo ya michezo ya kwenye mnyororo, ikitoa usimamizi bora zaidi wa hali kwa mantiki tata ya mchezo.
+
+## Anza na michezo ya Ethereum {#get-started-with-ethereum-gaming}
+
+Kuingia katika michezo ya Ethereum ni rahisi kuliko unavyoweza kufikiria. Kwa hatua chache tu, unaweza kuanza kucheza na kufurahia maendeleo yako:
+
+1. **Weka Mkoba wa Sarafu ya Kidijitali:** Utahitaji mkoba kudhibiti mali zako za kidijitali na kuingiliana na mifumo iliyotawanywa. [Chagua Mkoba](/wallets/find-wallet/)
+2. **Weka Pesa Kwenye Mkoba Wako:** Pata Ether (ETH) au tokeni zinazohusiana na mtandao wa Tabaka la 2 unaopanga kutumia.
+3. **Gundua Michezo:** Gundua michezo kwenye majukwaa kama vile [Orden](https://orden.gg/), [ChainPlay](https://chainplay.gg/chain/ethereum/), [Gam3s.GG](https://gam3s.gg/), [DappRadar](https://dappradar.com/rankings/protocol/ethereum/category/games), [OpenSea](https://opensea.io/), na [PlayToEarn.net](https://playtoearn.com/blockchaingames).
diff --git a/public/content/translations/sw/glossary/index.md b/public/content/translations/sw/glossary/index.md
new file mode 100644
index 00000000000..af0af8daca0
--- /dev/null
+++ b/public/content/translations/sw/glossary/index.md
@@ -0,0 +1,505 @@
+---
+title: Kamusi ya Ethereum
+description: Kamusi hii ya maneno ya kiufundi na yasio ya kiufundi yanayohusiana na Ethereum haijakamilika
+lang: sw
+---
+
+# Faharasa {#ethereum-glossary}
+
+## \# {#section-numbers}
+
+<GlossaryDefinition term="51%-attack" />
+
+<Divider />
+
+## A {#section-a}
+
+<GlossaryDefinition term="account" />
+
+<GlossaryDefinition term="address" />
+
+<GlossaryDefinition term="abi" />
+
+<GlossaryDefinition term="anti-sybil" />
+
+<GlossaryDefinition term="api" />
+
+<GlossaryDefinition term="apr" />
+
+<GlossaryDefinition term="asic" />
+
+<GlossaryDefinition term="assert" />
+
+<GlossaryDefinition term="attestation" />
+
+<Divider />
+
+## B {#section-b}
+
+<GlossaryDefinition term="base-fee" />
+
+<GlossaryDefinition term="beacon-chain" />
+
+<GlossaryDefinition term="big-endian" />
+
+<GlossaryDefinition term="block" />
+
+<GlossaryDefinition term="block-explorer" />
+
+<GlossaryDefinition term="block-header" />
+
+<GlossaryDefinition term="block-propagation" />
+
+<GlossaryDefinition term="block-proposer" />
+
+<GlossaryDefinition term="block-reward" />
+
+<GlossaryDefinition term="block-status" />
+
+<GlossaryDefinition term="block-time" />
+
+<GlossaryDefinition term="block-validation" />
+
+<GlossaryDefinition term="blockchain" />
+
+<GlossaryDefinition term="bootnode" />
+
+<GlossaryDefinition term="bridge" />
+
+<GlossaryDefinition term="bytecode" />
+
+<GlossaryDefinition term="byzantium-fork" />
+
+<Divider />
+
+## C {#section-c}
+
+<GlossaryDefinition term="casper-ffg" />
+
+<GlossaryDefinition term="checkpoint" />
+
+<GlossaryDefinition term="compiling" />
+
+<GlossaryDefinition term="committee" />
+
+<GlossaryDefinition term="computational-infeasibility" />
+
+<GlossaryDefinition term="consensus" />
+
+<GlossaryDefinition term="consensus-client" />
+
+<GlossaryDefinition term="consensus-layer" />
+
+<GlossaryDefinition term="consensus-rules" />
+
+<GlossaryDefinition term="constantinople-fork" />
+
+<GlossaryDefinition term="contract-account" />
+
+<GlossaryDefinition term="contract-creation-transaction" />
+
+<GlossaryDefinition term="cryptography" />
+
+<GlossaryDefinition term="cryptoeconomics" />
+
+<Divider />
+
+## D {#section-d}
+
+<GlossaryDefinition term="doge-d" />
+
+<GlossaryDefinition term="dag" />
+
+<GlossaryDefinition term="dapp" />
+
+<GlossaryDefinition term="data-availability" />
+
+<GlossaryDefinition term="decentralization" />
+
+<GlossaryDefinition term="dao" />
+
+<GlossaryDefinition term="desci" />
+
+<GlossaryDefinition term="dex" />
+
+<GlossaryDefinition term="deposit-contract" />
+
+<GlossaryDefinition term="defi" />
+
+<GlossaryDefinition term="difficulty" />
+
+<GlossaryDefinition term="difficulty-bomb" />
+
+<GlossaryDefinition term="digital-signatures" />
+
+<GlossaryDefinition term="discovery" />
+
+<GlossaryDefinition term="distributed-hash-table" />
+
+<GlossaryDefinition term="double-spend" />
+
+<Divider />
+
+## E {#section-e}
+
+<GlossaryDefinition term="ecdsa" />
+
+<GlossaryDefinition term="encryption" />
+
+<GlossaryDefinition term="entropy" />
+
+<GlossaryDefinition term="epoch" />
+
+<GlossaryDefinition term="equivocation" />
+
+<GlossaryDefinition term="eth1" />
+
+<GlossaryDefinition term="eth2" />
+
+<GlossaryDefinition term="eip" />
+
+<GlossaryDefinition term="ens" />
+
+<GlossaryDefinition term="execution-client" />
+
+<GlossaryDefinition term="execution-layer" />
+
+<GlossaryDefinition term="eoa" />
+
+<GlossaryDefinition term="erc" />
+
+<GlossaryDefinition term="erc-20" />
+
+<GlossaryDefinition term="erc-721" />
+
+<GlossaryDefinition term="erc-1155" />
+
+<GlossaryDefinition term="ethash" />
+
+<GlossaryDefinition term="ether" />
+
+<GlossaryDefinition term="events" />
+
+<GlossaryDefinition term="evm" />
+
+<GlossaryDefinition term="evm-assembly-language" />
+
+<Divider />
+
+## F {#section-f}
+
+<GlossaryDefinition term="fallback-function" />
+
+<GlossaryDefinition term="faucet" />
+
+<GlossaryDefinition term="finality" />
+
+<GlossaryDefinition term="finney" />
+
+<GlossaryDefinition term="fork" />
+
+<GlossaryDefinition term="fork-choice-algorithm" />
+
+<GlossaryDefinition term="fraud-proof" />
+
+<GlossaryDefinition term="frontier" />
+
+<Divider />
+
+## G {#section-g}
+
+<GlossaryDefinition term="gas" />
+
+<GlossaryDefinition term="gas-limit" />
+
+<GlossaryDefinition term="gas-price" />
+
+<GlossaryDefinition term="genesis-block" />
+
+<GlossaryDefinition term="geth" />
+
+<GlossaryDefinition term="gwei" />
+
+<Divider />
+
+## H {#section-h}
+
+<GlossaryDefinition term="hard-fork" />
+
+<GlossaryDefinition term="hash" />
+
+<GlossaryDefinition term="hash-rate" />
+
+<GlossaryDefinition term="holographic-consensus" />
+
+<GlossaryDefinition term="homestead" />
+
+<Divider />
+
+## I {#section-i}
+
+<GlossaryDefinition term="index" />
+
+<GlossaryDefinition term="ide" />
+
+<GlossaryDefinition term="immutable-deployed-code-problem" />
+
+<GlossaryDefinition term="internal-transaction" />
+
+<GlossaryDefinition term="issuance" />
+
+<Divider />
+
+## K {#section-k}
+
+<GlossaryDefinition term="kdf" />
+
+<GlossaryDefinition term="key" />
+
+<GlossaryDefinition term="keystore" />
+
+<GlossaryDefinition term="keccak-256" />
+
+<Divider />
+
+## L {#section-l}
+
+<GlossaryDefinition term="layer-1" />
+
+<GlossaryDefinition term="layer-2" />
+
+<GlossaryDefinition term="library" />
+
+<GlossaryDefinition term="light-client" />
+
+<GlossaryDefinition term="liquidity" />
+
+<GlossaryDefinition term="liquidity-tokens" />
+
+<GlossaryDefinition term="lmd-ghost" />
+
+<Divider />
+
+## M {#section-m}
+
+<GlossaryDefinition term="mainnet" />
+
+<GlossaryDefinition term="max-fee-per-gas" />
+
+<GlossaryDefinition term="merkle-patricia-tree" />
+
+<GlossaryDefinition term="merkle-root" />
+
+<GlossaryDefinition term="message" />
+
+<GlossaryDefinition term="message-call" />
+
+<GlossaryDefinition term="mev" />
+
+<GlossaryDefinition term="mining" />
+
+<GlossaryDefinition term="miner" />
+
+<GlossaryDefinition term="mint" />
+
+<GlossaryDefinition term="multisig" />
+
+<Divider />
+
+## N {#section-n}
+
+<GlossaryDefinition term="network" />
+
+<GlossaryDefinition term="network-hashrate" />
+
+<GlossaryDefinition term="nft" />
+
+<GlossaryDefinition term="node" />
+
+<GlossaryDefinition term="nonce" />
+
+<Divider />
+
+## O {#section-o}
+
+<GlossaryDefinition term="offchain" />
+
+<GlossaryDefinition term="ommer" />
+
+<GlossaryDefinition term="onchain" />
+
+<GlossaryDefinition term="optimistic-rollup" />
+
+<GlossaryDefinition term="oracle" />
+
+<Divider />
+
+## P {#section-p}
+
+<GlossaryDefinition term="peer" />
+
+<GlossaryDefinition term="peer-to-peer-network" />
+
+<GlossaryDefinition term="permissionless" />
+
+<GlossaryDefinition term="plasma" />
+
+<GlossaryDefinition term="private-key" />
+
+<GlossaryDefinition term="private-chain" />
+
+<GlossaryDefinition term="poap" />
+
+<GlossaryDefinition term="pos" />
+
+<GlossaryDefinition term="pow" />
+
+<GlossaryDefinition term="proto-danksharding" />
+
+<GlossaryDefinition term="public-goods" />
+
+<GlossaryDefinition term="public-key" />
+
+<Divider />
+
+## R {#section-r}
+
+<GlossaryDefinition term="receipt" />
+
+<GlossaryDefinition term="re-entrancy-attack" />
+
+<GlossaryDefinition term="reward" />
+
+<GlossaryDefinition term="rlp" />
+
+<GlossaryDefinition term="rollups" />
+
+<GlossaryDefinition term="rpc" />
+
+<Divider />
+
+## S {#section-s}
+
+<GlossaryDefinition term="sha" />
+
+<GlossaryDefinition term="recovery-phrase" />
+
+<GlossaryDefinition term="sequencer" />
+
+<GlossaryDefinition term="serialization" />
+
+<GlossaryDefinition term="shard" />
+
+<GlossaryDefinition term="sidechain" />
+
+<GlossaryDefinition term="signing" />
+
+<GlossaryDefinition term="singleton" />
+
+<GlossaryDefinition term="slasher" />
+
+<GlossaryDefinition term="slot" />
+
+<GlossaryDefinition term="smart-contract" />
+
+<GlossaryDefinition term="snark" />
+
+<GlossaryDefinition term="soft-fork" />
+
+<GlossaryDefinition term="solidity" />
+
+<GlossaryDefinition term="solidity-inline-assembly" />
+
+<GlossaryDefinition term="stablecoin" />
+
+<GlossaryDefinition term="staking" />
+
+<GlossaryDefinition term="staking-pool" />
+
+<GlossaryDefinition term="stark" />
+
+<GlossaryDefinition term="state" />
+
+<GlossaryDefinition term="state-channels" />
+
+<GlossaryDefinition term="supermajority" />
+
+<GlossaryDefinition term="sybil-attack" />
+
+<GlossaryDefinition term="syncing" />
+
+<GlossaryDefinition term="sync-committee" />
+
+<GlossaryDefinition term="szabo" />
+
+<Divider />
+
+## T {#section-t}
+
+<GlossaryDefinition term="terminal-total-difficulty" />
+
+<GlossaryDefinition term="testnet" />
+
+<GlossaryDefinition term="token" />
+
+<GlossaryDefinition term="token-factory" />
+
+<GlossaryDefinition term="transaction" />
+
+<GlossaryDefinition term="transaction-fee" />
+
+<GlossaryDefinition term="trust-assumptions" />
+
+<GlossaryDefinition term="trustlessness" />
+
+<GlossaryDefinition term="turing-complete" />
+
+<Divider />
+
+## V {#section-v}
+
+<GlossaryDefinition term="validator" />
+
+<GlossaryDefinition term="validator-lifecycle" />
+
+<GlossaryDefinition term="validity-proof" />
+
+<GlossaryDefinition term="validium" />
+
+<GlossaryDefinition term="vyper" />
+
+<Divider />
+
+## W {#section-w}
+
+<GlossaryDefinition term="wallet" />
+
+<GlossaryDefinition term="web3" />
+
+<GlossaryDefinition term="wei" />
+
+<GlossaryDefinition term="wrapped-token" />
+
+<Divider />
+
+## Z {#section-z}
+
+<GlossaryDefinition term="zero-address" />
+
+<GlossaryDefinition term="zk-proof" />
+
+<GlossaryDefinition term="zk-rollup" />
+
+<Divider />
+
+## Vyanzo {#sources}
+
+_Imetolewa kwa sehemu na [Mastering Ethereum](https://github.com/ethereumbook/ethereumbook) na [Andreas M. Antonopoulos, Gavin Wood](https://aantonop.com/books/mastering-ethereum) chini ya CC-BY-SA_
+
+<Divider />
+
+## Changia kwenye ukurasa huu {#contribute-to-this-page}
+
+Je, kuna kitu tumekosa? Je, kuna kitu si sahihi? Tusaidie kuboresha kwa kuchangia kwenye faharasa hii kwenye GitHub!
+
+[Jifunze zaidi kuhusu jinsi ya kuchangia](/contributing/adding-glossary-terms)
diff --git a/public/content/translations/sw/governance/index.md b/public/content/translations/sw/governance/index.md
new file mode 100644
index 00000000000..4c6ae5c7c2b
--- /dev/null
+++ b/public/content/translations/sw/governance/index.md
@@ -0,0 +1,184 @@
+---
+title: Utawala wa Ethereum
+description: Utambulisho kuhusu jinsi maamuzi ya Ethereum hufanywa.
+lang: sw
+---
+
+# Utangulizi wa utawala wa Ethereum {#introduction}
+
+_Kama hakuna mmoja anayemiliki Ethereum, maamuzi yana tengenezwaje kuhusu mabadiliko ya zamani na mbeleni ya Ethereum? Utawala wa Ethereum unahusu mchakato unaoruhusu maamuzi kama hayo kufanywa._
+
+<Divider />
+
+## Ni nini maana ya uongozi.? {#what-is-governance}
+
+Uongozi ni mfumo uliopo inaruhusu maamuzi kufanywa. Katika muundo wa kawaida ya shirika, timu ya utendaji au bodi ya wakurugenzi inaweza kuwa na uamuzi wa mwisho katika kufanya maamuzi. Au labda wamiliki wa hisa wanapiga kura juu ya mapendekezo ili kutekeleza mabadiliko. Katika mfumo wa kisiasa, maafisa waliochaguliwa wanaweza kutunga sheria zinazojaribu kuwakilisha matakwa ya wapiga kura wao.
+
+## Utawala uliogatuliwa {#decentralized-governance}
+
+Hakuna mtu mmoja anayemiliki au kudhibiti itifaki ya Ethereum, lakini bado maamuzi yanahitaji kufanywa kuhusu kutekeleza mabadiliko ili kuhakikisha uhai mrefu na ustawi wa wavu. Ukosefu huu wa umiliki unafanya uongozi wa kawaida wa kiasasi usiendane na suluhisho.
+
+## Utawala wa Ethereum {#ethereum-governance}
+
+Uongozi wa Ethereum ni utaratibu ambao kupitia kwake mabadiliko ya itifaki hufanywa. Ni muhimu kuonyesha kwamba utaratibu huu hauna uhusiano na jinsi watu na maombi rasmi zinazotumia itifaki - Ethereum haina ruhusa. Kila mtu kutoka sehemu yoyote duniani anaweza kushiriki katika shughuli zinazofanyika kwenye mnyororo wa vizuizi. Hakuna kanuni maalum za nani anaweza au hawezi kuunda maombi rasmi au kufanya muamala. Hata hivyo, kuna utaratibu wa kupendekeza mabadiliko kwenye itifaki kuu, ambayo maombi rasmi zisizo za kudhibitiwa kati inaendeshwa juu yake. Kwa kuwa watu wengi hutegemea uthabiti wa Ethereum, kuna kiwango cha juu sana cha ushirikiano inachohitajika kwa mabadiliko makuu, ikiwemo taratibu za kijamii na kiteknolojia, kuhakikisha kwamba mabadiliko yoyote ya Ethereum ni salama na yanayoungwa mkono sana na jamii.
+
+### Utawala wa Onchain dhidi ya offchain {#onchain-vs-offchain}
+
+Teknolojia ya mnyororo wa vizuizi unaruhusu uwezekano mpya wa uongozi, unaojulikana kama uongozi wa mnyororo wa vizuizi vya ndani. Uongozi wa mnyororo wa vizuizi vya ndani ni pale ambapo mabadiliko yaliyopendekezwa ya itifaki yameamuliwa kupitia kura ya washiriki wenye maslahi, kawaida kwa wamiliki wa tokeni ya uongozi, na upigaji kura unafanyika kwenye mnyororo wa vizuizi. Katika baadhi ya mifumo ya uongozi wa mnyororo wa vizuizi vya ndani, mabadiliko iliyopendekezwa tayari yameandikwa kwenye msimbo na hufanyiwa utekelezaji moja kwa moja ikiwa washiriki wenye maslahi watakubali mabadiliko hayo kwa kuweka sahihi muamala.
+
+Njia kinyume chake, uongozi wa mnyororo wa vizuizi vya nje, ni pale ambapo maamuzi yoyote kuhusu mabadiliko ya itifaki hufanywa kupitia utaratibu usio rasmi wa majadiliano ya kijamii, ambayo, ikiwa itakubaliwa, inatekelezwa katika msimbo ili kutekelezwa.
+
+**Utawala wa Ethereum hufanyika offchain** kukiwa na washikadau mbalimbali wanaohusika katika mchakato huo.
+
+_Ingawa katika kiwango cha itifaki utawala wa Ethereum ni offchain, kesi nyingi za utumiaji zilizojengwa juu ya Ethereum, kama vile DAOs, hutumia utawala wa onchain._
+
+<ButtonLink href="/dao/">
+  Zaidi kuhusu DAOs
+</ButtonLink>
+
+<Divider />
+
+## Ni nani washiriki.? {#who-is-involved}
+
+Kuna washikadau mbalimbali katika [jamii ya Ethereum](/community/), kila mmoja akichukua jukumu katika mchakato wa utawala. Kuanza na washiriki wenye maslahi wali mbali zaidi na itifaki na kisha kuzingatia kwa karibu, tunayo.:
+
+- **Wamiliki wa Ether**: watu hawa wanamiliki kiasi chochote cha ETH. [Zaidi kuhusu ETH](/what-is-ether/).
+- **Watumiaji wa Programu**: watu hawa huingiliana na programu kwenye blockchain ya Ethereum.
+- **Wasanidi wa Programu/Zana**: watu hawa huandika programu zinazoendeshwa kwenye blockchain ya Ethereum (k.m., DeFi, NFTs, n.k.) au huunda zana za kuingiliana na Ethereum (k.m., mikoba, seti za majaribio, n.k.). [Zaidi kuhusu mfumo mtawanyo wa kimamlaka](/apps/).
+- **Waendeshaji wa Nodi**: watu hawa huendesha nodi zinazoeneza vizuizi na miamala, na kukataa muamala au kizuizi chochote batili wanachokipata. [Zaidi kuhusu nodi](/developers/docs/nodes-and-clients/).
+- **Waandishi wa EIP**: watu hawa hupendekeza mabadiliko kwenye itifaki ya Ethereum, kwa njia ya Mapendekezo ya Uboreshaji wa Ethereum (EIPs). [Zaidi kuhusu EIPs](/eips/).
+- **Wathibitishaji**: watu hawa huendesha nodi zinazoweza kuongeza vizuizi vipya kwenye blockchain ya Ethereum.
+- **Wasanidi wa Itifaki** (a.k.a. "Wasanidi wa Msingi" ): watu hawa hudumisha utekelezaji mbalimbali wa Ethereum (k.m., go-ethereum, Nethermind, Besu, Erigon, Reth kwenye safu ya utekelezaji au Prysm, Lighthouse, Nimbus, Teku, Lodestar, Grandine kwenye safu ya makubaliano). [Zaidi kuhusu wateja wa Ethereum](/developers/docs/nodes-and-clients/).
+
+_Kumbuka: mtu yeyote anaweza kuwa sehemu ya makundi haya mengi (k.m., msanidi wa itifaki anaweza kutetea EIP, na kuendesha kithibitishaji cha Mnyororo Kioleza, na kutumia programu za DeFi). Hata hivyo, kwa uwazi wa dhana, ni rahisi zaidi kuwatofautisha._
+
+<Divider />
+
+## Nini maana ya pendekezo la uboreshaji wa Ethereum (EIP)? {#what-is-an-eip}
+
+Mchakato mmoja muhimu unaotumika katika utawala wa Ethereum ni pendekezo la **Mapendekezo ya Uboreshaji wa Ethereum (EIPs)**. Pendekezo la uendelezaji wa Ethereum ni viwango vinavyobainisha vipengele vipya vinavyoweza kuongezwa au utaratibu mpya kwa Ethereum. Mtu yeyote ndani ya jumuiya ya Ethereum anaweza kuunda pendekezo la uendelezaji wa Ethereum. Iwapo una nia ya kuandika pendekezo la uendelezaji wa Ethereum au kushiriki katika mapito ya wenzao na\au utawala, tazama:
+
+<ButtonLink href="/eips/">
+  Zaidi kuhusu EIPs
+</ButtonLink>
+
+<Divider />
+
+## Mchakato rasmi {#formal-process}
+
+Utaratibu rasmi kwa kuianza mabadiliko kwenye itifaki ya Ethereum ni kama inavyoelezwa:
+
+1. **Pendekeza EIP ya Msingi**: kama ilivyoelezwa katika [EIP-1](https://eips.ethereum.org/EIPS/eip-1#core-eips), hatua ya kwanza ya kupendekeza rasmi mabadiliko kwa Ethereum ni kuielezea kwa undani katika EIP ya Msingi. Hii itafanya kazi kama vipimo rasmi kwa pendekezo la utekelezaji wa Ethereum ambayo waundaji wa programu wa itifaki watatekeleza endapo itakubaliwa.
+
+2. **Wasilisha EIP yako kwa Wasanidi wa Itifaki**: pindi unapokuwa na EIP ya Msingi ambayo umekusanya maoni ya jamii, unapaswa kuiwasilisha kwa Wasanidi wa Itifaki. Unaweza kufanya hivyo kwa kuipendekeza kwa ajili ya majadiliano kwenye [simu ya AllCoreDevs](https://github.com/ethereum/execution-specs/tree/master/network-upgrades#getting-the-considered-for-inclusion-cfi-status). Kuna uwezekano kwamba baadhi ya majadiliano yatakuwa yamefanyika kwa njia isiyo ya moja kwa moja kwenye [jukwaa la Ethereum Magicians](https://ethereum-magicians.org/) au kwenye [Ethereum R&D Discord](https://discord.gg/mncqtgVSVw).
+
+> Matokeo yanayoweza kutokea katika hatua hii ni:
+
+> - Pendekezo la uendelezaji wa Ethereum itazingatiwa kwa ajili ya sasisho ya wavu ijayo.
+> - Mabadiliko ya kiufundi itahitajika.
+> - Inaweza kukataliwa ikiwa haliwezi kuzingatiwa kama kipaumbele au maboresho hayatoshi kulingana na jitihadi za maendeleo.
+
+3. **Rudia kuelekea pendekezo la mwisho:** baada ya kupokea maoni kutoka kwa washikadau wote husika, kuna uwezekano utahitaji kufanya mabadiliko kwenye pendekezo lako la awali ili kuboresha usalama wake au kukidhi mahitaji ya watumiaji mbalimbali vyema. Mara tu pendekezo la uendelezaji wa Ethereum imejumuisha mabadiliko yote unayooyadhania ni muhimu, utahitaji kuwasilisha tena kwa watengenezaji wa itifaki. Kisha utaendelea kwenye hatua inayofuata ya utaratibu huu, au matatizo mapya yatatokea, yanayohitaji kurekebisha pendekezo lako tena.
+
+4. **EIP Imejumuishwa katika Uboreshaji wa Mtandao**: ikichukuliwa kuwa EIP imeidhinishwa, imejaribiwa na kutekelezwa, hupangwa kama sehemu ya uboreshaji wa mtandao. Kutokana na gharama kubwa za kuratibu maboresho ya wavu (kila mmoja anahitaji kusasisha kwa wakati mmoja), Pendekezo la uendelezaji wa Ethereum kwa kawaida huunganishwa pamoja katika maboresho.
+
+5. **Uboreshaji wa Mtandao Umewashwa**: baada ya uboreshaji wa mtandao kuwashwa, EIP itakuwa hewani kwenye mtandao wa Ethereum. _Kumbuka: maboresho ya mtandao kwa kawaida huwashwa kwenye testnets kabla ya kuwashwa kwenye Mainnet ya Ethereum._
+
+Mtiririko huu, ingawa umefanywa kwa urahisi sana, unatoa muhtasari wa hatua muhimu za mabadiliko ya itifaki yanapopelekwa kwenye Ethereum. Sasa, tazama sababu zisizo rasmi zinachangia katika utaratibu huu.
+
+## Mchakato usio rasmi {#informal-process}
+
+### Kuelewa kazi ya awali {#prior-work}
+
+Washirika wanaoongoza pendekela la uendelezaji wa Ethereum wanapaswa kujifahamisha na kazi na mapendekezo za awali kabla ya kuunda pendekezo ya uendelezazi wa Ethereum ambayo inaweza kuzingatiwa kwa umakini ili kutekelezwa kwenye wavu kuu la Ethereum. Kwa njia hii, pendekezo la uendelezaji wa Ethereum inatarajiewa kuleta kitu kipya ambapo hakijakataliwa hapo awali. Sehemu kuu tatu za kufanyia utafiti huu ni [hazina ya EIP](https://github.com/ethereum/EIPs), [Ethereum Magicians](https://ethereum-magicians.org/) na [ethresear.ch](https://ethresear.ch/).
+
+### Vikundi vya kazi {#working-groups}
+
+Rasimu ya awali ya pendekezo ya uendelezaji wa Ethereum haiwezi kutekelezwa kwenye wavu kuu la Ethereum bila marekebisho au mabadiliko. Kwa ujumla, vinara wa pendekezo la uendelezaji wa Ethereum watafanya kazi na sehemu ndogo ya watengenezaji wa itifaki ili kubainisha, kutekeleza, kujaribu, kurudia na kukamilisha pendekezo lao. Kihistoria, vikundi hivi vya kazi vimehitaji miezi kadhaa (na wakati mwingine miaka!) ya kazi. Vivyo hivyo, vinara wa pendekezo la uendelezaji wa Ethereum kwa mabadiliko kama haya wanapaswa kuwahusisha watengenezaji wa maombi rasmi/tumiaji husika mapema katika juhudi zao ili kukusanya maoni kutoka kwa watumiaji wa mwisho na kupunguza hatari yoyote ya utekelezaji.
+
+### Makubaliano ya jamii {#community-consensus}
+
+Wakati baadhi ya pendekezo za uendelezaji wa Ethereum ni maboresho rahisi ya kiufundi yasiyo na ukinzani mkubwa, mengine ni magumu zaidi na yanakuja na masharti ya kuchagua kati ya mambo fulani ambayo yataathiri washiriki wenye maslahi tofauti kwa njia tofauti. Hii inamaanisha baadhi ya pendekezo la uendelezaji wa Ethereum zenye utata zaidi ndani ya jamii kuliko zingine.
+
+Hakuna mwongozo ulio wazi wa jinsi ya kushughulikia mapendekezo yenye utata. Hii ni matokeo ya muundo wa Ethereum usio na mamlaka ya kati ambapo hakuna kundi la washiriki wenye maslahi linaloweza kulazimisha jingine kwa nguvu za moja kwa moja: watengenezaji wa itifaki wanaweza kuamua kutozingatia mabadiliko ya msimbo; waendeshaji wa kituo wanaweza kuamua kutotumia mteja mpya wa Ethereum; na timu za maombi rasmi pamoja na watumiaji wanaweza kuamua kutoendesha miamala kwenye mnyororo. Kwa kuwa watengenezaji wa itifaki hawana njia ya kulazimisha watu kukubali uboreshaji ya wavu, kwa kawaida wataepuka kutekeleza pendekezo la uendelezaji wa Ethereum pale ambapo ubishi wake unazidi manufaa kwa jumuiya pana.
+
+Mabingwa wa pendekezo la uendelezaji wa Ethereum wanatarajiwa kuomba maoni kutoka kwa washiriki wenye maslahi wote husika. Iwapo utakua bingwa wa pendekezo la uendelezaji wa Ethereum yenye utata, unapaswa kujaribu kushughulikia pingamizi ili kujenga makubaliano kuhusu pendekezo la uendelezaji wa Ethereum yako. Kwa kuzingatia ukubwa na utofauti wa jumuiya ya Ethereum, hakuna kipimo kimoja (k.m., kura ya sarafu) kinachoweza kutumika kupima makubaliano ya jamii, na Watetezi wa EIP wanatarajiwa kubadilika kulingana na mazingira ya pendekezo lao.
+
+Zaidi ya usalama wa wavu la Ethereum, uzito mkubwa kihistoria umewekwa na watengenezaji wa miongozo ya itifaki juu ya kile ambachowatengenezaji wa maombi rasmi/vfaa na watumiaji wa maombi tasmi wanathamini, ikizingatiwa kwamba wao kutmia na kujenga juu ya Etheeum ndicho kinachoufanya mfumo ikolojia kuwa na kuvutia kwa washiriki wenye maslahi wengine. Zaidi ya hayo, pendekezo la uendelezaji wa Ethereum zinahitaji kutekelezwa katika utekelezaji wote wa wateja, ambao inasimamiwa na timu tofauti. Sehemu ya utaratibu huu kwa kawaida inamaanisha kushawishi timu nyingi za watengenezaji itifaki kwamba mabadiliko fulani yana thamani na kwamba inawasaidia watumiaji wa mwisho au kutatua tatizo la usalama.
+
+<Divider />
+
+## Kushughulikia kutokubaliana {#disagreements}
+
+Kuwa na washiriki wenye maslahi wengi wenye msukumo na imani tofauti ina maana kuwa kutokubaliana si jambo nadra.
+
+Kawaida, kutokubaliana kunashughulikiwa kupitia mijadala mirefu kwenye majukwaa ya umma ili kuelewa chanzo cha tatizo na kuruhusu mtu yeyote kutoa maoni yake. Kawaida, kundi moja hukubali kusalimu amri, au suluhu ya kati hupatikana. Ikiwa kundi moja litahisi kwa nguvu ya kutosha na kulazimisha mabadiliko fulani, inaweza kusababisha mgawanyiko wa mnyororo. Mgawanyiko wa mnyororo hutokea pale washiriki wenye maslahi fulani wanapopinga utekelezi wa mabadiliko ya kanuni za mtandao, na kusababisha matoleo tofauti yasiyooana na itifaki kuendeshwa, ambapo mnyororo miwili tofauti ya minyororo wa vizuizi hutokea.
+
+### Uma wa DAO {#dao-fork}
+
+Mgawanyiko ni pale ambapo masasisho makubwa ya kiteknolojia au mabadiliko yanahitajika kufanywa kwenye mtandao na kubadilisha kanuni za itifaki. [Ethereum clients](/developers/docs/nodes-and-clients/) lazima wasasishe programu zao ili kutekeleza sheria mpya za uma.
+
+Uma wa DAO ulikuwa ni jawabu kwa [shambulio la DAO la 2016](https://www.coindesk.com/learn/understanding-the-dao-attack) ambapo mkataba usio salama wa [DAO](/glossary/#dao) uliibiwa zaidi ya ETH milioni 3.6 katika udukuzi. Mgawanyiko huo ulihamish fedah kutoka kwenye mkataba wenye hitilafu hadi mkataba mpya, na hivyo kuruhusu yeyote aliyepoteza fedha katika udukuzi kuzirudisha.
+
+Njia hii ya utekelezaji iliamuliwa kwa kura na jamii ya Ethereum. Mmiliki yeyote wa ETH aliweza kupiga kura kupitia muamala kwenye [jukwaa la kupigia kura](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/). Uamuzi wa kugawanya ilifika zaidi ya asilimia 85 ya kura.
+
+Ni muhimu kutambua kwamba ingawa itifaki iligawanyika ili kurekebisha udukuzi, uzito wa kura katika kufanya uamuzi wa kugawanyika lenye utata kwa sababu kadhaa.:
+
+- Idadi ya wapiga kura walishiriki walikua kidogo mno.
+- Watu wengi hawakujua kuwa kura ilikua ikiendelea.
+- Kura hiyo iliwakilisha tu wamiliki wa ETH, si washiriki wengine wowote katika mfumo huo.
+
+Sehemu ya jamii ilikataa kufanya mgawanyiko wa itifaki, hasa kwa sababu walidhani tukio ya DAO halikua hitilafu katika itifaki. Waliendelea na kuunda [Ethereum Classic](https://ethereumclassic.org/).
+
+Leo, jamii ya Ethereum imekubali kanuni ya kutokuingilia kati katika hali za hitilafu za mikataba au fedha zilizopotea ili kudumisha usawa unaoaminika wa mfumo.
+
+Tazama zaidi kuhusu udukuzi wa DAO.:
+
+<YouTube id="rNeLuBOVe8A" />
+
+<Divider />
+
+### Manufaa ya kuunda uma {#forking-utility}
+
+Mgawanyo wa Ethereum / Ethereum asili ni mfano mzuri wa mgawanyiko wa itifaki yenye afya. Tulikua na vikundi viwili vilivyotofautisha sana kuhusu baadhi ya thamani za msingi, kiasi cha kuhisi kuwa hatari iliyoambatana na kufuata njia zao maalum za utekelezaji ilikua inafaa.
+
+Uwezo wa kufanya mgawanyiko wa itifaki mbele ya tofauti kubwa za kisiasa, kifikra au kiuchumi una mchango mkubwa katika mafanikio ya usimamizi wa Ethereum. Bila uwezo wa mgawanyiko wa itifaki, mbadala ingekuwa ni migongano ya ndani inayoendelea, ushiriki usio wa hiari kwa wale ambao hatimaye waliunda Ethereum asili na maono yanayobadilika kila wakati kuhusu jinsi mafanikio ya Ethereum yanavyopaswa kuonekana.
+
+<Divider />
+
+## Utawala wa Mnyororo Kioleza {#beacon-chain}
+
+Utaratibu wa usimamizi wa Ethereum mara nyingi unabadili kasi na ufanisi kwa ajili ya uwazi na ujumuishaji. Ili kuhakikisha maendeleo ya mnyororo wa taa ya mwongozo, ilianzishwa tofauti na wavu wa Ethereum wa uthibitisho wa kazi na kufuata taratibu zake za usimamizi.
+
+Ingawa ufafanuzi na utekelezaji wa maendeleo daima imekua chanzo wazi kikamilifu, utaratibu rasmi wa kupendekeza maboresho iliyoelezwa hapo juu haukutumiwa. Hii iliwezesha mabadiliko kutambulia na kukubalika haraka ziaidi na watafiti pamoja na wale wanaotekeleza maboresho.
+
+Wakati Mnyororo Kioleza ulipounganishwa na safu ya utekelezaji ya Ethereum mnamo Septemba 15, 2022, Muungano ulikamilika kama sehemu ya [uboreshaji wa mtandao wa Paris](/ethereum-forks/#paris). Pendekezo la [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675) lilibadilishwa kutoka 'Wito wa Mwisho' hadi 'Mwisho', na kukamilisha mpito hadi uthibitisho wa hisa.
+
+<ButtonLink href="/roadmap/merge/">
+  Zaidi kuhusu Muungano
+</ButtonLink>
+
+<Divider />
+
+## Ninaweza kushiriki vipi? {#get-involved}
+
+- [Pendekeza EIP](/eips/#participate)
+- [Jadili mapendekezo ya sasa](https://ethereum-magicians.org/)
+- [Shiriki katika majadiliano ya R&D](https://ethresear.ch/)
+- [Jiunge na Discord ya Ethereum R&D](https://discord.gg/mncqtgVSVw)
+- [Endesha nodi](/developers/docs/nodes-and-clients/run-a-node/)
+- [Changia katika uendelezaji wa mteja](/developers/docs/nodes-and-clients/#execution-clients)
+- [Programu ya Uanagenzi ya Msanidi wa Msingi](https://blog.ethereum.org/2021/09/06/core-dev-apprenticeship-second-cohort/)
+
+## Masomo zaidi {#further-reading}
+
+Usimamizi wa Ethereum haiko wazi kwa utaratibu thabiti. Washirika mbalimbali wa jamii wana mitazamo tofauti kuhusu hilo. Hapa kuna baadhi yao.:
+
+- [Dondoo kuhusu Utawala wa Blockchain](https://vitalik.eth.limo/general/2017/12/17/voting.html) - _Vitalik Buterin_
+- [Utawala wa Ethereum Hufanyaje Kazi?](https://cryptotesters.com/blog/ethereum-governance) – _Cryptotesters_
+- [Jinsi utawala wa Ethereum unavyofanya kazi](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_
+- [Msanidi wa msingi wa Ethereum ni nani?](https://hudsonjameson.com/2020-06-22-what-is-an-ethereum-core-developer/) - _Hudson Jameson_
+- [Utawala, Sehemu ya 2: Plutokrasia Bado ni Mbaya](https://vitalik.eth.limo/general/2018/03/28/plutocracy.html) - _Vitalik Buterin_
+- [Kuvuka mipaka ya utawala wa upigaji kura wa sarafu](https://vitalik.eth.limo/general/2021/08/16/voting3.html) - _Vitalik Buterin_
+- [Kuelewa Utawala wa Blockchain](https://web.archive.org/web/20250124192731/https://research.2077.xyz/understanding-blockchain-governance) - _2077 Research_
+- [Serikali ya Ethereum](https://www.galaxy.com/insights/research/ethereum-governance/) - _Christine Kim_
diff --git a/public/content/translations/sw/guides/how-to-create-an-ethereum-account/index.md b/public/content/translations/sw/guides/how-to-create-an-ethereum-account/index.md
new file mode 100644
index 00000000000..8934986f41e
--- /dev/null
+++ b/public/content/translations/sw/guides/how-to-create-an-ethereum-account/index.md
@@ -0,0 +1,75 @@
+---
+title: Jinsi ya "kufungua" akaunti ya Ethereum
+description: Mwongozo wa hatua kwa hatua juu ya uundaji wa hifadhi ya fedha ya Ethereum kutumia mkoba.
+lang: sw
+---
+
+# Jinsi ya kufungua akaunti ya Ethereum
+
+**Mtu yeyote anaweza kufungua akaunti ya Ethereum bila malipo.** Unahitaji tu kusakinisha programu ya mkoba wa sarafu ya kidigitali. Pochi kuunda na kusimamia hifadhi ya fedha yako Ethereum. Wanaweza tuma shughuli, kuangalia mizani yako na kuunganisha na mpango nyingine kujengwa juu ya Ethereum.
+
+Ukiwa na mkoba unaweza pia kuingia katika exchange yoyote ya tokeni, michezo, na masoko ya [NFT](/glossary/#nft) papo hapo. Hakuna haja ya usajili wa mtu binafsi, hifadhi ya fedha moja pamoja kwa mpango zote zilizojengwa kwenye Ethereum.
+
+## Hatua ya 1: Chagua pochi
+
+Pochi ni mpango ambayo husaidia kusimamia hifadhi ya fedha yako Ethereum. Kuna kadhaa ya mifuko tofauti ya kuchagua kutoka: simu, kompyuta ya mezani, au hata kipengele cha sogeza upanuzi.
+
+<ButtonLink href="/wallets/find-wallet/">
+  Orodha ya mikoba
+</ButtonLink>
+
+Ikiwa ni mara yako ya kwanza, unaweza chagua kichujio cha 'Mgeni kwa crypto (fedha fiche)' kwenye ukurasa wa 'kutafuta pochi' ili kutambua pochi zinazopendekezwa ambazo zina vipengele muhimu vinavyofaa kwa wanaoanza.
+
+![Uteuzi wa kichujio kwenye ukurasa wa 'tafuta mkoba'](./wallet-box.png)
+
+Pia kuna vichujio vya wasifu vya kukidhi mahitaji yako. Hizi ni baadhi ya mifano ya pochi zinazotumika sana - unapaswa kufanya utafiti kibinafsi kabla ya kuamini programu yeyote.
+
+## Hatua ya 2: Shusha na sanikisha programu ya pochi yako
+
+Pindi utakapoamua pochi mbadala, tembelea tovuti yao rasmi au duka la programu, kisha shusha na uisanikishe. Zote zinafaa kuwa bure.
+
+## Hatua ya 3: Fungua programu na uiunde akaunti yako ya Ethereum
+
+Mara ya kwanza utakapofungua pochi yako mpya unaweza ulizwa kuchagua kati ya kutengeneza akaunti mpya au kuingiza akaunti iliyopo tayari. Bonyeza kwa kuunda akaunti mpya. **Hii ni hatua ambayo programu ya pochi itakapoitengeneza akaunti yako ya Ethereum.**
+
+## Hatua ya 4: Hifadhi maneno ya urejesho wa akaunti
+
+Baadhi ya programu zitakuomba uandike na uhifadhi "maneno ya kurejesha" ya kisiri ( yanayojulikana pia kama "seed phrase" ama " mnemonic"). Kuhifadhi maneno haya vizuri ni muhimu kabisa! Hii inatumika kutengeneza akaunti yako ya Ethereum na inaweza tumika kufanya miamala.
+
+**Mtu yeyote anayejua kirai hicho anaweza kudhibiti fedha zote.** Kamwe usishiriki kirai hicho na mtu yeyote. Haya maneno ya kurejesha yanapaswa kuwa kati ya 12 hadi 24 maneno yaliyotengenezwa kwa mpangilio nasibu(mpangilio wa maneno haya ni muhimu sana).
+
+<div>
+<Alert variant="update">
+<AlertEmoji text=":eyes:"/>
+<AlertContent className="flex-row justify-between items-center">
+  <div><b>Umesakinisha mkoba?</b><br/>Jifunze jinsi ya kuutumia.</div>
+  <ButtonLink href="/guides/how-to-use-a-wallet">
+    Jinsi ya kutumia mkoba
+  </ButtonLink>
+</AlertContent>
+</Alert>
+</div>
+
+Ungependa kuona miongozo mingine? Angalia yetu: [Miongozo ya hatua kwa hatua](/guides/)
+
+## Maswali yanayoulizwa mara kwa mara
+
+### Pochi yangu na akaunti ya Ethereum ni sawa?
+
+Hapana. Pochi ni chombo cha usimamizi utakaokusaidia kusimamia akaunti. Pochi moja inaweza kuingia katika akaunti kadhaa, na akaunti moja inaweza kuingiwa na pochi nyingi. Maneno ya kurejesha yanatumiwa kufungua akaunti na yanakupea uwezo kwa programu ya pochi usimamie mali.
+
+### Naweza tuma Bitcoin kwa anwani ya Ethereum, au ether kwa anwani ya Bitcoin?
+
+La, hauwezi. Bitcoin na ether zipo kwenye mitandao miwili tofauti (yaani, blockchain tofauti), kila moja ikiwa na mifumo yake ya uwekaji hesabu na fomati za anwani. Kumekuwa na majaribio mbalimbali ya kuunganisha mitandao miwili tofauti, ambapo linalotumika zaidi kwa sasa ni [Wrapped Bitcoin au WBTC](https://www.bitcoin.com/get-started/what-is-wbtc/). Hii sio uidhinishaji, kwa kuwa WBTC ni suluhu ya ulezi wa mali( inamaanisha kikundi kimoja cha watu kinadhibiti kazi muhimu) na inapewa hapa kwa sababu za kujulisha pekee.
+
+### Ikiwa ninamiliki anwani ya ETH, nawezaje miliki anwani sawa kwenye blockchain zingine?
+
+Unaweza kutumia [anwani](/glossary/#address) ileile kwenye blockchain zote zinazotumia programu ya msingi inayofanana na ya Ethereum (inayojulikana kama 'EVM-compatible'). Hii [orodha](https://chainlist.org/) itakuonyesha minyororo ya bloku ambazo unaweza kutumia na anwani sawa. Baadhi mlolongo wa vitalu, kama Bitcoin, kutekeleza seti tofauti kabisa ya Mtandao Kanuni na unahitaji anwani tofauti na muundo tofauti. Kama una erevu mkataba mkoba unapaswa kuangalia bidhaa yake Mtandao kwa maelezo zaidi juu ya ambayo mlolongo wa vitalu ni mkono kwa sababu kwa kawaida wao na mdogo lakini salama zaidi wigo.
+
+### Je, kuwa na kibeti changu mwenyewe ni salama kuliko kuweka fedha zangu kwenye soko la fedha?
+
+Kuwa na mkoba wako mwenyewe maana kwamba wajibu kwa usalama wa mali zako. Kuna bahati mbaya mifano mingi ya badilisha kushindwa kwamba waliopotea fedha wateja wao. Kumiliki mkoba (na kifungu cha kufufua) huondoa hatari kuhusishwa na kuamini chombo fulani kushikilia mali zako. Hata hivyo, una kupata juu ya yako mwenyewe na kuepuka ulaghai ulaghai, bahati mbaya kupitisha shughuli au fichua ahueni kifungu, kuingiliana na Mtandao wa bandia na hatari nyingine ya kujilinda. Hatari na manufaa ni tofauti.
+
+### Kama mimi kupoteza simu yangu / vifaa mkoba, Je, mimi haja ya kutumia mpango hiyo mkoba tena ili kufufua fedha waliopotea?
+
+La, unaweza kutumia mkoba mwingine. Muda mrefu kama una neno mbegu unaweza kuingia katika pochi wengi na wao kurejesha hifadhi ya fedha yako. Kuwa makini kama wewe milele haja ya kufanya hivyo: ni bora kuhakikisha wewe si kushikamana na Mtandao wakati wa kurejesha mkoba wako ili neno lako mbegu si ajali kuvuja. Ni mara nyingi haiwezekani kurejesha fedha waliopotea bila kifungu ahueni.