diff --git a/public/content/translations/sw/developers/docs/scaling/zk-rollups/index.md b/public/content/translations/sw/developers/docs/scaling/zk-rollups/index.md
new file mode 100644
index 00000000000..9f7c773f2f6
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/scaling/zk-rollups/index.md
@@ -0,0 +1,257 @@
+---
+title: Rollups za Maarifa Sifuri
+description: "Utangulizi wa unda-mpya za zero-knowledge—suluhisho la uongezwaji linalotumiwa na jamii ya Ethereum."
+lang: sw
+---
+
+Unda-mpya za zero-knowledge (ZK-rollups) ni [suluhisho za uongezwaji](/developers/docs/scaling/) za safu ya 2 ambazo huongeza uwezo wa usindikaji kwenye Mtandao Mkuu wa Ethereum kwa kuhamisha ukokotoaji na hifadhi ya hali nje ya mnyororo. Unda-mpya za ZK zinaweza kushughulikia maelfu ya miamala katika kundi moja na kisha kuchapisha tu data ndogo ya muhtasari kwenye Mtandao Mkuu. Data hii ya muhtasari inabainisha mabadiliko ambayo yanapaswa kufanywa kwenye hali ya Ethereum na baadhi ya uthibitisho wa kiroptografia kwamba mabadiliko hayo ni sahihi.
+
+## Mahitaji ya awali {#prerequisites}
+
+Unapaswa kuwa umesoma na kuelewa ukurasa wetu kuhusu [kuongeza ukubwa wa Ethereum](/developers/docs/scaling/) na [safu ya 2](/layer-2).
+
+## Unda-mpya za zero-knowledge ni nini? {#what-are-zk-rollups}
+
+**Unda-mpya za zero-knowledge (ZK-rollups)** huunganisha (au 'kukunja') miamala kuwa makundi ambayo hutekelezwa nje ya mnyororo. Ukokotoaji wa nje ya mnyororo hupunguza kiasi cha data kinachopaswa kuchapishwa kwenye mnyororo wa bloku. Waendeshaji wa unda-mpya wa ZK huwasilisha muhtasari wa mabadiliko yanayohitajika kuwakilisha miamala yote katika kundi badala ya kutuma kila muamala kivyake. Pia huzalisha [uthibitisho wa uhalali](/glossary/#validity-proof) ili kuthibitisha usahihi wa mabadiliko yao.
+
+Hali ya unda-mpya ya ZK inadumishwa na mkataba-erevu uliotumwa kwenye mtandao wa Ethereum. Ili kusasisha hali hii, nodi za unda-mpya za ZK lazima ziwakilishe uthibitisho wa uhalali kwa ajili ya uthibitishaji. Kama ilivyotajwa, uthibitisho wa uhalali ni hakikisho la kiroptografia kwamba mabadiliko ya hali yaliyopendekezwa na unda-mpya ni kweli matokeo ya kutekeleza kundi husika la miamala. Hii inamaanisha kwamba unda-mpya za ZK zinahitaji tu kutoa uthibitisho wa uhalali ili kukamilisha miamala kwenye Ethereum badala ya kuchapisha data yote ya miamala kwenye mnyororo kama [optimistic rollups](/developers/docs/scaling/optimistic-rollups/).
+
+Hakuna ucheleweshaji wakati wa kuhamisha fedha kutoka kwa unda-mpya ya ZK kwenda Ethereum kwa sababu miamala ya kutoka hutekelezwa mara tu mkataba wa unda-mpya wa ZK unapothibitisha uthibitisho wa uhalali. Kinyume chake, kutoa fedha kutoka kwa optimistic rollups kuna ucheleweshaji ili kumruhusu yeyote kupinga muamala wa kutoka kwa kutumia [uthibitisho wa ulaghai](/glossary/#fraud-proof).
+
+Unda-mpya za ZK huandika miamala kwa Ethereum kama `calldata`. `calldata` ni mahali ambapo data inayojumuishwa katika miito ya nje kwa vitendaji vya mkataba-erevu huhifadhiwa. Taarifa katika `calldata` huchapishwa kwenye mnyororo wa bloku, na kumruhusu yeyote kuunda upya hali ya unda-mpya kwa kujitegemea. Unda-mpya za ZK hutumia mbinu za kubana data ili kupunguza data ya muamala—kwa mfano, akaunti zinawakilishwa na faharasa badala ya anwani, ambayo huokoa baiti 28 za data. Uchapishaji wa data kwenye mnyororo ni gharama kubwa kwa unda-mpya, hivyo kubana data kunaweza kupunguza ada kwa watumiaji.
+
+## Unda-mpya za ZK huingilianaje na Ethereum? {#zk-rollups-and-ethereum}
+
+Mnyororo wa unda-mpya wa ZK ni itifaki ya nje ya mnyororo inayofanya kazi juu ya mnyororo wa bloku wa Ethereum na inasimamiwa na mikataba-erevu ya Ethereum iliyo kwenye mnyororo. Unda-mpya za ZK hutekeleza miamala nje ya Mtandao Mkuu, lakini mara kwa mara huwasilisha makundi ya miamala ya nje ya mnyororo kwa mkataba wa unda-mpya ulio kwenye mnyororo. Rekodi hii ya muamala haibadiliki, kama vile mnyororo wa bloku wa Ethereum, na huunda mnyororo wa unda-mpya wa ZK.
+
+Usanifu mkuu wa unda-mpya wa ZK umeundwa na vipengele vifuatavyo:
+
+1. **Mikataba iliyo kwenye mnyororo**: Kama ilivyotajwa, itifaki ya unda-mpya ya ZK inadhibitiwa na mikataba-erevu inayoendeshwa kwenye Ethereum. Hii inajumuisha mkataba mkuu unaohifadhi bloku za unda-mpya, kufuatilia amana, na kufuatilia masasisho ya hali. Mkataba mwingine ulio kwenye mnyororo (mkataba wa kuthibitisha) huthibitisha uthibitisho wa zero-knowledge uliowasilishwa na wazalishaji wa bloku. Hivyo, Ethereum hutumika kama safu ya msingi au "safu ya 1" kwa unda-mpya ya ZK.
+
+2. **Mashine halisi ya nje ya mnyororo (VM)**: Ingawa itifaki ya unda-mpya ya ZK iko kwenye Ethereum, utekelezaji wa miamala na hifadhi ya hali hufanyika kwenye mashine halisi tofauti isiyotegemea [EVM](/developers/docs/evm/). VM hii ya nje ya mnyororo ni mazingira ya utekelezaji wa miamala kwenye unda-mpya ya ZK na hutumika kama safu ya pili au "safu ya 2" kwa itifaki ya unda-mpya ya ZK. Uthibitisho wa uhalali unaothibitishwa kwenye Mtandao Mkuu wa Ethereum huhakikisha usahihi wa mabadiliko ya hali katika VM ya nje ya mnyororo.
+
+Unda-mpya za ZK ni "suluhisho za uongezwaji za mseto"—itifaki za nje ya mnyororo zinazofanya kazi kwa kujitegemea lakini zinapata usalama kutoka kwa Ethereum. Hasa, mtandao wa Ethereum hutekeleza uhalali wa masasisho ya hali kwenye unda-mpya ya ZK na huhakikisha upatikanaji wa data nyuma ya kila sasisho la hali ya unda-mpya. Matokeo yake, unda-mpya za ZK ni salama zaidi kuliko suluhisho za uongezwaji za nje ya mnyororo, kama vile [sidechains](/developers/docs/scaling/sidechains/), ambazo zinawajibika kwa sifa zao za usalama, au [validiums](/developers/docs/scaling/validium/), ambazo pia huthibitisha miamala kwenye Ethereum kwa kutumia uthibitisho wa uhalali, lakini huhifadhi data ya muamala mahali pengine.
+
+Unda-mpya za ZK hutegemea itifaki kuu ya Ethereum kwa yafuatayo:
+
+### Upatikanaji wa data {#data-availability}
+
+Unda-mpya za ZK huchapisha data ya hali kwa kila muamala unaochakatwa nje ya mnyororo kwenda Ethereum. Kwa data hii, inawezekana kwa watu binafsi au biashara kuiga hali ya unda-mpya na kuhalalisha mnyororo wenyewe. Ethereum hufanya data hii ipatikane kwa washiriki wote wa mtandao kama `calldata`.
+
+Unda-mpya za ZK hazihitaji kuchapisha data nyingi ya miamala kwenye mnyororo kwa sababu uthibitisho wa uhalali tayari unathibitisha uhalisi wa mabadiliko ya hali. Hata hivyo, kuhifadhi data kwenye mnyororo bado ni muhimu kwa sababu inaruhusu uthibitishaji usio na ruhusa, wa kujitegemea wa hali ya mnyororo wa L2 ambao kwa upande wake unaruhusu mtu yeyote kuwasilisha makundi ya miamala, na kuzuia waendeshaji wenye dhamira mbaya kudhibiti au kufungia mnyororo.
+
+Kwenye mnyororo inahitajika ili watumiaji waingiliane na unda-mpya. Bila ufikiaji wa data ya hali, watumiaji hawawezi kuuliza salio la akaunti zao au kuanzisha miamala (k.m., uondoaji) inayotegemea taarifa ya hali.
+
+### Umisho wa muamala {#transaction-finality}
+
+Ethereum hufanya kazi kama safu ya malipo kwa unda-mpya za ZK: miamala ya L2 hukamilishwa tu ikiwa mkataba wa L1 unakubali uthibitisho wa uhalali. Hii huondoa hatari ya waendeshaji wenye dhamira mbaya kuharibu mnyororo (k.m., kuiba fedha za unda-mpya) kwani kila muamala lazima uidhinishwe kwenye Mtandao Mkuu. Pia, Ethereum huhakikisha kwamba operesheni za watumiaji haziwezi kugeuzwa mara tu zinapokamilishwa kwenye L1.
+
+### Ukinzani dhidi ya udhibiti {#censorship-resistance}
+
+Unda-mpya nyingi za ZK hutumia "supernode" (mwendeshaji) kutekeleza miamala, kuzalisha makundi, na kuwasilisha bloku kwa L1. Ingawa hii inahakikisha ufanisi, inaongeza hatari ya udhibiti: waendeshaji wa unda-mpya wa ZK wenye dhamira mbaya wanaweza kudhibiti watumiaji kwa kukataa kujumuisha miamala yao katika makundi.
+
+Kama hatua ya usalama, unda-mpya za ZK huruhusu watumiaji kuwasilisha miamala moja kwa moja kwa mkataba wa unda-mpya kwenye Mtandao Mkuu ikiwa wanafikiri wanadhibitiwa na mwendeshaji. Hii inaruhusu watumiaji kulazimisha kutoka kwa unda-mpya ya ZK kwenda Ethereum bila kutegemea ruhusa ya mwendeshaji.
+
+## Unda-mpya za ZK hufanyaje kazi? {#how-do-zk-rollups-work}
+
+### Miamala {#transactions}
+
+Watumiaji katika unda-mpya ya ZK husaini miamala na kuiwasilisha kwa waendeshaji wa L2 kwa ajili ya usindikaji na ujumuishaji katika kundi linalofuata. Katika baadhi ya matukio, mwendeshaji ni huluki ya kati, inayoitwa mratibu wa mfuatano, ambaye hutekeleza miamala, kuiunganisha kuwa makundi, na kuiwasilisha kwa L1. Mratibu wa mfuatano katika mfumo huu ndiye huluki pekee inayoruhusiwa kuzalisha bloku za L2 na kuongeza miamala ya unda-mpya kwenye mkataba wa unda-mpya wa ZK.
+
+Unda-mpya zingine za ZK zinaweza kubadilisha jukumu la mwendeshaji kwa kutumia seti ya wathibitishaji wa [uthibitisho wa hisa](/developers/docs/consensus-mechanisms/pos/). Waendeshaji watarajiwa huweka fedha katika mkataba wa unda-mpya, ambapo ukubwa wa kila hisa huathiri nafasi ya mweka hisa kuchaguliwa kuzalisha kundi linalofuata la unda-mpya. Hisa ya mwendeshaji inaweza kupunguzwa ikiwa atatenda kwa dhamira mbaya, jambo ambalo huwahamasisha kuchapisha bloku halali.
+
+#### Jinsi unda-mpya za ZK zinavyochapisha data ya muamala kwenye Ethereum {#how-zk-rollups-publish-transaction-data-on-ethereum}
+
+Kama ilivyoelezwa, data ya muamala huchapishwa kwenye Ethereum kama `calldata`. `calldata` ni eneo la data katika mkataba-erevu linalotumiwa kupitisha hoja kwa kitendaji na hufanya kazi sawa na [kumbukumbu](/developers/docs/smart-contracts/anatomy/#memory). `calldata` haihifadhiwi kama sehemu ya hali ya Ethereum, inadumu kwenye mnyororo kama sehemu ya [kumbukumbu za historia](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html?highlight=memory#logs) za mnyororo wa Ethereum. `calldata` haiathiri hali ya Ethereum, na kuifanya kuwa njia ya bei rahisi ya kuhifadhi data kwenye mnyororo.
+
+Neno kuu `calldata` mara nyingi hutambulisha mbinu ya mkataba-erevu inayoitwa na muamala na huhifadhi viingizio vya mbinu hiyo katika mfumo wa mfuatano wowote wa baiti. Unda-mpya za ZK hutumia `calldata` kuchapisha data ya muamala iliyobanwa kwenye mnyororo; mwendeshaji wa unda-mpya huongeza tu kundi jipya kwa kuita kitendaji kinachohitajika katika mkataba wa unda-mpya na kupitisha data iliyobanwa kama hoja za kitendaji. Hii husaidia kupunguza gharama kwa watumiaji kwani sehemu kubwa ya ada za unda-mpya huelekezwa kwenye kuhifadhi data ya muamala kwenye mnyororo.
+
+### Ahadi za hali {#state-commitments}
+
+Hali ya unda-mpya ya ZK, ambayo inajumuisha akaunti na salio za L2, inawakilishwa kama [mti wa Merkle](/whitepaper/#merkle-trees). Hashi ya kiroptografia ya mzizi wa mti wa Merkle (mzizi wa Merkle) huhifadhiwa katika mkataba wa kwenye mnyororo, kuruhusu itifaki ya unda-mpya kufuatilia mabadiliko katika hali ya unda-mpya ya ZK.
+
+Unda-mpya hubadilika na kuwa hali mpya baada ya utekelezaji wa seti mpya ya miamala. Mwendeshaji aliyeanzisha mabadiliko ya hali anahitajika kukokotoa mzizi mpya wa hali na kuwasilisha kwa mkataba wa kwenye mnyororo. Ikiwa uthibitisho wa uhalali unaohusishwa na kundi umethibitishwa na mkataba wa kuthibitisha, mzizi mpya wa Merkle unakuwa mzizi wa hali rasmi wa unda-mpya ya ZK.
+
+Mbali na kukokotoa mizizi ya hali, mwendeshaji wa unda-mpya wa ZK pia huunda mzizi wa kundi—mzizi wa mti wa Merkle unaojumuisha miamala yote katika kundi. Wakati kundi jipya linawasilishwa, mkataba wa unda-mpya huhifadhi mzizi wa kundi, kuruhusu watumiaji kuthibitisha muamala (k.m., ombi la kutoa pesa) ulijumuishwa katika kundi. Watumiaji watalazimika kutoa maelezo ya muamala, mzizi wa kundi, na [uthibitisho wa Merkle](/developers/tutorials/merkle-proofs-for-offline-data-integrity/) unaoonyesha njia ya ujumuishaji.
+
+### Uthibitisho wa uhalali {#validity-proofs}
+
+Mzizi mpya wa hali ambao mwendeshaji wa unda-mpya wa ZK anawasilisha kwa mkataba wa L1 ni matokeo ya masasisho kwenye hali ya unda-mpya. Sema Alice anamtumia Bob ishara 10, mwendeshaji anapunguza tu salio la Alice kwa 10 na kuongeza salio la Bob kwa 10. Kisha mwendeshaji huhasi data ya akaunti iliyosasishwa, anaunda upya mti wa Merkle wa unda-mpya, na anawasilisha mzizi mpya wa Merkle kwa mkataba wa kwenye mnyororo.
+
+Lakini mkataba wa unda-mpya hautakubali kiotomatiki ahadi ya hali iliyopendekezwa hadi mwendeshaji athibitishe kuwa mzizi mpya wa Merkle ulitokana na masasisho sahihi kwenye hali ya unda-mpya. Mwendeshaji wa unda-mpya wa ZK hufanya hivi kwa kutoa uthibitisho wa uhalali, ahadi fupi ya kiroptografia inayothibitisha usahihi wa miamala iliyowekwa kwenye makundi.
+
+Uthibitisho wa uhalali huruhusu pande kuthibitisha usahihi wa taarifa bila kufichua taarifa yenyewe—hivyo, pia huitwa uthibitisho wa zero-knowledge. Unda-mpya za ZK hutumia uthibitisho wa uhalali kuthibitisha usahihi wa mabadiliko ya hali ya nje ya mnyororo bila kulazimika kutekeleza upya miamala kwenye Ethereum. Uthibitisho huu unaweza kuja katika mfumo wa [ZK-SNARK](https://arxiv.org/abs/2202.06877) (Hoja Fupi Isiyoingiliana ya Ujuzi ya Zero-Knowledge) au [ZK-STARK](https://eprint.iacr.org/2018/046) (Hoja Inayoweza Kuongezwa Uwazi ya Ujuzi ya Zero-Knowledge).
+
+SNARKs na STARKs zote husaidia kuthibitisha uadilifu wa ukokotoaji wa nje ya mnyororo katika unda-mpya za ZK, ingawa kila aina ya uthibitisho ina sifa za kipekee.
+
+**ZK-SNARKs**
+
+Ili itifaki ya ZK-SNARK ifanye kazi, kuunda Mfuatano wa Rejea ya Pamoja (CRS) ni muhimu: CRS hutoa vigezo vya umma vya kuthibitisha na kuthibitisha uthibitisho wa uhalali. Usalama wa mfumo wa uthibitisho unategemea usanidi wa CRS; ikiwa taarifa iliyotumika kuunda vigezo vya umma itaangukia mikononi mwa wahusika wenye dhamira mbaya, wanaweza kuwa na uwezo wa kutoa uthibitisho wa uhalali wa uongo.
+
+Baadhi ya unda-mpya za ZK hujaribu kutatua tatizo hili kwa kutumia [sherehe ya ukokotoaji wa pande nyingi (MPC)](https://zkproof.org/2021/06/30/setup-ceremonies/amp/), inayohusisha watu wanaoaminika, ili kuzalisha vigezo vya umma kwa ajili ya mzunguko wa ZK-SNARK. Kila upande huchangia bahati nasibu (inayoitwa "taka sumu") katika ujenzi wa CRS, ambayo lazima waiharibu mara moja.
+
+Usanidi unaoaminika hutumiwa kwa sababu huongeza usalama wa usanidi wa CRS. Muda wote mshiriki mmoja mkweli anapoharibu ingizo lake, usalama wa mfumo wa ZK-SNARK unahakikishwa. Bado, mbinu hii inahitaji kuwaamini wale waliohusika kufuta bahati nasibu yao iliyochukuliwa na si kudhoofisha dhamana za usalama za mfumo.
+
+Mbali na dhana za uaminifu, ZK-SNARKs ni maarufu kwa ukubwa wao mdogo wa uthibitisho na uthibitishaji wa wakati usiobadilika. Kwa kuwa uthibitishaji wa uthibitisho kwenye L1 unajumuisha gharama kubwa zaidi ya kuendesha unda-mpya ya ZK, L2s hutumia ZK-SNARKs kuzalisha uthibitisho unaoweza kuthibitishwa haraka na kwa bei nafuu kwenye Mtandao Mkuu.
+
+**ZK-STARKs**
+
+Kama ZK-SNARKs, ZK-STARKs huthibitisha uhalali wa ukokotoaji wa nje ya mnyororo bila kufichua viingizi. Hata hivyo, ZK-STARKs huchukuliwa kama uboreshaji wa ZK-SNARKs kwa sababu ya uwezo wao wa kuongezeka na uwazi.
+
+ZK-STARKs ni 'wazi', kwani zinaweza kufanya kazi bila usanidi unaoaminika wa Mfuatano wa Rejea ya Pamoja (CRS). Badala yake, ZK-STARKs hutegemea bahati nasibu inayoweza kuthibitishwa na umma ili kuweka vigezo vya kuzalisha na kuthibitisha uthibitisho.
+
+ZK-STARKs pia hutoa uwezo mkubwa zaidi wa kuongezeka kwa sababu muda unaohitajika kuthibitisha na kuthibitisha uthibitisho wa uhalali huongezeka _karibu-linearly_ kulingana na ugumu wa ukokotoaji wa msingi. Kwa ZK-SNARKs, nyakati za kuthibitisha na kuthibitisha huongezeka _linearly_ kulingana na ukubwa wa ukokotoaji wa msingi. Hii inamaanisha ZK-STARKs zinahitaji muda mfupi kuliko ZK-SNARKs kwa kuthibitisha na kuthibitisha wakati seti kubwa za data zinahusika, na kuzifanya kuwa muhimu kwa matumizi ya kiwango kikubwa.
+
+ZK-STARKs pia ni salama dhidi ya kompyuta za quantum, wakati Kiroptografia ya Mviringo wa Elliptic (ECC) inayotumiwa katika ZK-SNARKs inaaminika kuwa rahisi kushambuliwa na mashambulizi ya kompyuta ya quantum. Upungufu wa ZK-STARKs ni kwamba huzalisha ukubwa mkubwa zaidi wa uthibitisho, ambao ni ghali zaidi kuthibitisha kwenye Ethereum.
+
+#### Uthibitisho wa uhalali hufanyaje kazi katika unda-mpya za ZK? {#validity-proofs-in-zk-rollups}
+
+##### Uzalishaji wa uthibitisho
+
+Kabla ya kukubali miamala, mwendeshaji atafanya ukaguzi wa kawaida. Hii inajumuisha kuthibitisha kwamba:
+
+- Akaunti za mtumaji na mpokeaji ni sehemu ya mti wa hali.
+- Mtumaji ana fedha za kutosha kushughulikia muamala.
+- Muamala ni sahihi na unalingana na ufunguo wa umma wa mtumaji kwenye unda-mpya.
+- Nonce ya mtumaji ni sahihi, n.k.
+
+Mara tu nodi ya unda-mpya ya ZK inapokuwa na miamala ya kutosha, inaziunganisha kuwa kundi na kuandaa viingizi kwa ajili ya mzunguko wa kuthibitisha ili kuandaa uthibitisho mfupi wa ZK. Hii inajumuisha:
+
+- Mzizi wa mti wa Merkle unaojumuisha miamala yote katika kundi.
+- Uthibitisho wa Merkle kwa miamala ili kuthibitisha ujumuishaji katika kundi.
+- Uthibitisho wa Merkle kwa kila jozi ya mtumaji-mpokeaji katika miamala ili kuthibitisha akaunti hizo ni sehemu ya mti wa hali wa unda-mpya.
+- Seti ya mizizi ya hali ya kati, inayotokana na kusasisha mzizi wa hali baada ya kutumia masasisho ya hali kwa kila muamala (yaani, kupunguza akaunti za watumaji na kuongeza akaunti za wapokeaji).
+
+Mzunguko wa kuthibitisha hukokotoa uthibitisho wa uhalali kwa "kupitia" kila muamala na kufanya ukaguzi uleule ambao mwendeshaji alikamilisha kabla ya kushughulikia muamala. Kwanza, inathibitisha kuwa akaunti ya mtumaji ni sehemu ya mzizi uliopo wa hali kwa kutumia uthibitisho wa Merkle uliotolewa. Kisha inapunguza salio la mtumaji, inaongeza nonce yao, inahasi data ya akaunti iliyosasishwa na kuiunganisha na uthibitisho wa Merkle ili kutoa mzizi mpya wa Merkle.
+
+Mzizi huu wa Merkle unaonyesha mabadiliko pekee katika hali ya unda-mpya ya ZK: mabadiliko katika salio na nonce ya mtumaji. Hii inawezekana kwa sababu uthibitisho wa Merkle uliotumiwa kuthibitisha uwepo wa akaunti hutumiwa kupata mzizi mpya wa hali.
+
+Mzunguko wa kuthibitisha hufanya mchakato uleule kwenye akaunti ya mpokeaji. Inakagua ikiwa akaunti ya mpokeaji ipo chini ya mzizi wa hali ya kati (kwa kutumia uthibitisho wa Merkle), inaongeza salio lao, inahasi upya data ya akaunti na kuiunganisha na uthibitisho wa Merkle ili kutoa mzizi mpya wa hali.
+
+Mchakato unarudiwa kwa kila muamala; kila "mzunguko" huunda mzizi mpya wa hali kutokana na kusasisha akaunti ya mtumaji na mzizi mpya unaofuata kutokana na kusasisha akaunti ya mpokeaji. Kama ilivyoelezwa, kila sasisho la mzizi wa hali linawakilisha sehemu moja ya mti wa hali wa unda-mpya inayobadilika.
+
+Mzunguko wa kuthibitisha wa ZK hupitia kundi zima la miamala, ukithibitisha mfuatano wa masasisho ambayo husababisha mzizi wa mwisho wa hali baada ya muamala wa mwisho kutekelezwa. Mzizi wa mwisho wa Merkle uliokokotolewa unakuwa mzizi mpya zaidi wa hali rasmi wa unda-mpya ya ZK.
+
+##### Uthibitishaji wa uthibitisho
+
+Baada ya mzunguko wa kuthibitisha kuthibitisha usahihi wa masasisho ya hali, mwendeshaji wa L2 huwasilisha uthibitisho wa uhalali uliokokotolewa kwa mkataba wa kuthibitisha kwenye L1. Mzunguko wa uthibitishaji wa mkataba huthibitisha uhalali wa uthibitisho na pia hukagua viingizi vya umma ambavyo ni sehemu ya uthibitisho:
+
+- **Mzizi wa kabla ya hali**: Mzizi wa zamani wa hali wa unda-mpya ya ZK (yaani, kabla ya miamala iliyowekwa kwenye makundi kutekelezwa), unaoakisi hali ya mwisho inayojulikana kuwa halali ya mnyororo wa L2.
+
+- **Mzizi wa baada ya hali**: Mzizi mpya wa hali wa unda-mpya ya ZK (yaani, baada ya utekelezaji wa miamala iliyowekwa kwenye makundi), unaoakisi hali mpya zaidi ya mnyororo wa L2. Mzizi wa baada ya hali ni mzizi wa mwisho unaopatikana baada ya kutumia masasisho ya hali katika mzunguko wa kuthibitisha.
+
+- **Mzizi wa kundi**: Mzizi wa Merkle wa kundi, unaopatikana kwa _kuweka kwenye mti wa Merkle_ miamala katika kundi na kuhasi mzizi wa mti.
+
+- **Viingizi vya muamala**: Data inayohusishwa na miamala iliyotekelezwa kama sehemu ya kundi lililowasilishwa.
+
+Ikiwa uthibitisho unakidhi mzunguko (yaani, ni halali), inamaanisha kuwa kuna mfuatano wa miamala halali ambayo hubadilisha unda-mpya kutoka hali ya awali (iliyotiwa alama ya kidole kiroptografia na mzizi wa kabla ya hali) hadi hali mpya (iliyotiwa alama ya kidole kiroptografia na mzizi wa baada ya hali). Ikiwa mzizi wa kabla ya hali unalingana na mzizi uliohifadhiwa katika mkataba wa unda-mpya, na uthibitisho ni halali, mkataba wa unda-mpya huchukua mzizi wa baada ya hali kutoka kwenye uthibitisho na kusasisha mti wake wa hali ili kuakisi hali iliyobadilika ya unda-mpya.
+
+### Kuingia na kutoka {#entries-and-exits}
+
+Watumiaji huingia kwenye unda-mpya ya ZK kwa kuweka ishara katika mkataba wa unda-mpya uliotumwa kwenye mnyororo wa L1. Muamala huu unawekwa kwenye foleni kwani waendeshaji pekee ndio wanaoweza kuwasilisha miamala kwa mkataba wa unda-mpya.
+
+Ikiwa foleni ya amana inayosubiri itaanza kujaa, mwendeshaji wa unda-mpya wa ZK atachukua miamala ya amana na kuiwasilisha kwa mkataba wa unda-mpya. Mara tu fedha za mtumiaji zinapokuwa kwenye unda-mpya, anaweza kuanza kufanya miamala kwa kutuma miamala kwa mwendeshaji ili ichakatwe. Watumiaji wanaweza kuthibitisha salio kwenye unda-mpya kwa kuhasi data ya akaunti yao, kutuma hashi kwa mkataba wa unda-mpya, na kutoa uthibitisho wa Merkle ili kuthibitisha dhidi ya mzizi wa sasa wa hali.
+
+Kutoa fedha kutoka kwa unda-mpya ya ZK kwenda L1 ni rahisi. Mtumiaji huanzisha muamala wa kutoka kwa kutuma mali zake kwenye unda-mpya kwa akaunti maalum kwa ajili ya kuchomwa. Ikiwa mwendeshaji atajumuisha muamala katika kundi linalofuata, mtumiaji anaweza kuwasilisha ombi la kutoa pesa kwa mkataba wa kwenye mnyororo. Ombi hili la kutoa pesa litajumuisha yafuatayo:
+
+- Uthibitisho wa Merkle unaothibitisha ujumuishaji wa muamala wa mtumiaji kwenye akaunti ya kuchoma katika kundi la miamala
+
+- Data ya muamala
+
+- Mzizi wa kundi
+
+- Anwani ya L1 ya kupokea fedha zilizowekwa
+
+Mkataba wa unda-mpya huhasi data ya muamala, hukagua ikiwa mzizi wa kundi upo, na hutumia uthibitisho wa Merkle kuangalia ikiwa hashi ya muamala ni sehemu ya mzizi wa kundi. Baada ya hapo, mkataba hutekeleza muamala wa kutoka na kutuma fedha kwa anwani iliyochaguliwa na mtumiaji kwenye L1.
+
+## Unda-mpya za ZK na uoanifu wa EVM {#zk-rollups-and-evm-compatibility}
+
+Tofauti na optimistic rollups, unda-mpya za ZK haziendani kwa urahisi na [Mashine Halisi ya Ethereum (EVM)](/developers/docs/evm/). Kuthibitisha ukokotoaji wa jumla wa EVM katika mizunguko ni ngumu zaidi na kunahitaji rasilimali nyingi kuliko kuthibitisha ukokotoaji rahisi (kama uhamisho wa ishara ulioelezwa hapo awali).
+
+Hata hivyo, [maendeleo katika teknolojia ya zero-knowledge](https://hackmd.io/@yezhang/S1_KMMbGt#Why-possible-now) yanachochea upya nia ya kufunika ukokotoaji wa EVM katika uthibitisho wa zero-knowledge. Juhudi hizi zinalenga kuunda utekelezaji wa zero-knowledge EVM (zkEVM) unaoweza kuthibitisha kwa ufanisi usahihi wa utekelezaji wa programu. ZkEVM huunda upya misimbo ya uendeshaji iliyopo ya EVM kwa ajili ya kuthibitisha/kuthibitisha katika mizunguko, kuruhusu kutekeleza mikataba-erevu.
+
+Kama EVM, zkEVM hubadilika kati ya hali baada ya ukokotoaji kufanywa kwenye baadhi ya viingizi. Tofauti ni kwamba zkEVM pia huunda uthibitisho wa zero-knowledge ili kuthibitisha usahihi wa kila hatua katika utekelezaji wa programu. Uthibitisho wa uhalali unaweza kuthibitisha usahihi wa operesheni zinazogusa hali ya VM (kumbukumbu, mrundikano, ghala) na ukokotoaji wenyewe (yaani, je, operesheni iliita misimbo sahihi ya uendeshaji na kuitekeleza kwa usahihi?).
+
+Kuanzishwa kwa unda-mpya za ZK zinazoendana na EVM kunatarajiwa kusaidia wasanidi programu kutumia uwezo wa kuongezeka na dhamana za usalama za uthibitisho wa zero-knowledge. Muhimu zaidi, uoanifu na miundombinu asilia ya Ethereum inamaanisha wasanidi programu wanaweza kuunda mfumo mtawanyo wa kimamlaka unaofaa kwa ZK kwa kutumia zana na lugha zinazojulikana (na zilizojaribiwa).
+
+## Ada za unda-mpya za ZK hufanyaje kazi? {#how-do-zk-rollup-fees-work}
+
+Kiasi ambacho watumiaji hulipa kwa miamala kwenye unda-mpya za ZK kinategemea ada ya gesi, kama tu kwenye Mtandao Mkuu wa Ethereum. Hata hivyo, ada za gesi hufanya kazi tofauti kwenye L2 na huathiriwa na gharama zifuatazo:
+
+1. **Uandishi wa hali**: Kuna gharama isiyobadilika ya kuandika kwenye hali ya Ethereum (yaani, kuwasilisha muamala kwenye mnyororo wa bloku wa Ethereum). Unda-mpya za ZK hupunguza gharama hii kwa kuweka miamala kwenye makundi na kugawanya gharama zisizobadilika kwa watumiaji wengi.
+
+2. **Uchapishaji wa data**: Unda-mpya za ZK huchapisha data ya hali kwa kila muamala kwenda Ethereum kama `calldata`. Gharama za `calldata` kwa sasa zinasimamiwa na [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559), ambayo inabainisha gharama ya gesi 16 kwa baiti zisizo sifuri na gesi 4 kwa baiti sifuri za `calldata`, mtawalia. Gharama inayolipwa kwa kila muamala huathiriwa na kiasi gani cha `calldata` kinachohitaji kuchapishwa kwenye mnyororo kwa ajili yake.
+
+3. **Ada za mwendeshaji wa L2**: Hiki ni kiasi kinacholipwa kwa mwendeshaji wa unda-mpya kama fidia kwa gharama za ukokotoaji zilizotumika katika kuchakata miamala, sawa na ["ada za kipaumbele za muamala (vidokezo)"](/developers/docs/gas/#how-are-gas-fees-calculated) kwenye Mtandao Mkuu wa Ethereum.
+
+4. **Uzalishaji na uthibitishaji wa uthibitisho**: Waendeshaji wa unda-mpya wa ZK lazima wazalishe uthibitisho wa uhalali kwa makundi ya miamala, jambo ambalo linahitaji rasilimali nyingi. Kuthibitisha uthibitisho wa zero-knowledge kwenye Mtandao Mkuu pia hugharimu gesi (~ gesi 500,000).
+
+Mbali na kuweka miamala kwenye makundi, unda-mpya za ZK hupunguza ada kwa watumiaji kwa kubana data ya muamala. Unaweza [kuona muhtasari wa wakati halisi](https://l2fees.info/) wa gharama za kutumia unda-mpya za ZK za Ethereum.
+
+## Unda-mpya za ZK huongezaje ukubwa wa Ethereum? {#scaling-ethereum-with-zk-rollups}
+
+### Ubanaji wa data ya muamala {#transaction-data-compression}
+
+Unda-mpya za ZK huongeza uwezo wa usindikaji kwenye safu ya msingi ya Ethereum kwa kupeleka ukokotoaji nje ya mnyororo, lakini msukumo halisi wa kuongeza ukubwa hutokana na kubana data ya muamala. [Ukubwa wa bloku](/developers/docs/blocks/#block-size) wa Ethereum huweka kikomo cha data ambayo kila bloku inaweza kushikilia na, kwa hivyo, idadi ya miamala inayochakatwa kwa kila bloku. Kwa kubana data inayohusiana na miamala, unda-mpya za ZK huongeza kwa kiasi kikubwa idadi ya miamala inayochakatwa kwa kila bloku.
+
+Unda-mpya za ZK zinaweza kubana data ya muamala bora kuliko optimistic rollups kwa kuwa hazihitaji kuchapisha data yote inayohitajika kuhalalisha kila muamala. Zinahitaji tu kuchapisha data ndogo inayohitajika ili kuunda upya hali ya hivi karibuni ya akaunti na salio kwenye unda-mpya.
+
+### Ithibati za kujirudia {#recursive-proofs}
+
+Faida ya uthibitisho wa zero-knowledge ni kwamba uthibitisho unaweza kuthibitisha uthibitisho mwingine. Kwa mfano, ZK-SNARK moja inaweza kuthibitisha ZK-SNARKs zingine. "Uthibitisho wa uthibitisho" kama huo huitwa uthibitisho wa kurudia na huongeza kwa kiasi kikubwa uwezo wa usindikaji kwenye unda-mpya za ZK.
+
+Hivi sasa, uthibitisho wa uhalali hutolewa kwa msingi wa bloku kwa bloku na huwasilishwa kwa mkataba wa L1 kwa ajili ya uthibitishaji. Hata hivyo, kuthibitisha uthibitisho wa bloku moja huweka kikomo cha uwezo wa usindikaji ambao unda-mpya za ZK zinaweza kufikia kwani bloku moja tu inaweza kukamilishwa wakati mwendeshaji anawasilisha uthibitisho.
+
+Uthibitisho wa kurudia, hata hivyo, hufanya iwezekanavyo kukamilisha bloku kadhaa kwa uthibitisho mmoja wa uhalali. Hii ni kwa sababu mzunguko wa kuthibitisha huunganisha kwa kurudia uthibitisho wa bloku nyingi hadi uthibitisho mmoja wa mwisho utakapoundwa. Mwendeshaji wa L2 huwasilisha uthibitisho huu wa kurudia, na ikiwa mkataba utaukubali, bloku zote husika zitakamilishwa mara moja. Kwa uthibitisho wa kurudia, idadi ya miamala ya unda-mpya ya ZK inayoweza kukamilishwa kwenye Ethereum kwa vipindi huongezeka.
+
+### Faida na hasara za unda-mpya za ZK {#zk-rollups-pros-and-cons}
+
+| Faida | Hasara |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Uthibitisho wa uhalali huhakikisha usahihi wa miamala ya nje ya mnyororo na kuzuia waendeshaji kutekeleza mabadiliko batili ya hali. | Gharama inayohusishwa na kukokotoa na kuthibitisha uthibitisho wa uhalali ni kubwa na inaweza kuongeza ada kwa watumiaji wa unda-mpya. |
+| Hutoa umisho wa haraka wa muamala kwani masasisho ya hali yanaidhinishwa mara tu uthibitisho wa uhalali unapothibitishwa kwenye L1. | Kujenga unda-mpya za ZK zinazoendana na EVM ni ngumu kutokana na ugumu wa teknolojia ya zero-knowledge. |
+| Hutegemea mifumo ya kiroptografia isiyo na uaminifu kwa usalama, si uaminifu wa wahusika waliohamasishwa kama ilivyo kwa [optimistic rollups](/developers/docs/scaling/optimistic-rollups/#optimistic-pros-and-cons). | Kuzalisha uthibitisho wa uhalali kunahitaji vifaa maalum, jambo ambalo linaweza kuhimiza udhibiti wa kati wa mnyororo na pande chache. |
+| Huhifadhi data inayohitajika kurejesha hali ya nje ya mnyororo kwenye L1, ambayo inahakikisha usalama, upinzani dhidi ya udhibiti, na ugatuaji. | Waendeshaji wa kati (waratibu wa mfuatano) wanaweza kuathiri mpangilio wa miamala. |
+| Watumiaji hunufaika na ufanisi mkubwa wa mtaji na wanaweza kutoa fedha kutoka L2 bila ucheleweshaji. | Mahitaji ya vifaa yanaweza kupunguza idadi ya washiriki wanaoweza kulazimisha mnyororo kufanya maendeleo, na kuongeza hatari ya waendeshaji wenye dhamira mbaya kufungia hali ya unda-mpya na kudhibiti watumiaji. |
+| Haitegemei dhana za uhai na watumiaji hawahitaji kuhalalisha mnyororo ili kulinda fedha zao. | Baadhi ya mifumo ya uthibitisho (k.m., ZK-SNARK) inahitaji usanidi unaoaminika ambao, ukitumiwa vibaya, unaweza kuhatarisha muundo wa usalama wa unda-mpya ya ZK. |
+| Ubanaji bora wa data unaweza kusaidia kupunguza gharama za kuchapisha `calldata` kwenye Ethereum na kupunguza ada za unda-mpya kwa watumiaji. | |
+
+### Maelezo ya kuona ya unda-mpya za ZK {#zk-video}
+
+Tazama Finematics ikielezea unda-mpya za ZK:
+
+
+
+## Nani anafanyia kazi zkEVM? {#zkevm-projects}
+
+Miradi inayofanyia kazi zkEVMs ni pamoja na:
+
+- **[zkEVM](https://github.com/privacy-scaling-explorations/zkevm-specs)** - _zkEVM ni mradi unaofadhiliwa na Msingi wa Ethereum kuendeleza unda-mpya ya ZK inayooana na EVM na utaratibu wa kuzalisha uthibitisho wa uhalali kwa bloku za Ethereum._
+
+- **[Polygon zkEVM](https://polygon.technology/solutions/polygon-zkevm)** - _ni unda-mpya ya ZK iliyogatuliwa kwenye mtandao mkuu wa Ethereum inayofanyia kazi Mashine Halisi ya Ethereum ya zero-knowledge (zkEVM) inayotekeleza miamala ya Ethereum kwa njia ya uwazi, ikijumuisha mikataba-erevu na uthibitisho wa zero-knowledge._
+
+- **[Scroll](https://scroll.io/blog/zkEVM)** - _Scroll ni kampuni inayoendeshwa na teknolojia inayofanyia kazi ujenzi wa Suluhisho la asili la Safu ya 2 la zkEVM kwa Ethereum._
+
+- **[Taiko](https://taiko.xyz)** - _Taiko ni unda-mpya ya ZK iliyogatuliwa, sawa na Ethereum (aina ya [Type 1 ZK-EVM](https://vitalik.eth.limo/general/2022/08/04/zkevm.html))._
+
+- **[ZKsync](https://docs.zksync.io/)** - _ZKsync Era ni unda-mpya ya ZK inayooana na EVM iliyojengwa na Matter Labs, inayotumia zkEVM yake yenyewe._
+
+- **[Starknet](https://starkware.co/starknet/)** - _StarkNet ni suluhisho la uongezwaji la safu ya 2 linalooana na EVM lililojengwa na StarkWare._
+
+- **[Morph](https://www.morphl2.io/)** - _Morph ni suluhisho la uongezwaji la unda-mpya la mseto linalotumia uthibitisho wa zk kushughulikia suala la changamoto ya hali ya Safu ya 2._
+
+- **[Linea](https://linea.build)** - _Linea ni Safu ya 2 ya zkEVM sawa na Ethereum iliyojengwa na Consensys, inayolingana kikamilifu na mfumo wa ikolojia wa Ethereum._
+
+## Masomo zaidi kuhusu unda-mpya za ZK {#further-reading-on-zk-rollups}
+
+- [Unda-mpya za Zero-Knowledge ni Nini?](https://coinmarketcap.com/alexandria/glossary/zero-knowledge-rollups)
+- [Unda-mpya za zero-knowledge ni nini?](https://alchemy.com/blog/zero-knowledge-rollups)
+- [Mwongozo wa Vitendo wa Rollups za Ethereum](https://web.archive.org/web/20241108192208/https://research.2077.xyz/the-practical-guide-to-ethereum-rollups)
+- [STARKs dhidi ya SNARKs](https://consensys.net/blog/blockchain-explained/zero-knowledge-proofs-starks-vs-snarks/)
+- [zkEVM ni nini?](https://www.alchemy.com/overviews/zkevm)
+- [Aina za ZK-EVM: Sawa na Ethereum, sawa na EVM, Aina 1, Aina 4, na maneno mengine ya siri](https://taiko.mirror.xyz/j6KgY8zbGTlTnHRFGW6ZLVPuT0IV0_KmgowgStpA0K4)
+- [Utangulizi wa zkEVM](https://hackmd.io/@yezhang/S1_KMMbGt)
+- [ZK-EVM L2s ni nini?](https://linea.mirror.xyz/qD18IaQ4BROn_Y40EBMTUTdJHYghUtdECscSWyMvm8M)
+- [Rasilimali za kushangaza za zkEVM](https://github.com/LuozhuZhang/awesome-zkevm)
+- [ZK-SNARKS chini ya kofia](https://vitalik.eth.limo/general/2017/02/01/zk_snarks.html)
+- [SNARKs zinawezekanaje?](https://vitalik.eth.limo/general/2021/01/26/snarks.html)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/anatomy/index.md b/public/content/translations/sw/developers/docs/smart-contracts/anatomy/index.md
new file mode 100644
index 00000000000..6301cc4befc
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/anatomy/index.md
@@ -0,0 +1,658 @@
+---
+title: Anatomy ya mikataba smart
+description: Uchunguzi wa kina wa anatomia ya mwasiliani mahiri - kazi, data na vigeu.
+lang: sw
+---
+
+Mkataba mzuri ni mpango unaoendeshwa kwenye anwani kwenye Ethereum. Zinajumuisha data na vipengele vinavyoweza kutekeleza unapopokea muamala. Huu hapa ni muhtasari wa kile kinachounda mkataba mzuri.
+
+## Mahitaji ya awali {#prerequisites}
+
+Hakikisha umesoma kuhusu [mikataba-erevu](/developers/docs/smart-contracts/) kwanza. Hati hii inadhania kuwa tayari unajua lugha za programu kama vile JavaScript au Python.
+
+## Data {#data}
+
+Data yoyote ya mkataba lazima ipewe eneo: ama kwa `storage` au `memory`. Ni gharama kubwa kurekebisha hifadhi katika mkataba mahiri kwa hivyo unahitaji kuzingatia mahali data yako inapaswa kuishi.
+
+### Ghala {#storage}
+
+Data endelevu inajulikana kama hifadhi na inawakilishwa na vigeu vya hali. Thamani hizi huhifadhiwa kabisa kwenye Kiambajengo. Unahitaji kutangaza aina ili mkataba uweze kufuatilia ni kiasi gani cha hifadhi kwenye Kiambajengo inahitaji wakati inapoundwa.
+
+```solidity
+// Mfano wa Solidity
+contract SimpleStorage {
+ uint storedData; // Kigezo cha Hali
+ // ...
+}
+```
+
+```python
+# Mfano wa Vyper
+storedData: int128
+```
+
+Ikiwa tayari umepanga lugha zinazoelekezwa kwa kitu, kuna uwezekano kwamba utafahamu aina nyingi. Hata hivyo, `address` inapaswa kuwa mpya kwako ikiwa wewe ni mgeni katika uendelezaji wa Ethereum.
+
+Aina ya `address` inaweza kushikilia anwani ya Ethereum ambayo ni sawa na baiti 20 au biti 160. Inarudi katika nukuu ya hexadecimal na 0x inayoongoza.
+
+Aina zingine ni pamoja na:
+
+- boolean
+- nambari kamili
+- nambari za uhakika
+- safu za baiti za ukubwa usiobadilika
+- safu za baiti zenye ukubwa unaobadilika
+- maandishi halisi ya kimantiki na nambari kamili
+- maandishi halisi ya string
+- maandishi halisi ya heksadesimali
+- enums
+
+Kwa maelezo zaidi, angalia hati:
+
+- [Tazama aina za Vyper](https://docs.vyperlang.org/en/v0.1.0-beta.6/types.html#value-types)
+- [Tazama aina za Solidity](https://docs.soliditylang.org/en/latest/types.html#value-types)
+
+### Kumbukumbu {#memory}
+
+Thamani ambazo huhifadhiwa kwa muda wote wa utendakazi wa kazi ya mkataba huitwa vigeu vya kumbukumbu. Kwa kuwa hizi hazihifadhiwa kwa kudumu kwenye Kiambajengo, ni nafuu sana kutumia.
+
+Jifunze zaidi kuhusu jinsi EVM inavyohifadhi data (Hifadhi, Kumbukumbu, na Stack) katika [nyaraka za Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#storage-memory-and-the-stack).
+
+### Vigezo vya mazingira {#environment-variables}
+
+Mbali na vigezo unavyobainisha kwenye mkataba wako, kuna baadhi ya vigezo maalum vya kimataifa. Zinatumika kimsingi kutoa habari kuhusu blockchain au shughuli ya sasa.
+
+Mifano:
+
+| **Sifa** | **Kigezo cha Hali** | **Maelezo** |
+| ----------------- | ------------------- | --------------------------------------------------- |
+| `block.timestamp` | uint256 | Muhuri wa wakati wa kipindi cha kizuizi cha sasa |
+| `msg.sender` | anuani | Mtumaji wa ujumbe (simu ya sasa) |
+
+## Kazi {#functions}
+
+Kwa maneno rahisi zaidi, chaguo za kukokotoa zinaweza kupata taarifa au kuweka taarifa kujibu miamala inayoingia.
+
+Kuna aina mbili za simu za kazi:
+
+- `internal` – hizi hazitengenezi simu ya EVM
+ - Kazi za ndani na vigezo vya hali vinaweza kufikiwa tu ndani (yaani, kutoka ndani ya mkataba wa sasa au mikataba inayotokana nayo)
+- `external` – hizi hutengeneza simu ya EVM
+ - Kazi za nje ni sehemu ya kiolesura cha mkataba, ambayo ina maana kwamba zinaweza kuitwa kutoka kwa mikataba mingine na kupitia miamala. Kazi ya nje `f` haiwezi kuitwa ndani (yaani, `f()` haifanyi kazi, lakini `this.f()` inafanya kazi).
+
+Pia zinaweza kuwa za `umma` au `faragha`
+
+- `kazi za umma` zinaweza kuitwa ndani kutoka ndani ya mkataba au nje kupitia ujumbe
+- `kazi za faragha` zinaonekana tu kwa mkataba ambapo zimefafanuliwa na si katika mikataba inayotokana
+
+Vipengele vyote viwili vya kukokotoa na vigezo vya hali vinaweza kuwekwa hadharani au kwa faragha
+
+Hapa kuna kazi ya kubadilisha utofauti wa hali kwenye mkataba:
+
+```solidity
+// Mfano wa Solidity
+function update_name(string value) public {
+ dapp_name = value;
+}
+```
+
+- Kigezo `value` cha aina ya `string` kinapitishwa kwenye kazi: `update_name`
+- Imetangazwa kuwa ya `umma`, ikimaanisha mtu yeyote anaweza kuifikia
+- Haijatangazwa `view`, hivyo inaweza kurekebisha hali ya mkataba
+
+### Kazi za kutazama {#view-functions}
+
+Kazi hizi zinaahidi kutorekebisha hali ya data ya mkataba. Mifano ya kawaida ni vitendaji vya "pata" - unaweza kutumia hii kupokea salio la mtumiaji kwa mfano.
+
+```solidity
+// Mfano wa Solidity
+function balanceOf(address _owner) public view returns (uint256 _balance) {
+ return ownerPizzaCount[_owner];
+}
+```
+
+```python
+dappName: public(string)
+
+@view
+@public
+def readName() -> string:
+ return dappName
+```
+
+Ni nini kinachozingatiwa hali ya kurekebisha:
+
+1. Kuandika vigezo kwa hali.
+2. [Kutoa matukio](https://docs.soliditylang.org/en/v0.7.0/contracts.html#events).
+3. [Kuunda mikataba mingine](https://docs.soliditylang.org/en/v0.7.0/control-structures.html#creating-contracts).
+4. Kutumia `selfdestruct`.
+5. Inatuma etha kupitia simu.
+6. Kuita kazi yoyote ambayo haijawekwa alama ya `view` au `pure`.
+7. Kutumia simu za kiwango cha chini.
+8. Kutumia mkusanyiko wa ndani ambao una opcodes fulani.
+
+### Kazi za kiunda {#constructor-functions}
+
+`kazi za kiunda` hutekelezwa mara moja tu wakati mkataba unapelekwa kwa mara ya kwanza. Kama `constructor` katika lugha nyingi za programu za msingi wa darasa, kazi hizi mara nyingi huanzisha vigezo vya hali kwa thamani zake zilizoainishwa.
+
+```solidity
+// Mfano wa Solidity
+// Huanzisha data ya mkataba, ikiweka `owner`
+// kwa anwani ya muundaji wa mkataba.
+constructor() public {
+ // Mikataba-erevu yote hutegemea miamala ya nje ili kuanzisha kazi zake.
+ // `msg` ni kigezo cha kimataifa ambacho kinajumuisha data husika kwenye muamala uliopewa,
+ // kama vile anwani ya mtumaji na thamani ya ETH iliyojumuishwa kwenye muamala.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
+ owner = msg.sender;
+}
+```
+
+```python
+# Mfano wa Vyper
+
+@external
+def __init__(_beneficiary: address, _bidding_time: uint256):
+ self.beneficiary = _beneficiary
+ self.auctionStart = block.timestamp
+ self.auctionEnd = self.auctionStart + _bidding_time
+```
+
+### Kazi zilizojengewa ndani {#built-in-functions}
+
+Kando na vigezo na chaguo za kukokotoa unazofafanua kwenye mkataba wako, kuna vitendaji maalum vilivyojumuishwa. Mfano dhahiri zaidi ni:
+
+- `address.send()` – Solidity
+- `send(address)` – Vyper
+
+Hizi huruhusu kandarasi kutuma ETH kwa akaunti zingine.
+
+## Kuandika kazi {#writing-functions}
+
+Utendaji wako unahitaji:
+
+- kutofautisha kwa paramu na aina (ikiwa inakubali vigezo)
+- tamko la ndani/nje
+- tamko la mtazamo safi/unaoweza kulipwa
+- inarudisha aina (ikiwa inarudisha thamani)
+
+```solidity
+pragma solidity >=0.4.0 <=0.6.0;
+
+contract ExampleDapp {
+ string dapp_name; // kigezo cha hali
+
+ // Inaitwa wakati mkataba unapelekwa na kuanzisha thamani
+ constructor() public {
+ dapp_name = "Mfumo wangu mtawanyo wa kimamlaka wa mfano";
+ }
+
+ // Kazi ya Kupata
+ function read_name() public view returns(string) {
+ return dapp_name;
+ }
+
+ // Kazi ya Kuweka
+ function update_name(string value) public {
+ dapp_name = value;
+ }
+}
+```
+
+Mkataba kamili unaweza kuonekana kama hii. Hapa kazi ya `constructor` inatoa thamani ya awali kwa kigezo cha `dapp_name`.
+
+## Matukio na kumbukumbu {#events-and-logs}
+
+Matukio huwezesha mkataba wako mahiri kuwasiliana na eneo lako la mbele au programu zingine za kujisajili. Baada ya muamala kuthibitishwa na kuongezwa kwenye kizuizi, mikataba mahiri inaweza kutoa matukio na kuweka taarifa, ambayo sehemu ya mbele inaweza kuchakata na kutumia.
+
+## Mifano yenye maelezo {#annotated-examples}
+
+Hii ni baadhi ya mifano iliyoandikwa katika Solidity. Ikiwa ungependa kucheza na msimbo, unaweza kuingiliana nao katika [Remix](http://remix.ethereum.org).
+
+### Habari dunia {#hello-world}
+
+```solidity
+// Inabainisha toleo la Solidity, kwa kutumia matoleo ya kimantiki.
+// Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
+pragma solidity ^0.5.10;
+
+// Inafafanua mkataba unaoitwa `HelloWorld`.
+// Mkataba ni mkusanyiko wa kazi na data (hali yake).
+// Baada ya kupelekwa, mkataba hukaa kwenye anwani maalum kwenye mnyororo wa bloku wa Ethereum.
+// Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
+contract HelloWorld {
+
+ // Inatangaza kigezo cha hali `message` cha aina ya `string`.
+ // Vigezo vya hali ni vigezo ambavyo thamani zake huhifadhiwa kabisa katika hifadhi ya mkataba.
+ // Neno muhimu `public` hufanya vigezo viweze kufikiwa kutoka nje ya mkataba
+ // na huunda kazi ambayo mikataba mingine au wateja wanaweza kuita ili kufikia thamani.
+ string public message;
+
+ // Sawa na lugha nyingi za programu za kuelekeza-vitu zenye msingi wa darasa, kiunda ni
+ // kazi maalum ambayo inatekelezwa tu wakati wa uundaji wa mkataba.
+ // Viunda hutumika kuanzisha data ya mkataba.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
+ constructor(string memory initMessage) public {
+ // Inakubali hoja ya string `initMessage` na kuweka thamani
+ // kwenye kigezo cha hifadhi cha `message` cha mkataba).
+ message = initMessage;
+ }
+
+ // Kazi ya umma inayokubali hoja ya string
+ // na inasasisha kigezo cha hifadhi cha `message`.
+ function update(string memory newMessage) public {
+ message = newMessage;
+ }
+}
+```
+
+### Token {#token}
+
+```solidity
+pragma solidity ^0.5.10;
+
+contract Token {
+ // `Anwani` inalinganishwa na anwani ya barua pepe - inatumika kutambua akaunti kwenye Ethereum.
+ // Anwani zinaweza kuwakilisha mkataba-erevu au akaunti za nje (mtumiaji).
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/types.html#address
+ address public owner;
+
+ // `mapping` kimsingi ni muundo wa data wa jedwali la hashi.
+ // `mapping` hii inapeana nambari kamili isiyo na alama (salio la tokeni) kwa anwani (mmiliki wa tokeni).
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/types.html#mapping-types
+ mapping (address => uint) public balances;
+
+ // Matukio huruhusu uwekaji kumbukumbu wa shughuli kwenye mnyororo wa bloku.
+ // Wateja wa Ethereum wanaweza kusikiliza matukio ili kujibu mabadiliko ya hali ya mkataba.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#events
+ event Transfer(address from, address to, uint amount);
+
+ // Huanzisha data ya mkataba, ikiweka `owner`
+ // kwa anwani ya muundaji wa mkataba.
+ constructor() public {
+ // Mikataba-erevu yote hutegemea miamala ya nje ili kuanzisha kazi zake.
+ // `msg` ni kigezo cha kimataifa ambacho kinajumuisha data husika kwenye muamala uliopewa,
+ // kama vile anwani ya mtumaji na thamani ya ETH iliyojumuishwa kwenye muamala.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/units-and-global-variables.html#block-and-transaction-properties
+ owner = msg.sender;
+ }
+
+ // Huunda kiasi cha tokeni mpya na kuzituma kwa anwani.
+ function mint(address receiver, uint amount) public {
+ // `require` ni muundo wa udhibiti unaotumika kutekeleza masharti fulani.
+ // Ikiwa taarifa ya `require` itatathminiwa kuwa `false`, ubaguzi husababishwa,
+ // ambayo hubatilisha mabadiliko yote yaliyofanywa kwa hali wakati wa wito wa sasa.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
+
+ // Mmiliki wa mkataba pekee ndiye anayeweza kuita kazi hii
+ require(msg.sender == owner, "Wewe si mmiliki.");
+
+ // Inatekeleza kiasi cha juu cha tokeni
+ require(amount < 1e60, "Utoaji wa juu umezidi");
+
+ // Huongeza salio la `receiver` kwa `amount`
+ balances[receiver] += amount;
+ }
+
+ // Hutuma kiasi cha tokeni zilizopo kutoka kwa mpigaji simu yeyote kwenda kwa anwani.
+ function transfer(address receiver, uint amount) public {
+ // Mtumaji lazima awe na tokeni za kutosha kutuma
+ require(amount <= balances[msg.sender], "Salio halitoshi.");
+
+ // Hurekebisha salio la tokeni za anwani mbili
+ balances[msg.sender] -= amount;
+ balances[receiver] += amount;
+
+ // Hutoa tukio lililofafanuliwa mapema
+ emit Transfer(msg.sender, receiver, amount);
+ }
+}
+```
+
+### Mali ya kipekee ya kidijitali {#unique-digital-asset}
+
+```solidity
+pragma solidity ^0.5.10;
+
+// Huingiza alama kutoka faili zingine kwenye mkataba wa sasa.
+// Katika kesi hii, mfululizo wa mikataba msaidizi kutoka OpenZeppelin.
+// Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#importing-other-source-files
+
+import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import "../node_modules/@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
+import "../node_modules/@openzeppelin/contracts/introspection/ERC165.sol";
+import "../node_modules/@openzeppelin/contracts/math/SafeMath.sol";
+
+// Neno muhimu `is` hutumika kurithi kazi na maneno muhimu kutoka kwa mikataba ya nje.
+// Katika kesi hii, `CryptoPizza` inarithi kutoka kwa mikataba ya `IERC721` na `ERC165`.
+// Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#inheritance
+contract CryptoPizza is IERC721, ERC165 {
+ // Hutumia maktaba ya SafeMath ya OpenZeppelin kufanya shughuli za hesabu kwa usalama.
+ // Jifunze zaidi: https://docs.openzeppelin.com/contracts/2.x/api/math#SafeMath
+ using SafeMath for uint256;
+
+ // Vigezo vya hali vya kudumu katika Solidity ni sawa na lugha zingine
+ // lakini lazima upeane kutoka kwa usemi ambao ni wa kudumu wakati wa kukusanya.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constant-state-variables
+ uint256 constant dnaDigits = 10;
+ uint256 constant dnaModulus = 10 ** dnaDigits;
+ bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
+
+ // Aina za muundo hukuruhusu kufafanua aina yako mwenyewe
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/types.html#structs
+ struct Pizza {
+ string name;
+ uint256 dna;
+ }
+
+ // Huunda safu tupu ya miundo ya Pizza
+ Pizza[] public pizzas;
+
+ // Upangaji kutoka ID ya pizza hadi anwani ya mmiliki wake
+ mapping(uint256 => address) public pizzaToOwner;
+
+ // Upangaji kutoka anwani ya mmiliki hadi idadi ya tokeni inayomilikiwa
+ mapping(address => uint256) public ownerPizzaCount;
+
+ // Upangaji kutoka ID ya tokeni hadi anwani iliyoidhinishwa
+ mapping(uint256 => address) pizzaApprovals;
+
+ // Unaweza kuweka upangaji, mfano huu unapanga mmiliki kwa idhini za mendeshaji
+ mapping(address => mapping(address => bool)) private operatorApprovals;
+
+ // Kazi ya ndani ya kuunda Pizza nasibu kutoka kwa string (jina) na DNA
+ function _createPizza(string memory _name, uint256 _dna)
+ // Neno muhimu `internal` linamaanisha kazi hii inaonekana tu
+ // ndani ya mkataba huu na mikataba inayotokana na mkataba huu
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#visibility-and-getters
+ internal
+ // `isUnique` ni kirekebishaji cha kazi kinachokagua ikiwa pizza tayari ipo
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html#function-modifiers
+ isUnique(_name, _dna)
+ {
+ // Huongeza Pizza kwenye safu ya Piza na kupata id
+ uint256 id = SafeMath.sub(pizzas.push(Pizza(_name, _dna)), 1);
+
+ // Hukagua kwamba mmiliki wa Pizza ni sawa na mtumiaji wa sasa
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/control-structures.html#error-handling-assert-require-revert-and-exceptions
+
+ // kumbuka kuwa address(0) ni anwani sifuri,
+ // ikionyesha kuwa pizza[id] bado haijatengewa mtumiaji fulani.
+
+ assert(pizzaToOwner[id] == address(0));
+
+ // Inapanga Pizza kwa mmiliki
+ pizzaToOwner[id] = msg.sender;
+ ownerPizzaCount[msg.sender] = SafeMath.add(
+ ownerPizzaCount[msg.sender],
+ 1
+ );
+ }
+
+ // Huunda Pizza nasibu kutoka kwa string (jina)
+ function createRandomPizza(string memory _name) public {
+ uint256 randDna = generateRandomDna(_name, msg.sender);
+ _createPizza(_name, randDna);
+ }
+
+ // Huzalisha DNA nasibu kutoka kwa string (jina) na anwani ya mmiliki (muundaji)
+ function generateRandomDna(string memory _str, address _owner)
+ public
+ // Kazi zilizo na alama ya `pure` huahidi kutosoma au kurekebisha hali
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#pure-functions
+ pure
+ returns (uint256)
+ {
+ // Huzalisha uint nasibu kutoka kwa string (jina) + anwani (mmiliki)
+ uint256 rand = uint256(keccak256(abi.encodePacked(_str))) +
+ uint256(_owner);
+ rand = rand % dnaModulus;
+ return rand;
+ }
+
+ // Hurudisha safu ya Piza zilizopatikana na mmiliki
+ function getPizzasByOwner(address _owner)
+ public
+ // Kazi zilizo na alama ya `view` huahidi kurekebisha hali
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/contracts.html#view-functions
+ view
+ returns (uint256[] memory)
+ {
+ // Hutumia eneo la hifadhi la `memory` kuhifadhi thamani tu kwa
+ // mzunguko wa maisha wa wito huu wa kazi.
+ // Jifunze zaidi: https://solidity.readthedocs.io/en/v0.5.10/introduction-to-smart-contracts.html#storage-memory-and-the-stack
+ uint256[] memory result = new uint256[](ownerPizzaCount[_owner]);
+ uint256 counter = 0;
+ for (uint256 i = 0; i < pizzas.length; i++) {
+ if (pizzaToOwner[i] == _owner) {
+ result[counter] = i;
+ counter++;
+ }
+ }
+ return result;
+ }
+
+ // Huhamisha Pizza na umiliki kwa anwani nyingine
+ function transferFrom(address _from, address _to, uint256 _pizzaId) public {
+ require(_from != address(0) && _to != address(0), "Anwani batili.");
+ require(_exists(_pizzaId), "Pizza haipo.");
+ require(_from != _to, "Haiwezi kuhamisha kwa anwani ileile.");
+ require(_isApprovedOrOwner(msg.sender, _pizzaId), "Anwani haijaidhinishwa.");
+
+ ownerPizzaCount[_to] = SafeMath.add(ownerPizzaCount[_to], 1);
+ ownerPizzaCount[_from] = SafeMath.sub(ownerPizzaCount[_from], 1);
+ pizzaToOwner[_pizzaId] = _to;
+
+ // Hutoa tukio lililofafanuliwa katika mkataba wa IERC721 ulioingizwa
+ emit Transfer(_from, _to, _pizzaId);
+ _clearApproval(_to, _pizzaId);
+ }
+
+ /**
+ * Huhamisha umiliki wa ID ya tokeni fulani kwa usalama kwenda kwa anwani nyingine
+ * Ikiwa anwani lengwa ni mkataba, lazima itekeleze `onERC721Received`,
+ * ambayo inaitwa wakati wa uhamisho salama, na kurudisha thamani ya kichawi
+ * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`;
+ * vinginevyo, uhamisho unabatilishwa.
+ */
+ function safeTransferFrom(address from, address to, uint256 pizzaId)
+ public
+ {
+ // solium-disable-next-line arg-overflow
+ this.safeTransferFrom(from, to, pizzaId, "");
+ }
+
+ /**
+ * Huhamisha umiliki wa ID ya tokeni fulani kwa usalama kwenda kwa anwani nyingine
+ * Ikiwa anwani lengwa ni mkataba, lazima itekeleze `onERC721Received`,
+ * ambayo inaitwa wakati wa uhamisho salama, na kurudisha thamani ya kichawi
+ * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`;
+ * vinginevyo, uhamisho unabatilishwa.
+ */
+ function safeTransferFrom(
+ address from,
+ address to,
+ uint256 pizzaId,
+ bytes memory _data
+ ) public {
+ this.transferFrom(from, to, pizzaId);
+ require(_checkOnERC721Received(from, to, pizzaId, _data), "Lazima utekeleze onERC721Received.");
+ }
+
+ /**
+ * Kazi ya ndani ya kuita `onERC721Received` kwenye anwani lengwa
+ * Wito hautekelezwi ikiwa anwani lengwa si mkataba
+ */
+ function _checkOnERC721Received(
+ address from,
+ address to,
+ uint256 pizzaId,
+ bytes memory _data
+ ) internal returns (bool) {
+ if (!isContract(to)) {
+ return true;
+ }
+
+ bytes4 retval = IERC721Receiver(to).onERC721Received(
+ msg.sender,
+ from,
+ pizzaId,
+ _data
+ );
+ return (retval == _ERC721_RECEIVED);
+ }
+
+ // Huchoma Pizza - huharibu Tokeni kabisa
+ // Kirekebishaji cha kazi cha `external` kinamaanisha kazi hii ni
+ // sehemu ya kiolesura cha mkataba na mikataba mingine inaweza kuiita
+ function burn(uint256 _pizzaId) external {
+ require(msg.sender != address(0), "Anwani batili.");
+ require(_exists(_pizzaId), "Pizza haipo.");
+ require(_isApprovedOrOwner(msg.sender, _pizzaId), "Anwani haijaidhinishwa.");
+
+ ownerPizzaCount[msg.sender] = SafeMath.sub(
+ ownerPizzaCount[msg.sender],
+ 1
+ );
+ pizzaToOwner[_pizzaId] = address(0);
+ }
+
+ // Hurudisha hesabu ya Piza kwa anwani
+ function balanceOf(address _owner) public view returns (uint256 _balance) {
+ return ownerPizzaCount[_owner];
+ }
+
+ // Hurudisha mmiliki wa Pizza iliyopatikana kwa id
+ function ownerOf(uint256 _pizzaId) public view returns (address _owner) {
+ address owner = pizzaToOwner[_pizzaId];
+ require(owner != address(0), "ID ya Pizza batili.");
+ return owner;
+ }
+
+ // Huidhinisha anwani nyingine kuhamisha umiliki wa Pizza
+ function approve(address _to, uint256 _pizzaId) public {
+ require(msg.sender == pizzaToOwner[_pizzaId], "Lazima uwe mmiliki wa Pizza.");
+ pizzaApprovals[_pizzaId] = _to;
+ emit Approval(msg.sender, _to, _pizzaId);
+ }
+
+ // Hurudisha anwani iliyoidhinishwa kwa Pizza maalum
+ function getApproved(uint256 _pizzaId)
+ public
+ view
+ returns (address operator)
+ {
+ require(_exists(_pizzaId), "Pizza haipo.");
+ return pizzaApprovals[_pizzaId];
+ }
+
+ /**
+ * Kazi ya faragha ya kufuta idhini ya sasa ya ID ya tokeni fulani
+ * Hubatilisha ikiwa anwani iliyotolewa si kweli mmiliki wa tokeni
+ */
+ function _clearApproval(address owner, uint256 _pizzaId) private {
+ require(pizzaToOwner[_pizzaId] == owner, "Lazima uwe mmiliki wa pizza.");
+ require(_exists(_pizzaId), "Pizza haipo.");
+ if (pizzaApprovals[_pizzaId] != address(0)) {
+ pizzaApprovals[_pizzaId] = address(0);
+ }
+ }
+
+ /*
+ * Huweka au huondoa idhini ya mendeshaji fulani
+ * Mendeshaji anaruhusiwa kuhamisha tokeni zote za mtumaji kwa niaba yake
+ */
+ function setApprovalForAll(address to, bool approved) public {
+ require(to != msg.sender, "Haiwezi kuidhinisha anwani mwenyewe");
+ operatorApprovals[msg.sender][to] = approved;
+ emit ApprovalForAll(msg.sender, to, approved);
+ }
+
+ // Husema ikiwa mendeshaji ameidhinishwa na mmiliki fulani
+ function isApprovedForAll(address owner, address operator)
+ public
+ view
+ returns (bool)
+ {
+ return operatorApprovals[owner][operator];
+ }
+
+ // Huchukua umiliki wa Pizza - kwa watumiaji walioidhinishwa pekee
+ function takeOwnership(uint256 _pizzaId) public {
+ require(_isApprovedOrOwner(msg.sender, _pizzaId), "Anwani haijaidhinishwa.");
+ address owner = this.ownerOf(_pizzaId);
+ this.transferFrom(owner, msg.sender, _pizzaId);
+ }
+
+ // Hukagua ikiwa Pizza ipo
+ function _exists(uint256 pizzaId) internal view returns (bool) {
+ address owner = pizzaToOwner[pizzaId];
+ return owner != address(0);
+ }
+
+ // Hukagua ikiwa anwani ni mmiliki au imeidhinishwa kuhamisha Pizza
+ function _isApprovedOrOwner(address spender, uint256 pizzaId)
+ internal
+ view
+ returns (bool)
+ {
+ address owner = pizzaToOwner[pizzaId];
+ // Lemaza ukaguzi wa solium kwa sababu ya
+ // https://github.com/duaraghav8/Solium/issues/175
+ // solium-disable-next-line operator-whitespace
+ return (spender == owner ||
+ this.getApproved(pizzaId) == spender ||
+ this.isApprovedForAll(owner, spender));
+ }
+
+ // Kagua ikiwa Pizza ni ya kipekee na bado haipo
+ modifier isUnique(string memory _name, uint256 _dna) {
+ bool result = true;
+ for (uint256 i = 0; i < pizzas.length; i++) {
+ if (
+ keccak256(abi.encodePacked(pizzas[i].name)) ==
+ keccak256(abi.encodePacked(_name)) &&
+ pizzas[i].dna == _dna
+ ) {
+ result = false;
+ }
+ }
+ require(result, "Pizza yenye jina kama hilo tayari ipo.");
+ _;
+ }
+
+ // Hurudisha ikiwa anwani lengwa ni mkataba
+ function isContract(address account) internal view returns (bool) {
+ uint256 size;
+ // Kwa sasa hakuna njia bora ya kuangalia kama kuna mkataba katika anwani
+ // kuliko kuangalia ukubwa wa msimbo kwenye anwani hiyo.
+ // Tazama https://ethereum.stackexchange.com/a/14016/36603
+ // kwa maelezo zaidi kuhusu jinsi hii inavyofanya kazi.
+ // TODO Kagua hili tena kabla ya toleo la Serenity, kwa sababu anwani zote zitakuwa
+ // mikataba basi.
+ // solium-disable-next-line security/no-inline-assembly
+ assembly {
+ size := extcodesize(account)
+ }
+ return size > 0;
+ }
+}
+```
+
+## Masomo zaidi {#further-reading}
+
+Angalia nyaraka za Solidity na Vyper kwa muhtasari kamili zaidi wa mikataba mahiri:
+
+- [Solidity](https://docs.soliditylang.org/)
+- [Vyper](https://docs.vyperlang.org/en/stable/)
+
+## Mada zinazohusiana {#related-topics}
+
+- [Mikataba-erevu](/developers/docs/smart-contracts/)
+- [Mashine Halisi ya Ethereum](/developers/docs/evm/)
+
+## Mafunzo yanayohusiana {#related-tutorials}
+
+- [Kupunguza mikataba ili kupambana na kikomo cha ukubwa wa mkataba](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _– Baadhi ya vidokezo vya vitendo vya kupunguza ukubwa wa mkataba wako mahiri._
+- [Kuweka kumbukumbu ya data kutoka kwa mikataba mahiri na matukio](/developers/tutorials/logging-events-smart-contracts/) _– Utangulizi wa matukio ya mkataba mahiri na jinsi unavyoweza kuyatumia kuweka kumbukumbu ya data._
+- [Kuingiliana na mikataba mingine kutoka Solidity](/developers/tutorials/interact-with-other-contracts-from-solidity/) _– Jinsi ya kupeleka mkataba mahiri kutoka kwa mkataba uliopo na kuingiliana nao._
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/compiling/index.md b/public/content/translations/sw/developers/docs/smart-contracts/compiling/index.md
new file mode 100644
index 00000000000..5d1a725a4ec
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/compiling/index.md
@@ -0,0 +1,282 @@
+---
+title: Kuandaa smart contracts
+description: Ufafanuzi wa kwa nini unahitaji kuandaa mikataba-erevu na kile ambacho uandaaji hufanya.
+lang: sw
+incomplete: true
+---
+
+Unahitaji kuandaa mkataba wako ili programu yako ya wavuti na Mashine ya mtandaoni ya Ethereum (EVM) iweze kuuelewa.
+
+## Mahitaji ya awali {#prerequisites}
+
+Huenda ikawa na manufaa kwako kuwa umesoma utangulizi wetu wa [mikataba-erevu](/developers/docs/smart-contracts/) na [Mashine ya mtandaoni ya Ethereum](/developers/docs/evm/) kabla ya kusoma kuhusu uandaaji.
+
+## EVM {#the-evm}
+
+Ili [EVM](/developers/docs/evm/) iweze kutekeleza mkataba wako, inahitaji kuwa katika **bytecode**. Uandaaji hubadilisha hii:
+
+```solidity
+pragma solidity 0.4.24;
+
+contract Greeter {
+
+ function greet() public view returns (string memory) {
+ return "Hello";
+ }
+
+}
+```
+
+**na kuwa hii**
+
+```
+PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH2 0x41 JUMPI PUSH1 0x0 CALLDATALOAD PUSH29 0x100000000000000000000000000000000000000000000000000000000 SWAP1 DIV PUSH4 0xFFFFFFFF AND DUP1 PUSH4 0xCFAE3217 EQ PUSH2 0x46 JUMPI JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST CALLVALUE DUP1 ISZERO PUSH2 0x52 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH2 0x5B PUSH2 0xD6 JUMP JUMPDEST PUSH1 0x40 MLOAD DUP1 DUP1 PUSH1 0x20 ADD DUP3 DUP2 SUB DUP3 MSTORE DUP4 DUP2 DUP2 MLOAD DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP DUP1 MLOAD SWAP1 PUSH1 0x20 ADD SWAP1 DUP1 DUP4 DUP4 PUSH1 0x0 JUMPDEST DUP4 DUP2 LT ISZERO PUSH2 0x9B JUMPI DUP1 DUP3 ADD MLOAD DUP2 DUP5 ADD MSTORE PUSH1 0x20 DUP2 ADD SWAP1 POP PUSH2 0x80 JUMP JUMPDEST POP POP POP POP SWAP1 POP SWAP1 DUP2 ADD SWAP1 PUSH1 0x1F AND DUP1 ISZERO PUSH2 0xC8 JUMPI DUP1 DUP3 SUB DUP1 MLOAD PUSH1 0x1 DUP4 PUSH1 0x20 SUB PUSH2 0x100 EXP SUB NOT AND DUP2 MSTORE PUSH1 0x20 ADD SWAP2 POP JUMPDEST POP SWAP3 POP POP POP PUSH1 0x40 MLOAD DUP1 SWAP2 SUB SWAP1 RETURN JUMPDEST PUSH1 0x60 PUSH1 0x40 DUP1 MLOAD SWAP1 DUP2 ADD PUSH1 0x40 MSTORE DUP1 PUSH1 0x5 DUP2 MSTORE PUSH1 0x20 ADD PUSH32 0x48656C6C6F000000000000000000000000000000000000000000000000000000 DUP2 MSTORE POP SWAP1 POP SWAP1 JUMP STOP LOG1 PUSH6 0x627A7A723058 KECCAK256 SLT 0xec 0xe 0xf5 0xf8 SLT 0xc7 0x2d STATICCALL ADDRESS SHR 0xdb COINBASE 0xb1 BALANCE 0xe8 0xf8 DUP14 0xda 0xad DUP13 LOG1 0x4c 0xb4 0x26 0xc2 DELEGATECALL PUSH7 0x8994D3E002900
+```
+
+Hizi huitwa **opcodes**. Opcodes za EVM ni maelekezo ya kiwango cha chini ambayo Mashine ya mtandaoni ya Ethereum (EVM) inaweza kutekeleza. Kila opcode inawakilisha operesheni maalum, kama vile operesheni za hesabu, operesheni za kimantiki, upotoshaji wa data, mtiririko wa udhibiti, n.k.
+
+[Zaidi kuhusu opcodes](/developers/docs/evm/opcodes/)
+
+## Programu za wavuti {#web-applications}
+
+Kiandaaji pia kitatoa **Kiolesura cha Binary cha Programu (ABI)** ambacho unahitaji ili programu yako ielewe mkataba na kuita utendaji wa mkataba.
+
+ABI ni faili ya JSON inayoelezea mkataba uliotumwa na utendaji wake wa mkataba-erevu. Hii husaidia kuziba pengo kati ya web2 na web3
+
+[Library ya wateja ya JavaScript](/developers/docs/apis/javascript/) itasoma **ABI** ili uweze kuita mkataba-erevu wako katika kiolesura cha programu yako ya wavuti.
+
+Ifuatayo ni ABI ya mkataba wa tokeni ya ERC-20. ERC-20 ni tokeni ambayo unaweza kufanya biashara nayo kwenye Ethereum.
+
+```json
+[
+ {
+ "constant": true,
+ "inputs": [],
+ "name": "name",
+ "outputs": [
+ {
+ "name": "",
+ "type": "string"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "constant": false,
+ "inputs": [
+ {
+ "name": "_spender",
+ "type": "address"
+ },
+ {
+ "name": "_value",
+ "type": "uint256"
+ }
+ ],
+ "name": "approve",
+ "outputs": [
+ {
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "constant": true,
+ "inputs": [],
+ "name": "totalSupply",
+ "outputs": [
+ {
+ "name": "",
+ "type": "uint256"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "constant": false,
+ "inputs": [
+ {
+ "name": "_from",
+ "type": "address"
+ },
+ {
+ "name": "_to",
+ "type": "address"
+ },
+ {
+ "name": "_value",
+ "type": "uint256"
+ }
+ ],
+ "name": "transferFrom",
+ "outputs": [
+ {
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "constant": true,
+ "inputs": [],
+ "name": "decimals",
+ "outputs": [
+ {
+ "name": "",
+ "type": "uint8"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "constant": true,
+ "inputs": [
+ {
+ "name": "_owner",
+ "type": "address"
+ }
+ ],
+ "name": "balanceOf",
+ "outputs": [
+ {
+ "name": "balance",
+ "type": "uint256"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "constant": true,
+ "inputs": [],
+ "name": "symbol",
+ "outputs": [
+ {
+ "name": "",
+ "type": "string"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "constant": false,
+ "inputs": [
+ {
+ "name": "_to",
+ "type": "address"
+ },
+ {
+ "name": "_value",
+ "type": "uint256"
+ }
+ ],
+ "name": "transfer",
+ "outputs": [
+ {
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "constant": true,
+ "inputs": [
+ {
+ "name": "_owner",
+ "type": "address"
+ },
+ {
+ "name": "_spender",
+ "type": "address"
+ }
+ ],
+ "name": "allowance",
+ "outputs": [
+ {
+ "name": "",
+ "type": "uint256"
+ }
+ ],
+ "payable": false,
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
+ "payable": true,
+ "stateMutability": "payable",
+ "type": "fallback"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": true,
+ "name": "owner",
+ "type": "address"
+ },
+ {
+ "indexed": true,
+ "name": "spender",
+ "type": "address"
+ },
+ {
+ "indexed": false,
+ "name": "value",
+ "type": "uint256"
+ }
+ ],
+ "name": "Approval",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": true,
+ "name": "from",
+ "type": "address"
+ },
+ {
+ "indexed": true,
+ "name": "to",
+ "type": "address"
+ },
+ {
+ "indexed": false,
+ "name": "value",
+ "type": "uint256"
+ }
+ ],
+ "name": "Transfer",
+ "type": "event"
+ }
+]
+```
+
+## Masomo zaidi {#further-reading}
+
+- [Maelezo ya ABI](https://solidity.readthedocs.io/en/v0.7.0/abi-spec.html) _– Solidity_
+
+## Mada zinazohusiana {#related-topics}
+
+- [Libraries za wateja za JavaScript](/developers/docs/apis/javascript/)
+- [Mashine ya mtandaoni ya Ethereum](/developers/docs/evm/)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/composability/index.md b/public/content/translations/sw/developers/docs/smart-contracts/composability/index.md
new file mode 100644
index 00000000000..0659521d2c1
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/composability/index.md
@@ -0,0 +1,76 @@
+---
+title: Uundikaji wa mkataba-erevu
+description: Jifunze jinsi mikataba-erevu inavyoweza kuunganishwa kama bloku za Lego ili kuunda dapps changamano kwa kutumia tena vijenzi vilivyopo.
+lang: sw
+incomplete: true
+---
+
+## Utangulizi mfupi {#a-brief-introduction}
+
+Mikataba-erevu ni ya umma kwenye Ethereum na inaweza kufikiriwa kama API zilizo wazi. Huhitaji kuandika mkataba-erevu wako mwenyewe ili kuwa msanidi programu wa dapp, unahitaji tu kujua jinsi ya kuingiliana nao. Kwa mfano, unaweza kutumia mikataba-erevu iliyopo ya [Uniswap](https://uniswap.exchange/swap), exchange ya ugatuzi, kushughulikia mantiki yote ya ubadilishaji wa tokeni katika programu yako – huhitaji kuanza kutoka mwanzo. Angalia baadhi ya mikataba yao ya [v2](https://github.com/Uniswap/uniswap-v2-core/tree/master/contracts) na [v3](https://github.com/Uniswap/uniswap-v3-core/tree/main/contracts).
+
+## Uundikaji ni nini? {#what-is-composability}
+
+Uundikaji ni kuunganisha vijenzi tofauti ili kuunda mifumo au matokeo mapya. Katika usanidi wa programu, uundikaji unamaanisha wasanidi programu wanaweza kutumia tena vijenzi vya programu vilivyopo ili kuunda programu mpya. Njia nzuri ya kuelewa uundikaji ni kufikiria vijenzi vinavyoundika kama bloku za Lego. Kila Lego inaweza kuunganishwa na nyingine, kukuruhusu kujenga miundo tata kwa kuunganisha Lego tofauti.
+
+Katika Ethereum, kila mkataba-erevu ni kama Lego—unaweza kutumia mikataba-erevu kutoka kwa miradi mingine kama bloku za ujenzi za mradi wako. Hii inamaanisha si lazima utumie muda kugundua upya gurudumu au kujenga kutoka mwanzo.
+
+## Uundikaji hufanyaje kazi? {#how-does-composability-work}
+
+Mikataba-erevu ya Ethereum ni kama API za umma, kwa hivyo mtu yeyote anaweza kuingiliana na mkataba au kuijumuisha kwenye dapps kwa utendakazi ulioongezwa. Uundikaji wa mkataba-erevu kwa ujumla hufanya kazi kwa kanuni tatu: umodula, uhuru, na ugundulikaji:
+
+**1. Umodula**: Huu ni uwezo wa vijenzi binafsi kutekeleza kazi maalum. Katika Ethereum, kila mkataba-erevu una kesi maalum ya utumiaji (kama inavyoonyeshwa kwenye mfano wa Uniswap).
+
+**2. Uhuru**: Vijenzi vinavyoundika lazima viweze kufanya kazi kwa kujitegemea. Kila mkataba-erevu katika Ethereum unajitekeleza na unaweza kufanya kazi bila kutegemea sehemu zingine za mfumo.
+
+**3. Ugundulikaji**: Wasanidi programu hawawezi kuita mikataba ya nje au kuunganisha maktaba za programu katika programu ikiwa hazipatikani kwa umma. Kwa muundo, mikataba-erevu ni chanzo-wazi; mtu yeyote anaweza kuita mkataba-erevu au kufanya mgawanyiko wa msimbo.
+
+## Faida za uundikaji {#benefits-of-composability}
+
+### Mzunguko mfupi wa usanidi {#shorter-development-cycle}
+
+Uundikaji hupunguza kazi ambayo wasanidi programu wanapaswa kufanya wakati wa kuunda [dapps](/apps/#what-are-dapps). [Kama anavyosema Naval Ravikant:](https://twitter.com/naval/status/1444366754650656770) "Chanzo-wazi inamaanisha kila tatizo linapaswa kutatuliwa mara moja."
+
+Ikiwa kuna mkataba-erevu unaotatua tatizo moja, wasanidi programu wengine wanaweza kuutumia tena, kwa hivyo si lazima watatue tatizo lile lile. Kwa njia hii, wasanidi programu wanaweza kuchukua maktaba zilizopo za programu na kuongeza utendakazi wa ziada ili kuunda dapps mpya.
+
+### Ubunifu mkuu {#greater-innovation}
+
+Uundikaji unahimiza uvumbuzi na majaribio kwa sababu wasanidi programu wako huru kutumia tena, kurekebisha, kunakili, au kuunganisha msimbo wa chanzo-wazi ili kuunda matokeo yanayohitajika. Matokeo yake, timu za usanidi hutumia muda mchache kwenye utendakazi wa msingi na zinaweza kutenga muda zaidi kujaribu vipengele vipya.
+
+### Uzoefu bora wa mtumiaji {#better-user-experience}
+
+Utangamano kati ya vijenzi vya mfumo ikolojia wa Ethereum huboresha uzoefu wa mtumiaji. Watumiaji wanaweza kufikia utendakazi mkuu wakati dapps zinapounganisha mikataba-erevu ya nje kuliko katika mfumo ikolojia uliogawanyika ambapo programu haziwezi kuwasiliana.
+
+Tutatumia mfano kutoka kwa biashara ya arbitraji ili kuonyesha manufaa ya utangamano:
+
+Ikiwa tokeni inauzwa kwa bei ya juu kwenye `exchange A` kuliko `exchange B`, unaweza kutumia tofauti ya bei kupata faida. Hata hivyo, unaweza kufanya hivyo tu ikiwa una mtaji wa kutosha kufadhili muamala (yaani, kununua tokeni kutoka `exchange B` na kuiuza kwenye `exchange A`).
+
+Katika hali ambapo huna fedha za kutosha kulipia biashara, mkopo wa haraka unaweza kuwa bora. [Mikopo ya haraka](/defi/#flash-loans) ni ya kiufundi sana, lakini wazo la msingi ni kwamba unaweza kukopa mali (bila dhamana) na kuirejesha ndani ya muamala _mmoja_.
+
+Tukirejea kwenye mfano wetu wa awali, mfanyabiashara wa arbitraji anaweza kuchukua mkopo mkubwa wa haraka, kununua tokeni kutoka `exchange B`, kuziuza kwenye `exchange A`, kulipa mtaji + riba, na kubaki na faida, yote ndani ya muamala mmoja. Mantiki hii changamano inahitaji kuchanganya wito kwa mikataba mingi, jambo ambalo lisingewezekana kama mikataba-erevu ingekosa utangamano.
+
+## Mifano ya uundikaji katika Ethereum {#composability-in-ethereum}
+
+### Kubadilisha tokeni {#token-swaps}
+
+Ukitengeneza dapp inayohitaji miamala kulipwa kwa ETH, unaweza kuwaruhusu watumiaji kulipa kwa tokeni zingine za ERC-20 kwa kuunganisha mantiki ya ubadilishaji wa tokeni. Msimbo utabadilisha kiotomatiki tokeni ya mtumiaji kuwa ETH kabla ya mkataba kutekeleza kitendakazi kilichoitwa.
+
+### Utawala {#governance}
+
+Kujenga mifumo ya utawala maalum kwa [DAO](/dao/) kunaweza kuwa ghali na kuchukua muda. Badala yake, unaweza kutumia zana ya utawala ya chanzo-wazi, kama vile [Aragon Client](https://client.aragon.org/), ili kuanzisha DAO yako na kuunda haraka mfumo wa utawala.
+
+### Usimamizi wa utambulisho {#identity-management}
+
+Badala ya kuunda mfumo maalum wa uthibitishaji au kutegemea watoa huduma wa kati, unaweza kuunganisha zana za utambulisho uliogatuliwa (DID) ili kudhibiti uthibitishaji kwa watumiaji. Mfano ni [SpruceID](https://www.spruceid.com/), zana ya chanzo-wazi ambayo inatoa utendakazi wa "Ingia na Ethereum" unaowaruhusu watumiaji kuthibitisha utambulisho na pochi ya Ethereum.
+
+## Mafunzo yanayohusiana {#related-tutorials}
+
+- [Anzisha usanidi wako wa frontend wa dapp na create-eth-app](/developers/tutorials/kickstart-your-dapp-frontend-development-with-create-eth-app/) _– Muhtasari wa jinsi ya kutumia create-eth-app kuunda programu zenye mikataba-erevu maarufu tayari kwa matumizi._
+
+## Masomo zaidi {#further-reading}
+
+_Unajua rasilimali ya jamii iliyokusaidia?_ Hariri ukurasa huu na uiongeze!_
+
+- [Uundikaji ni Ubunifu](https://a16zcrypto.com/posts/article/how-composability-unlocks-crypto-and-everything-else/)
+- [Kwa Nini Uundikaji ni Muhimu kwa Web3](https://hackernoon.com/why-composability-matters-for-web3)
+- [Uundikaji ni Nini?](https://blog.aragon.org/what-is-composability/#:~:text=Aragon,connect%20to%20every%20other%20piece.)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/deploying/index.md b/public/content/translations/sw/developers/docs/smart-contracts/deploying/index.md
new file mode 100644
index 00000000000..4b5300886e1
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/deploying/index.md
@@ -0,0 +1,81 @@
+---
+title: Kupeleka mikataba erevu
+description: Jifunze jinsi ya kupeleka mikataba-erevu kwenye mitandao ya Ethereum, ikiwa ni pamoja na mahitaji ya lazima, zana, na hatua za upelekaji.
+lang: sw
+---
+
+Unahitaji kupeleka mkataba wako-erevu ili uweze kupatikana kwa watumiaji wa mtandao wa Ethereum.
+
+Ili kupeleka mkataba-erevu, unahitaji tu kutuma muamala wa Ethereum wenye msimbo ulioandaliwa wa mkataba-erevu bila kubainisha mpokeaji yeyote.
+
+## Mahitaji ya awali {#prerequisites}
+
+Unapaswa kuelewa [mitandao ya Ethereum](/developers/docs/networks/), [miamala](/developers/docs/transactions/) na [muundo wa mikataba-erevu](/developers/docs/smart-contracts/anatomy/) kabla ya kupeleka mikataba-erevu.
+
+Kupeleka mkataba pia hugharimu ether (ETH) kwa kuwa huhifadhiwa kwenye mnyororo wa bloku, kwa hivyo unapaswa kufahamu [gesi na ada](/developers/docs/gas/) kwenye Ethereum.
+
+Mwisho, utahitaji kuandaa mkataba wako kabla ya kuuwasilisha, kwa hiyo hakikisha umesoma kuhusu [kuandaa mikataba-erevu](/developers/docs/smart-contracts/compiling/).
+
+## Jinsi ya kupeleka mkataba-erevu {#how-to-deploy-a-smart-contract}
+
+### Vitu utakavyohitaji {#what-youll-need}
+
+- Bytecode ya mkataba wako – hii hutengenezwa kupitia [uandaaji](/developers/docs/smart-contracts/compiling/)
+- ETH ya gesi – utaweka kikomo chako cha gesi kama miamala mingine kwa hiyo fahamu kwamba upelekaji wa mkataba unahitaji gesi nyingi zaidi kuliko uhamisho rahisi wa ETH
+- hati ya upelekaji au programu-jalizi
+- ufikiaji wa [nodi ya Ethereum](/developers/docs/nodes-and-clients/), ama kwa kuendesha yako mwenyewe, kuunganisha kwenye nodi ya umma, au kupitia ufunguo wa API kwa kutumia [huduma ya nodi](/developers/docs/nodes-and-clients/nodes-as-a-service/)
+
+### Hatua za kupeleka mkataba-erevu {#steps-to-deploy}
+
+Hatua mahususi zinazohusika zitatategemea mfumo wa usanidi unaohusika. Kwa mfano, unaweza kuangalia [nyaraka za Hardhat kuhusu kupeleka mikataba yako](https://hardhat.org/docs/tutorial/deploying) au [nyaraka za Foundry kuhusu kupeleka na kuthibitisha mkataba-erevu](https://book.getfoundry.sh/forge/deploying). Mara tu utakapowasilishwa, mkataba wako utakuwa na anwani ya Ethereum kama [akaunti](/developers/docs/accounts/) zingine na unaweza kuthibitishwa kwa kutumia [zana za uthibitishaji wa msimbo chanzo](/developers/docs/smart-contracts/verifying/#source-code-verification-tools).
+
+## Zana zinazohusiana {#related-tools}
+
+**Remix - _Remix IDE huruhusu kusanidi, kupeleka na kusimamia mikataba-erevu kwa minyororo ya bloku kama Ethereum_**
+
+- [Remix](https://remix.ethereum.org)
+
+**Tenderly - _Jukwaa la usanidi la Web3 ambalo hutoa utatuzi, uangalizi, na vizuizi vya ujenzi wa miundombinu kwa ajili ya kusanidi, kujaribu, kufuatilia na kuendesha mikataba-erevu_**
+
+- [tenderly.co](https://tenderly.co/)
+- [Nyaraka](https://docs.tenderly.co/)
+- [GitHub](https://github.com/Tenderly)
+- [Discord](https://discord.gg/eCWjuvt)
+
+**Hardhat - _Mazingira ya usanidi ya kuandaa, kupeleka, kujaribu na kutatua programu yako ya Ethereum_**
+
+- [hardhat.org](https://hardhat.org/getting-started/)
+- [Nyaraka kuhusu kupeleka mikataba yako](https://hardhat.org/docs/tutorial/deploying)
+- [GitHub](https://github.com/nomiclabs/hardhat)
+- [Discord](https://discord.com/invite/TETZs2KK4k)
+
+**thirdweb - _Peleka mkataba wowote kwa urahisi kwenye mnyororo wowote unaoendana na EVM, kwa kutumia amri moja_**
+
+- [Nyaraka](https://portal.thirdweb.com/deploy/)
+
+**Crossmint - _Jukwaa la usanidi la web3 la kiwango cha biashara la kupeleka mikataba-erevu, kuwezesha malipo ya kadi za mkopo na mnyororo-mbali, na kutumia API kuunda, kusambaza, kuuza, kuhifadhi na kuhariri NFTs._**
+
+- [crossmint.com](https://www.crossmint.com)
+- [Nyaraka](https://docs.crossmint.com)
+- [Discord](https://discord.com/invite/crossmint)
+- [Blog](https://blog.crossmint.com)
+
+## Mafunzo yanayohusiana {#related-tutorials}
+
+- [Kupeleka mkataba wako wa kwanza-erevu](/developers/tutorials/deploying-your-first-smart-contract/) _– Utangulizi wa kupeleka mkataba wako wa kwanza-erevu kwenye mtandao wa majaribio wa Ethereum._
+- [Hello World | mafunzo ya mkataba-erevu](/developers/tutorials/hello-world-smart-contract/) _– Mafunzo rahisi kufuata ya kuunda na kupeleka mkataba-erevu wa msingi kwenye Ethereum._
+- [Kuingiliana na mikataba mingine kutoka Solidity](/developers/tutorials/interact-with-other-contracts-from-solidity/) _– Jinsi ya kupeleka mkataba mahiri kutoka kwa mkataba uliopo na kuingiliana nao._
+- [Jinsi ya kupunguza ukubwa wa mkataba wako](/developers/tutorials/downsizing-contracts-to-fight-the-contract-size-limit/) _- Jinsi ya kupunguza ukubwa wa mkataba wako ili ukae chini ya kikomo na kuokoa kwenye gesi_
+
+## Masomo zaidi {#further-reading}
+
+- [https://docs.openzeppelin.com/learn/deploying-and-interacting](https://docs.openzeppelin.com/learn/deploying-and-interacting) - _OpenZeppelin_
+- [Kupeleka mikataba yako na Hardhat](https://hardhat.org/docs/tutorial/deploying) - _Nomic Labs_
+
+_Unajua rasilimali ya jamii iliyokusaidia?_ Hariri ukurasa huu na uiongeze!_
+
+## Mada zinazohusiana {#related-topics}
+
+- [Mifumo ya uundaji](/developers/docs/frameworks/)
+- [Endesha nodi ya Ethereum](/developers/docs/nodes-and-clients/run-a-node/)
+- [Nodi-kama-huduma](/developers/docs/nodes-and-clients/nodes-as-a-service)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/formal-verification/index.md b/public/content/translations/sw/developers/docs/smart-contracts/formal-verification/index.md
new file mode 100644
index 00000000000..eb68cb4b8b8
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/formal-verification/index.md
@@ -0,0 +1,284 @@
+---
+title: Uthibitishaji rasmi wa mikataba-erevu
+description: Muhtasari wa uthibitishaji rasmi wa mikataba-erevu ya Ethereum
+lang: sw
+---
+
+[Mikataba-erevu](/developers/docs/smart-contracts/) inafanya iwezekane kuunda programu zilizogatuliwa, zisizo za kuaminika, na imara ambazo zinaleta visa-matumizi vipya na kufungua thamani kwa watumiaji. Kwa sababu mikataba mahiri hushughulikia kiasi kikubwa cha thamani, usalama ni jambo muhimu sana kwa wasanifu programu.
+
+Uthibitishaji rasmi ni moja ya mbinu zinazopendekezwa za kuboresha [usalama wa mkataba-erevu](/developers/docs/smart-contracts/security/). Uthibitishaji rasmi, ambao unatumia [mbinu rasmi](https://www.brookings.edu/techstream/formal-methods-as-a-path-toward-better-cybersecurity/) za kubainisha, kubuni, na kuthibitisha programu, umetumika kwa miaka mingi kuhakikisha usahihi wa mifumo muhimu ya maunzi na programu.
+
+Inapotekelezwa katika mikataba mahiri, uthibitishaji rasmi unaweza kuthibitisha kuwa mantiki ya biashara ya mkataba inakidhi vipimo vilivyobainishwa awali. Ikilinganishwa na mbinu nyingine za kutathmini usahihi wa msimbo wa mkataba, kama vile kupima, uthibitishaji rasmi hutoa uhakikisho mkubwa zaidi kwamba mkataba mahiri ni sahihi kiutendaji.
+
+## Uthibitishaji rasmi ni nini? {#what-is-formal-verification}
+
+Uthibitishaji rasmi unarejelea mchakato wa kutathmini usahihi wa mfumo kuhusiana na vipimo rasmi. Kwa maneno rahisi, uthibitishaji rasmi huturuhusu kuangalia ikiwa tabia ya mfumo inakidhi mahitaji fulani (yaani, inafanya tunachotaka).
+
+Tabia zinazotarajiwa za mfumo (mkataba mahiri katika kesi hii) hufafanuliwa kwa kutumia uundaji rasmi, huku lugha za ubainishi huwezesha uundaji wa sifa rasmi. Mbinu rasmi za uthibitishaji zinaweza kuthibitisha kwamba utekelezaji wa mkataba unatii vipimo vyake na kupata uthibitisho wa kihisabati wa usahihi wa mkataba wa awali. Wakati mkataba unakidhi maelezo yake, unafafanuliwa kuwa sahihi kiutendaji, sahihi kwa muundo, au "sahihi kwa ujenzi.
+
+### Mfumo rasmi ni nini? {#what-is-a-formal-model}
+
+Katika sayansi ya kompyuta, [mfumo rasmi](https://en.wikipedia.org/wiki/Model_of_computation) ni maelezo ya kihisabati ya mchakato wa kikokotozi. Vipindi vinatolewa katika vitendea kazi vya hisabati (milinganyo), huku kielelezo kikieleza jinsi matokeo ya utendaji kazi yanavyokokotolewa kutokana na ingizo.
+
+Miundo rasmi hutoa kiwango cha ufupisho ambacho uchanganuzi wa tabia ya programu unaweza kutathminiwa. Uwepo wa mifumo rasmi unaruhusu uundaji wa _ainisho rasmi_, ambayo inaelezea sifa zinazohitajika za mfumo husika.
+
+Mbinu tofauti hutumika kuiga mikataba-erevu kwa ajili ya uthibitishaji rasmi. Kwa mfano, baadhi ya mifumo hutumiwa kujadili kuhusu tabia ya kiwango cha juu ya mkataba-erevu. Mbinu hizi za mfano hutumia mwonekano wa kisanduku cheusi kwa mikataba mahiri, na kuziona kama mifumo inayokubali ingizo na kutekeleza hesabu kulingana na ingizo hizo.
+
+Miundo ya kiwango cha juu huzingatia uhusiano kati ya mikataba mahiri na mawakala wa nje, kama vile akaunti zinazomilikiwa za nje (EOAs), akaunti za mikataba na mazingira ya kiambajengo. Miundo kama hii ni muhimu kwa kufafanua sifa zinazobainisha jinsi mkataba unapaswa kutenda kulingana na mwingiliano fulani wa watumiaji.
+
+Kinyume chake, mifumo mingine rasmi hulenga tabia ya kiwango cha chini cha mkataba-erevu. Ingawa miundo ya kiwango cha juu inaweza kusaidia katika hoja kuhusu utendaji kazi wa mkataba, inaweza kushindwa kupata maelezo kuhusu utendakazi wa ndani wa utekelezaji. Mifumo ya kiwango cha chini hutumia mtazamo wa 'sanduku-jeupe' kwa uchanganuzi wa programu na hutegemea uwakilishi wa kiwango cha chini wa programu za mkataba-erevu, kama vile mfuatilio wa programu na [grafu za mtiririko wa udhibiti](https://en.wikipedia.org/wiki/Control-flow_graph), ili kutoa hoja kuhusu sifa zinazohusiana na utekelezaji wa mkataba.
+
+Mifumo ya kiwango cha chini inachukuliwa kuwa bora kwani inawakilisha utekelezaji halisi wa mkataba-erevu katika mazingira ya utekelezaji ya Ethereum (yaani, [EVM](/developers/docs/evm/)). Mbinu za uundaji wa kiwango cha chini ni muhimu sana katika kuanzisha sifa muhimu za usalama katika mikataba mahiri na kugundua udhaifu unaowezekana.
+
+### Ainisho rasmi ni nini? {#what-is-a-formal-specification}
+
+Ainisho ni hitaji la kiufundi tu ambalo mfumo fulani lazima utimize. Katika upangaji, vipimo vinawakilisha mawazo ya jumla kuhusu utekelezaji wa programu (yaani, kile ambacho programu inapaswa kufanya).
+
+Katika muktadha wa mikataba-erevu, mainisho rasmi hurejelea _sifa_—maelezo rasmi ya mahitaji ambayo mkataba lazima utimize. Sifa kama hizo zinafafanuliwa kama "zisizobadilika" na zinawakilisha madai ya kimantiki kuhusu utekelezaji wa mkataba ambayo lazima yabaki kuwa kweli chini ya kila hali iwezekanayo, bila ubaguzi wowote.
+
+Kwa hivyo, tunaweza kufikiria ubainifu rasmi kama mkusanyo wa taarifa zilizoandikwa katika lugha rasmi inayoelezea utekelezaji uliokusudiwa wa mkataba mahiri. Maelezo yanahusu mali ya mkataba na kufafanua jinsi mkataba unapaswa kutenda katika hali tofauti. Madhumuni ya uthibitishaji rasmi ni kubaini ikiwa mkataba mahiri unamiliki sifa hizi (zisizobadilika) na kwamba sifa hizi hazijakiukwa wakati wa utekelezaji.
+
+Mainisho rasmi ni muhimu katika kuunda utekelezaji salama wa mikataba-erevu. Mikataba ambayo inashindwa kubadilika au mali zao kukiukwa wakati wa utekelezaji huathiriwa na udhaifu unaoweza kudhuru utendakazi au kusababisha matumizi mabaya.
+
+## Aina za mainisho rasmi kwa mikataba-erevu {#formal-specifications-for-smart-contracts}
+
+Mainisho rasmi huwezesha utoaji hoja za kihisabati kuhusu usahihi wa utekelezaji wa programu. Kama ilivyo kwa miundo rasmi, vipimo rasmi vinaweza kunasa sifa za kiwango cha juu au tabia ya kiwango cha chini cha utekelezaji wa mkataba.
+
+Mainisho rasmi hutokana na matumizi ya vipengele vya [mantiki ya programu](https://en.wikipedia.org/wiki/Logic_programming), ambavyo huruhusu utoaji hoja rasmi kuhusu sifa za programu. Mantiki ya programu ina sheria rasmi zinazoeleza (katika lugha ya hisabati) tabia inayotarajiwa ya programu. Mantiki mbalimbali za programu hutumika katika kuunda mainisho rasmi, ikiwa ni pamoja na [mantiki ya ufikivu](https://en.wikipedia.org/wiki/Reachability_problem), [mantiki ya muda](https://en.wikipedia.org/wiki/Temporal_logic), na [mantiki ya Hoare](https://en.wikipedia.org/wiki/Hoare_logic).
+
+Mainisho rasmi kwa mikataba-erevu yanaweza kuainishwa kwa upana kama mainisho ya **kiwango cha juu** au **kiwango cha chini**. Bila kujali aina ya vipimo ni vya aina gani, lazima ielezee vya kutosha na bila utata mali ya mfumo unaochambuliwa.
+
+### Mainisho ya kiwango cha juu {#high-level-specifications}
+
+Kama jina linavyopendekeza, vipimo vya kiwango cha juu (pia huitwa vielelezo vyenye mwelekeo wa modeli) hufafanua tabia ya kiwango cha juu cha programu. Mainisho ya kiwango cha juu huiga mkataba-erevu kama [mashine ya hali ya kikomo](https://en.wikipedia.org/wiki/Finite-state_machine) (FSM), ambayo inaweza kubadilika kati ya hali kwa kutekeleza operesheni, huku mantiki ya muda ikitumika kufafanua sifa rasmi za mfumo wa FSM.
+
+[Mantiki za muda](https://en.wikipedia.org/wiki/Temporal_logic) ni "kanuni za kutoa hoja kuhusu mapendekezo yaliyohitimu kulingana na wakati (k.m., "Nina njaa _kila wakati_" au "_Hatimaye_ nitakuwa na njaa")." Inapotumika kwa uthibitishaji rasmi, mantiki ya muda hutumiwa kutaja madai kuhusu tabia sahihi ya mifumo iliyoigwa kama mashine za majimbo. Hasa, mantiki ya muda inaelezea hali za baadaye ambazo mkataba mahiri unaweza kuwa ndani na jinsi unavyobadilika kati ya majimbo.
+
+Mainisho ya kiwango cha juu kwa ujumla hunasa sifa mbili muhimu za muda kwa mikataba-erevu: **usalama** na **uhai**. Sifa za usalama huwakilisha wazo kwamba "hakuna chochote kibaya kinachowahi kutokea" na kwa kawaida huonyesha kutofautiana. Sifa ya usalama inaweza kubainisha mahitaji ya jumla ya programu, kama vile uhuru kutoka kwa [mkwamo](https://www.techtarget.com/whatis/definition/deadlock), au kuelezea sifa maalum za kikoa kwa mikataba (k.m., visivyobadilika kwenye udhibiti wa ufikiaji wa vitendaji, thamani zinazokubalika za vigeu vya hali, au masharti ya uhamishaji wa tokeni).
+
+Chukua kwa mfano hitaji hili la usalama ambalo linashughulikia masharti ya kutumia `transfer()` au `transferFrom()` katika mikataba ya tokeni ya ERC-20: _“Salio la mtumaji kamwe haliwi chini ya kiasi kilichoombwa cha tokeni za kutumwa.”_. Maelezo haya ya lugha asilia ya kipingamizi cha mkataba yanaweza kutafsiriwa katika ubainifu rasmi (wa hisabati), ambao unaweza kuangaliwa kwa umakini ili kubaini uhalali.
+
+Sifa za maisha zinadai kwamba "jambo zuri hatimaye hufanyika" na linahusu uwezo wa mkataba kuendelea kupitia majimbo tofauti. Mfano wa mali hai ni "ukwasi", ambayo inarejelea uwezo wa mkataba wa kuhamisha salio zake kwa watumiaji kwa ombi. Ikiwa sifa hii itakiukwa, watumiaji hawatakuwa na uwezo wa kutoa rasilimali zilizohifadhiwa kwenye mkataba, kama ilivyotokea na [tukio la mkoba wa Parity](https://www.cnbc.com/2017/11/08/accidental-bug-may-have-frozen-280-worth-of-ether-on-parity-wallet.html).
+
+### Mainisho ya kiwango cha chini {#low-level-specifications}
+
+Vipimo vya kiwango cha juu huchukua kama kianzio kielelezo cha hali ya kikomo cha mkataba na kufafanua sifa zinazohitajika za muundo huu. Kinyume chake, vipimo vya kiwango cha chini (pia huitwa "vielelezo vinavyolenga mali") mara nyingi huiga programu (mikataba mahiri) kama mifumo inayojumuisha mkusanyiko wa utendakazi wa hisabati na kuelezea tabia sahihi ya mifumo hiyo.
+
+Kwa maneno rahisi, mainisho ya kiwango cha chini huchanganua _mfuatilio wa programu_ na kujaribu kufafanua sifa za mkataba-erevu juu ya mfuatilio huu. Ufuatiliaji hurejelea mfuatano wa utendakazi ambao hubadilisha hali ya mkataba mahiri; kwa hivyo, vipimo vya kiwango cha chini husaidia kubainisha mahitaji ya utekelezaji wa ndani wa mkataba.
+
+Vipimo rasmi vya kiwango cha chini vinaweza kutolewa kama sifa za mtindo wa Hoare au vibadala kwenye njia za utekelezaji.
+
+### Sifa za mtindo wa Hoare {#hoare-style-properties}
+
+[Mantiki ya Hoare](https://en.wikipedia.org/wiki/Hoare_logic) hutoa seti ya sheria rasmi za kutoa hoja kuhusu usahihi wa programu, ikiwa ni pamoja na mikataba-erevu. Sifa ya mtindo wa Hoare inawakilishwa na utatu wa Hoare `{P}c{Q}`, ambapo `c` ni programu na `P` na `Q` ni viarifu juu ya hali ya `c` (yaani, programu), vinavyoelezewa rasmi kama _masharti-awali_ na _masharti-baada_, mtawalia.
+
+Sharti ni kihusishi kinachoeleza masharti yanayohitajika kwa ajili ya utekelezaji sahihi wa chaguo la kukokotoa; watumiaji wanaoingia kwenye mkataba lazima watimize mahitaji haya. Hali ya baada ni kihusishi kinachoelezea hali ambayo chaguo za kukokotoa huweka ikiwa imetekelezwa kwa usahihi; watumiaji wanaweza kutarajia hali hii kuwa kweli baada ya kupiga simu kwenye chaguo la kukokotoa. _Kisichobadilika_ katika mantiki ya Hoare ni kiarifu ambacho huhifadhiwa na utekelezaji wa kitendaji (yaani, hakibadiliki).
+
+Mainisho ya mtindo wa Hoare yanaweza kuhakikisha ama _usahihi kiasi_ au _usahihi kamili_. Utekelezaji wa kazi ya mkataba ni "sahihi kiasi" ikiwa sharti ni la kweli kabla ya kazi kutekelezwa, na ikiwa utekelezaji utakatizwa, sharti la posta pia ni kweli. Uthibitisho wa usahihi kamili hupatikana ikiwa sharti la awali ni la kweli kabla ya chaguo la kukokotoa kutekelezwa, utekelezaji umehakikishiwa kusitishwa na ukifanya hivyo, sharti la baada litakuwa kweli.
+
+Kupata uthibitisho wa usahihi kamili ni vigumu kwa kuwa baadhi ya utekelezaji unaweza kuchelewa kabla ya kusitishwa, au kamwe kusitisha kabisa. Hiyo ilisema, swali la ikiwa utekelezaji utakoma ni jambo lisilowezekana kwa kuwa utaratibu wa gharama ya muamala wa Ethereum huzuia minyororo isiyo na kikomo ya programu (utekelezaji hukatiza kwa mafanikio au kumalizika kwa sababu ya kosa la 'nje ya gharama ya muamala').
+
+Vipimo vya mikataba mahiri vilivyoundwa kwa kutumia mantiki ya Hoare vitakuwa na masharti, masharti ya baadae na vibadala vilivyobainishwa kwa ajili ya utekelezaji wa majukumu na minyoro katika mkataba. Masharti ya awali mara nyingi hujumuisha uwezekano wa ingizo zenye makosa kwa chaguo za kukokotoa, pamoja na masharti ya baadae yanayoelezea jibu linalotarajiwa kwa ingizo kama hizo (k.m., kutoa ubaguzi maalum). Kwa njia hii sifa za mtindo wa Hoare zinafaa kwa kuhakikisha usahihi wa utekelezaji wa mkataba.
+
+Miundo mingi ya uthibitishaji rasmi hutumia vipimo vya mtindo wa Hoare ili kuthibitisha usahihi wa kisemantiki wa vitendea kazi. Inawezekana pia kuongeza sifa za mtindo wa Hoare (kama madai) moja kwa moja kwenye msimbo wa mkataba kwa kutumia kauli za `require` na `assert` katika Solidity.
+
+Kauli za `require` huelezea sharti-awali au kisichobadilika na mara nyingi hutumika kuhalalisha ingizo la mtumiaji, huku `assert` ikinasa sharti-baada linalohitajika kwa usalama. Kwa mfano, udhibiti sahihi wa ufikiaji kwa vitendaji (mfano wa sifa ya usalama) unaweza kupatikana kwa kutumia `require` kama ukaguzi wa sharti-awali juu ya utambulisho wa akaunti inayopiga simu. Vilevile, kisichobadilika kwenye thamani zinazoruhusiwa za vigeu vya hali katika mkataba (k.m., jumla ya idadi ya tokeni zinazosambazwa) kinaweza kulindwa dhidi ya ukiukaji kwa kutumia `assert` ili kuthibitisha hali ya mkataba baada ya utekelezaji wa kitendaji.
+
+### Sifa za kiwango cha mfuatilio {#trace-level-properties}
+
+Vipimo vinavyotokana na ufuatiliaji hufafanua miamala inayobadilisha mkataba kati ya mataifa tofauti na uhusiano kati ya shughuli hizi. Kama ilivyoelezwa hapo awali, athari ni mfuatano wa shughuli ambazo hubadilisha hali ya mkataba kwa njia fulani.
+
+Mbinu hii inategemea muundo wa mikataba mahiri kama mifumo ya mpito ya serikali iliyo na baadhi ya majimbo yaliyobainishwa awali (yaliyofafanuliwa na vigeu vya hali) pamoja na seti ya mabadiliko yaliyobainishwa mapema (yanayofafanuliwa na utendakazi wa mkataba). Zaidi ya hayo, [grafu ya mtiririko wa udhibiti](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/) (CFG), ambayo ni uwakilishi wa kielelezo wa mtiririko wa utekelezaji wa programu, mara nyingi hutumika kuelezea semantiki za uendeshaji wa mkataba. Hapa, kila mfuatilio unawakilishwa kama njia kwenye grafu ya mtiririko wa udhibiti.
+
+Kimsingi, vipimo vya kiwango cha ufuatiliaji hutumiwa kwasababu kuhusu mifumo ya utekelezaji wa ndani katika mikataba mahiri. Kwa kuunda vipimo vya kiwango cha ufuatiliaji, tunasisitiza njia zinazokubalika za utekelezaji (yaani, mabadiliko ya hali) kwa mkataba mahiri. Kwa kutumia mbinu, kama vile utekelezaji wa kiishara, tunaweza kuthibitisha rasmi kwamba utekelezaji haufuati kamwe njia ambayo haijafafanuliwa katika muundo rasmi.
+
+Hebu tutumie mfano wa mkataba wa [DAO](/dao/) ambao una baadhi ya vitendaji vinavyopatikana kwa umma ili kuelezea sifa za kiwango cha mfuatilio. Hapa, tunachukulia kwamba mkataba wa DAO unaruhusu watumiaji kutekeleza operesheni zifuatazo:
+
+- Weka fedha
+
+- Piga kura kwenye pendekezo baada ya kuweka fedha
+
+- Dai marejesho kama hawapigi kura kwenye pendekezo
+
+Mfano wa sifa za kiwango cha mfuatilio unaweza kuwa _"watumiaji ambao hawaweki fedha hawawezi kupiga kura kwenye pendekezo"_ au _"watumiaji ambao hawapigi kura kwenye pendekezo wanapaswa daima kuwa na uwezo wa kudai marejesho"_. Sifa zote mbili zinathibitisha mifuatano inayopendelewa ya utekelezaji (upigaji kura hauwezi kutokea _kabla_ ya kuweka fedha na kudai marejesho hakuwezi kutokea _baada_ ya kupiga kura kwenye pendekezo).
+
+## Mbinu za uthibitishaji rasmi wa mikataba-erevu {#formal-verification-techniques}
+
+### Uhakiki wa mfumo {#model-checking}
+
+Kukagua muundo ni mbinu rasmi ya uthibitishaji ambapo algoriti hukagua muundo rasmi wa mkataba mahiri dhidi ya ubainifu wake. Katika modeli za kukagua mikataba mahiri mara nyingi huwakilishwa kama mifumo ya mipito ya serikali, ilhali sifa kwenye hali za mkataba zinazoruhusiwa hufafanuliwa kwa kutumia mantiki ya muda.
+
+Uhakiki wa mfumo unahitaji kuunda uwakilishi dhahania wa kihisabati wa mfumo (yaani, mkataba) na kuelezea sifa za mfumo huu kwa kutumia fomula zinazotokana na [mantiki ya mapendekezo](https://www.baeldung.com/cs/propositional-logic). Hii hurahisisha kazi ya algoriti ya kukagua modeli, yaani kuthibitisha kwamba muundo wa hisabati unakidhi fomula fulani ya kimantiki.
+
+Ukaguaji wa kielelezo katika uthibitishaji rasmi hutumiwa kimsingi kutathmini sifa za muda zinazoelezea tabia ya mkataba baada ya muda. Sifa za muda za mikataba-erevu ni pamoja na _usalama_ na _uhai_, ambazo tulizielezea awali.
+
+Kwa mfano, sifa ya usalama inayohusiana na udhibiti wa ufikiaji (k.m., _Mmiliki wa mkataba pekee ndiye anayeweza kuita `selfdestruct`_) inaweza kuandikwa katika mantiki rasmi. Kwa mfano, usalama unaohusiana na udhibiti wa sifa (k. m., Mmiliki wa mkataba pekee ndiye anayeweza kupiga simu selfdestruct) inaweza kuandikwa kwa mantiki.
+
+Kukagua muundo hutumia uchunguzi wa nafasi ya majimbo, unaojumuisha kuunda hali zote zinazowezekana za mkataba mzuri na kujaribu kupata hali zinazoweza kufikiwa ambazo husababisha ukiukaji wa mali. Hata hivyo, hii inaweza kusababisha idadi isiyo na kikomo ya majimbo (inayojulikana kama "tatizo la mlipuko wa serikali"), kwa hivyo wakaguzi wa miundo hutegemea mbinu za uondoaji ili kufanya uchanganuzi mzuri wa kandarasi mahiri iwezekanavyo.
+
+### Uthibitishaji wa nadharia {#theorem-proving}
+
+Uthibitishaji wa nadharia ni mbinu ya kisababu kihisabati kuhusu usahihi wa programu, ikijumuisha mikataba mahiri. Inahusisha kubadilisha muundo wa mfumo wa mkataba na vipimo vyake kuwa fomula za hisabati (kauli za mantiki).
+
+Lengo la uthibitishaji wa nadharia ni kuthibitisha usawa wa kimantiki kati ya kauli hizi. “Usawa wa kimantiki” (pia huitwa “bi-implication ya kimantiki”) ni aina ya uhusiano kati ya kauli mbili ambapo kauli ya kwanza ni ya kweli _ikiwa na tu ikiwa_ kauli ya pili ni ya kweli.
+
+Uhusiano unaohitajika (usawa wa kimantiki) kati ya taarifa kuhusu muundo wa mkataba na mali yake umeundwa kama taarifa inayoweza kuthibitishwa (inayoitwa nadharia). Kwa kutumia mfumo rasmi wa makisio, kithibitishi cha nadharia cha kiotomatiki kinaweza kuthibitisha uhalali wa nadharia hiyo. Kwa maneno mengine, mthibitishaji wa nadharia inaweza kuthibitisha kwa uthabiti muundo wa mkataba mahiri unalingana na vipimo vyake.
+
+Wakati modeli za kukagua kandarasi kama mifumo ya mpito yenye hali zenye ukomo, uthibitisho wa nadharia unaweza kushughulikia uchanganuzi wa mifumo ya serikali isiyo na kikomo. Hata hivyo, hii inamaanisha kuwa mtaalamu wa nadharia ya kiotomatiki hawezi kujua kila wakati ikiwa tatizo la mantiki "linaweza kuamuliwa" au la.
+
+Kwa hiyo, msaada wa kibinadamu mara nyingi unahitajika ili kumuongoza mthibitishaji wa nadharia katika kupata uthibitisho wa usahihi. Utumiaji wa juhudi za kibinadamu katika uthibitishaji wa nadharia hufanya iwe ghali zaidi kutumia kuliko ukaguzi wa mfano, ambao umejiendesha kikamilifu.
+
+### Utekelezaji wa kiishara {#symbolic-execution}
+
+Utekelezaji wa kiishara ni mbinu ya kuchanganua mkataba-erevu kwa kutekeleza vitendaji kwa kutumia _thamani za kiishara_ (k.m., `x > 5`) badala ya _thamani halisi_ (k.m., `x == 5`). Kama mbinu rasmi ya uthibitishaji, utekelezaji wa kiishara hutumiwa kusababu rasmi kuhusu kufuatilia sifa za kiwango katika msimbo wa mkataba.
+
+Utekelezaji wa kiishara unawakilisha mfuatilio wa utekelezaji kama fomula ya kihisabati juu ya thamani za ingizo za kiishara, vinginevyo huitwa _kiarifu cha njia_. [Kitatuzi cha SMT](https://en.wikipedia.org/wiki/Satisfiability_modulo_theories) hutumika kuangalia kama kiarifu cha njia "kinatosheleza" (yaani, kuna thamani inayoweza kutosheleza fomula). Iwapo njia iliyo katika mazingira magumu inatosheleza, kisuluhishi cha SMT kitatoa thamani madhubuti ambayo itachochea utekelezaji wa waendeshaji kuelekea njia hiyo.
+
+Tuseme kitendaji cha mkataba-erevu kinachukua thamani ya `uint` (`x`) kama ingizo na hurejea nyuma wakati `x` ni kubwa kuliko `5` na pia ndogo kuliko `10`. Kupata thamani ya `x` inayosababisha hitilafu kwa kutumia utaratibu wa kawaida wa majaribio kungehitaji kupitia visa vingi vya majaribio (au zaidi) bila uhakikisho wa kupata ingizo linalosababisha hitilafu.
+
+Kinyume chake, zana ya utekelezaji wa kiishara ingetekeleza kitendaji ikiwa na thamani ya kiishara: `X > 5 ∧ X < 10` (yaani, `x` ni kubwa kuliko 5 NA `x` ni ndogo kuliko 10). Kiarifu cha njia kinachohusiana `x = X > 5 ∧ X < 10` kingepelekwa kwa kitatuzi cha SMT ili kitatuliwe. Ikiwa thamani fulani itatosheleza fomula `x = X > 5 ∧ X < 10`, kitatuzi cha SMT kitaikokotoa—kwa mfano, kitatuzi kinaweza kutoa `7` kama thamani ya `x`.
+
+Kwa sababu utekelezaji wa kiishara unategemea ingizo la programu, na seti ya ingizo ili kuchunguza hali zote zinazoweza kufikiwa kuna uwezekano usio na kikomo, bado ni aina ya majaribio. Hata hivyo, kama inavyoonyeshwa katika mfano, utekelezaji wa kiishara ni mzuri zaidi kuliko majaribio ya mara kwa mara ya kutafuta michango ambayo husababisha ukiukaji wa mali.
+
+Zaidi ya hayo, utekelezaji wa kiishara hutoa chanya chache za uwongo kuliko mbinu zingine zinazotegemea mali (k.m., fuzzing) ambazo hutokeza maingizo kwa chaguo maalum kwa nasibu. Ikiwa hali ya kosa imeanzishwa wakati wa utekelezaji wa ishara, basi inawezekana kutoa thamani halisi ambayo inasababisha kosa na kuzalisha suala hilo tena.
+
+Utekelezaji wa kiishara pia unaweza kutoa kiwango fulani cha uthibitisho wa kihisabati wa usahihi. Fikiria mfano ufuatao wa kitendaji cha mkataba chenye ulinzi wa 'overflow':
+
+```
+function safe_add(uint x, uint y) returns(uint z){
+
+ z = x + y;
+ require(z>=x);
+ require(z>=y);
+
+ return z;
+}
+```
+
+Mfuatilio wa utekelezaji unaosababisha integer overflow utahitaji kutosheleza fomula: `z = x + y AND (z >= x) AND (z >= y) AND (z < x OR z < y)` Fomula kama hiyo haiwezekani kutatuliwa, kwa hivyo inatumika kama uthibitisho wa kihisabati kwamba kitendaji cha `safe_add` hakipati overflow kamwe.
+
+### Kwa nini utumie uthibitishaji rasmi kwa mikataba-erevu? {#benefits-of-formal-verification}
+
+#### Haja ya uaminifu {#need-for-reliability}
+
+Uthibitishaji rasmi hutumiwa kutathmini usahihi wa mifumo muhimu zaidi ya usalama ambayo kutofaulu kunaweza kusababisha matokeo mabaya, kama vile kifo, majeraha au uharibifu wa kifedha. Mikataba-erevu ni programu za thamani ya juu zinazodhibiti kiasi kikubwa cha thamani, na makosa rahisi katika usanifu yanaweza kusababisha [hasara isiyoweza kurejeshwa kwa watumiaji](https://www.freecodecamp.org/news/a-hacker-stole-31m-of-ether-how-it-happened-and-what-it-means-for-ethereum-9e5dc29e33ce/amp/). Kuthibitisha rasmi mkataba kabla ya kupelekwa, hata hivyo, kunaweza kuongeza hakikisho kwamba itafanya kazi inavyotarajiwa mara tu itakapoendeshwa kwenye kiambajengo.
+
+Kutegemewa ni ubora unaohitajika sana katika mkataba wowote mahiri, hasa kwa sababu msimbo unaotumwa kwenye Mashine ya Mtandaoni ya Ethereum (EVM) kwa kawaida hauwezi kubadilika. Kwa kuwa maboresho ya baada ya uzinduzi hayapatikani kwa urahisi, hitaji la kuhakikisha utegemezi wa mikataba hufanya uthibitishaji rasmi uwe muhimu. Uthibitishaji rasmi unaweza kugundua masuala magumu, kama vile utiririshaji wa kutosha na kufurika, kuingia tena, na uboreshaji duni wa gharama ya muamala, ambayo inaweza kuwakumba wakaguzi na wajaribu waliopita.
+
+#### Thibitisha usahihi wa kiutendaji {#prove-functional-correctness}
+
+Majaribio ya programu ndiyo njia ya kawaida zaidi ya kuthibitisha kwamba mkataba mahiri unakidhi baadhi ya mahitaji. Hii inahusisha kutekeleza mkataba na sampuli ya data inayotarajiwa kushughulikia na kuchanganua tabia yake. Iwapo mkataba utarejesha matokeo yanayotarajiwa kwa data ya sampuli, basi wasanidi programu wana uthibitisho halisi wa usahihi wake.
+
+Hata hivyo, mbinu hii haiwezi kuthibitisha utekelezaji sahihi kwa thamani za pembejeo ambazo si sehemu ya sampuli. Kwa hivyo, kupima mkataba kunaweza kusaidia kugundua hitilafu (yaani, ikiwa baadhi ya njia za msimbo zitashindwa kurudisha matokeo yanayotarajiwa wakati wa utekelezaji), lakini **haiwezi kuthibitisha kwa ukamilifu kutokuwepo kwa hitilafu**.
+
+Kinyume chake, uthibitishaji rasmi unaweza kuthibitisha rasmi kwamba mkataba-erevu unakidhi mahitaji kwa anuwai isiyo na kikomo ya utekelezaji _bila_ kuendesha mkataba hata kidogo. Hili linahitaji kuunda ubainifu rasmi ambao unafafanua kwa usahihi tabia sahihi za mkataba na kuunda muundo rasmi (wa hisabati) wa mfumo wa mkataba. Kisha tunaweza kufuata utaratibu rasmi wa uthibitisho ili kuangalia uthabiti kati ya muundo wa mkataba na maelezo yake.
+
+Kwa uthibitishaji rasmi, swali la kuthibitisha ikiwa mantiki ya biashara ya mkataba inakidhi mahitaji ni pendekezo la hisabati ambalo linaweza kuthibitishwa au kukataliwa. Kwa kuthibitisha pendekezo rasmi, tunaweza kuthibitisha idadi isiyo na kikomo ya kesi za majaribio kwa idadi isiyo na kikomo ya hatua. Kwa namna hii uthibitishaji rasmi una matarajio bora zaidi ya kuthibitisha kuwa mkataba ni sahihi kiutendaji kuhusiana na vipimo.
+
+#### Malengo bora ya uthibitishaji {#ideal-verification-targets}
+
+Lengo la uthibitishaji linaelezea mfumo utakaothibitishwa rasmi. Uthibitishaji rasmi hutumiwa vyema katika "mifumo iliyopachikwa" (vipande vidogo, rahisi vya programu ambavyo vinaunda sehemu ya mfumo mkubwa). Pia ni bora kwa vikoa maalum ambavyo vina sheria chache, kwa kuwa hii hurahisisha kurekebisha zana za kuthibitisha sifa mahususi za kikoa.
+
+Mikataba-erevu—angalau, kwa kiasi fulani—inatimiza mahitaji yote mawili. Kwa mfano, ukubwa mdogo wa mikataba ya Ethereum huifanya iweze kufanyiwa uthibitishaji rasmi. Pia ni bora kwa vikosa maalum vina sheria chache, kwa kuwa hii hurahisisha kurekebisha zana za kuthibitisha sifa mahususi za kikoa.
+
+### Mzunguko wa uundaji wa haraka {#faster-development-cycle}
+
+Mbinu rasmi za uthibitishaji, kama vile ukaguzi wa kielelezo na utekelezaji wa kiishara, kwa ujumla ni bora zaidi kuliko uchanganuzi wa kawaida wa msimbo mahiri wa mkataba (unaotekelezwa wakati wa majaribio au ukaguzi). Hii ni kwa sababu uthibitishaji rasmi unategemea thamani za kiishara kupima madai ("vipi ikiwa mtumiaji atajaribu kutoa ether _n_?") tofauti na upimaji ambao hutumia thamani halisi ("vipi ikiwa mtumiaji atajaribu kutoa ether 5?").
+
+Vigezo vya ishara vinaweza kufunika aina nyingi za thamani halisi, kwa hivyo mbinu rasmi za uthibitishaji huahidi ufunikaji zaidi wa msimbo katika muda mfupi zaidi. Inapotumiwa ipasavyo, uthibitishaji rasmi unaweza kuharakisha mzunguko wa maendeleo kwa wasanidi programu.
+
+Uthibitishaji rasmi pia huboresha mchakato wa kuunda programu zilizotawanywa (dapps) kwa kupunguza hitilafu za muundo wa gharama kubwa. Kuboresha mikataba (inapowezekana) ili kurekebisha udhaifu kunahitaji uandishi wa kina wa misingi ya kanuni na juhudi zaidi zinazotumika katika utayarishaji. Uthibitishaji rasmi unaweza kugundua makosa mengi katika utekelezaji wa mkataba ambao unaweza kuwaacha wakaguzi na wakaguzi wa zamani na kutoa fursa ya kutosha ya kurekebisha masuala hayo kabla ya kupeleka mkataba.
+
+## Hasara za uthibitishaji rasmi {#drawbacks-of-formal-verification}
+
+### Gharama ya kazi ya mikono {#cost-of-manual-labor}
+
+Uthibitishaji rasmi, hasa uthibitishaji wa nusu kiotomatiki ambapo binadamu humwongoza mthibitishaji kupata uthibitisho wa usahihi, huhitaji kazi kubwa ya mikono. Zaidi ya hayo, kuunda ainisho rasmi ni shughuli ngumu inayohitaji kiwango cha juu cha ujuzi.
+
+Mambo haya (juhudi na ustadi) hufanya uthibitishaji rasmi kuwa wa mahitaji zaidi na ghali ikilinganishwa na mbinu za kawaida za kutathmini usahihi katika kandarasi, kama vile majaribio na ukaguzi. Hata hivyo, kulipa gharama ya ukaguzi kamili wa uthibitishaji ni vitendo, kwa kuzingatia gharama ya makosa katika utekelezaji wa mikataba mahiri.
+
+### Hasi za uongo {#false-negatives}
+
+Uthibitishaji rasmi unaweza tu kuangalia ikiwa utekelezaji wa mkataba mahiri unalingana na vipimo rasmi. Kwa hivyo, ni muhimu kuhakikisha kuwa vipimo vinaelezea vizuri tabia zinazotarajiwa za mkataba mzuri.
+
+Ikiwa maelezo hayajaandikwa vyema, ukiukaji wa mali—ambao unaelekeza kwenye unyongaji hatari—hauwezi kutambuliwa na ukaguzi rasmi wa uthibitishaji. Katika kesi hii, msanidi programu anaweza kudhani kimakosa kuwa mkataba hauna hitilafu.
+
+### Masuala ya utendaji {#performance-issues}
+
+Uthibitishaji rasmi hukumbana na masuala kadhaa ya utendaji. Kwa mfano, matatizo ya hali na njia ya mlipuko yanayotokea wakati wa kukagua kielelezo na ukaguzi wa kiishara, kwa mtiririko huo unaweza kuathiri taratibu za uthibitishaji. Pia, zana rasmi za uthibitishaji mara nyingi hutumia vitatuzi vya SMT na vitatuzi vingine vya vikwazo katika safu yao ya msingi, na vitatuzi hivi hutegemea taratibu za kimahesabu.
+
+Pia, si mara zote inawezekana kwa wathibitishaji wa programu kubaini kama sifa (inayoelezewa kama fomula ya kimantiki) inaweza kutoshelezwa au la ("[tatizo la uamuzi](https://en.wikipedia.org/wiki/Decision_problem)") kwa sababu programu inaweza isikome kamwe. Kwa hivyo, inaweza kuwa vigumu kuthibitisha baadhi ya sifa za mkataba hata kama umebainishwa vizuri.
+
+## Zana za uthibitishaji rasmi za mikataba-erevu ya Ethereum {#formal-verification-tools}
+
+### Lugha za uainishaji za kuunda mainisho rasmi {#specification-languages}
+
+**Act**: __Act inaruhusu uainishaji wa masasisho ya hifadhi, masharti-awali/baada na visivyobadilika vya mkataba. Seti yake ya zana pia ina sehemu za nyuma za uthibitisho zinazoweza kuthibitisha sifa nyingi kupitia Coq, vitatuzi vya SMT, au hevm.__
+
+- [GitHub](https://github.com/ethereum/act)
+- [Nyaraka](https://github.com/argotorg/act)
+
+**Scribble** - __Scribble hubadilisha ufafanuzi wa msimbo katika lugha ya uainishaji ya Scribble kuwa madai halisi yanayokagua uainishaji.__
+
+- [Nyaraka](https://docs.scribble.codes/)
+
+**Dafny** - __Dafny ni lugha ya upangaji tayari kwa uthibitishaji ambayo inategemea ufafanuzi wa kiwango cha juu ili kutoa hoja na kuthibitisha usahihi wa msimbo.__
+
+- [GitHub](https://github.com/dafny-lang/dafny)
+
+### Wathibitishaji wa programu za kuangalia usahihi {#program-verifiers}
+
+**Certora Prover** - _Certora Prover ni zana ya kiotomatiki ya uthibitishaji rasmi kwa ajili ya kuangalia usahihi wa msimbo katika mikataba-erevu. Vipimo vimeandikwa katika CVL (Lugha ya Uthibitishaji wa Certora), na ukiukaji wa mali umegunduliwa kwa kutumia mchanganyiko wa uchanganuzi tuli na utatuzi wa vikwazo._
+
+- [Tovuti](https://www.certora.com/)
+- [Nyaraka](https://docs.certora.com/en/latest/index.html)
+
+**Solidity SMTChecker** - __SMTChecker ya Solidity ni kikagua mfumo kilichojengewa ndani kinachotegemea SMT (Satisfiability Modulo Theories) na utatuzi wa Horn. Inathibitisha ikiwa msimbo wa chanzo wa mkataba unalingana na vipimo wakati wa utungaji na hukagua kwa takwimu kwa ukiukaji wa sifa za usalama.__
+
+- [GitHub](https://github.com/ethereum/solidity)
+
+**solc-verify** - __solc-verify ni toleo lililopanuliwa la mkusanyaji wa Solidity ambalo linaweza kufanya uthibitishaji rasmi wa kiotomatiki kwenye msimbo wa Solidity kwa kutumia ufafanuzi na uthibitishaji wa programu wa moduli.__
+
+- [GitHub](https://github.com/SRI-CSL/solidity)
+
+**KEVM** - __KEVM ni semantiki rasmi ya Mashine ya Mtandaoni ya Ethereum (EVM) iliyoandikwa katika mfumo wa K. KEVM inaweza kutekelezwa na inaweza kuthibitisha madai fulani yanayohusiana na sifa kwa kutumia mantiki ya ufikivu.__
+
+- [GitHub](https://github.com/runtimeverification/evm-semantics)
+- [Nyaraka](https://jellopaper.org/)
+
+### Mifumo ya kimantiki ya uthibitishaji wa nadharia {#theorem-provers}
+
+**Isabelle** - _Isabelle/HOL ni msaidizi wa uthibitisho unaoruhusu fomula za kihisabati kuelezwa katika lugha rasmi na hutoa zana za kuthibitisha fomula hizo. Maombi makuu ni kurasimisha uthibitisho wa hisabati na hasa uthibitishaji rasmi, unaojumuisha kuthibitisha usahihi wa vigezo vya kompyuta au programu na kuthibitisha sifa za lugha na itifaki za kompyuta._
+
+- [GitHub](https://github.com/isabelle-prover)
+- [Nyaraka](https://isabelle.in.tum.de/documentation.html)
+
+**Rocq** - _Rocq ni kithibitishi cha nadharia shirikishi ambacho hukuruhusu kufafanua programu kwa kutumia nadharia na kutoa uthibitisho wa usahihi uliokaguliwa na mashine._
+
+- [GitHub](https://github.com/rocq-prover/rocq)
+- [Nyaraka](https://rocq-prover.org/docs)
+
+### Zana zinazotegemea utekelezaji wa kiishara za kugundua ruwaza zilizo hatarini katika mikataba-erevu {#symbolic-execution-tools}
+
+**Manticore** - __Zana ya kuchanganua bytecode ya EVM inayotegemea utekelezaji wa kiishara.__
+
+- [GitHub](https://github.com/trailofbits/manticore)
+- [Nyaraka](https://github.com/trailofbits/manticore/wiki)
+
+**hevm** - __hevm ni injini ya utekelezaji wa kiishara na kikagua usawa cha bytecode ya EVM.__
+
+- [GitHub](https://github.com/dapphub/dapptools/tree/master/src/hevm)
+
+**Mythril** - _Zana ya utekelezaji wa kiishara ya kugundua udhaifu katika mikataba-erevu ya Ethereum_
+
+- [GitHub](https://github.com/ConsenSys/mythril-classic)
+- [Nyaraka](https://mythril-classic.readthedocs.io/en/develop/)
+
+## Masomo zaidi {#further-reading}
+
+- [Jinsi Uthibitishaji Rasmi wa Mikataba-erevu Unavyofanya Kazi](https://runtimeverification.com/blog/how-formal-verification-of-smart-contracts-works/)
+- [Jinsi Uthibitishaji Rasmi Unavyoweza Kuhakikisha Mikataba-erevu Isiyo na Kasoro](https://media.consensys.net/how-formal-verification-can-ensure-flawless-smart-contracts-cbda8ad99bd1)
+- [Muhtasari wa Miradi ya Uthibitishaji Rasmi katika Mfumo Ikolojia wa Ethereum](https://github.com/leonardoalt/ethereum_formal_verification_overview)
+- [Uthibitishaji Rasmi wa Mwanzo hadi Mwisho wa Mkataba-erevu wa Amana wa Ethereum 2.0](https://runtimeverification.com/blog/end-to-end-formal-verification-of-ethereum-2-0-deposit-smart-contract/)
+- [Kuthibitisha Rasmi Mkataba-erevu Maarufu Zaidi Duniani](https://www.zellic.io/blog/formal-verification-weth)
+- [SMTChecker na Uthibitishaji Rasmi](https://docs.soliditylang.org/en/v0.8.15/smtchecker.html)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/index.md b/public/content/translations/sw/developers/docs/smart-contracts/index.md
new file mode 100644
index 00000000000..6a64c793f2d
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/index.md
@@ -0,0 +1,112 @@
+---
+title: Utangulizi wa mikataba-erevu
+description: Muhtasari wa mikataba-erevu, unaozingatia sifa na mapungufu yake ya kipekee.
+lang: sw
+---
+
+## Mkataba-erevu ni nini? {#what-is-a-smart-contract}
+
+"Mkataba-erevu" ni programu tu inayoendeshwa kwenye mnyororo wa bloku wa Ethereum. Ni mkusanyiko wa msimbo (kazi zake) na data (hali yake) unaokaa kwenye anwani maalum kwenye mnyororo wa bloku wa Ethereum.
+
+Mikataba-erevu ni aina ya [akaunti ya Ethereum](/developers/docs/accounts/). Hii inamaanisha zina salio na zinaweza kulengwa na miamala. Hata hivyo, hazidhibitiwi na mtumiaji, badala yake hupelekwa kwenye mtandao na huendeshwa kama zilivyopangwa. Akaunti za watumiaji zinaweza kisha kuingiliana na mkataba-erevu kwa kuwasilisha miamala inayotekeleza kazi iliyobainishwa kwenye mkataba-erevu. Mikataba-erevu inaweza kufafanua sheria, kama mkataba wa kawaida, na kuzitekeleza kiotomatiki kupitia msimbo. Mikataba-erevu haiwezi kufutwa kwa chaguo-msingi, na mwingiliano nayo hauwezi kubatilishwa.
+
+## Mahitaji ya awali {#prerequisites}
+
+Ikiwa unaanza sasa hivi au unatafuta utangulizi usio wa kiufundi sana, tunapendekeza [utangulizi wetu wa mikataba-erevu](/smart-contracts/).
+
+Hakikisha umesoma kuhusu [akaunti](/developers/docs/accounts/), [miamala](/developers/docs/transactions/) na [mashine halisi ya Ethereum](/developers/docs/evm/) kabla ya kuingia katika ulimwengu wa mikataba-erevu.
+
+## Mashine ya kuuza ya kidijitali {#a-digital-vending-machine}
+
+Labda sitiari bora kwa mkataba-erevu ni mashine ya kuuza, kama ilivyoelezwa na [Nick Szabo](https://unenumerated.blogspot.com/). Ukiweka pembejeo sahihi, matokeo fulani yamehakikishwa.
+
+Ili kupata vitafunio kutoka kwa mashine ya kuuza:
+
+```
+pesa + uteuzi wa vitafunio = vitafunio vimetolewa
+```
+
+Mantiki hii imepangwa ndani ya mashine ya kuuza.
+
+Mkataba-erevu, kama mashine ya kuuza, una mantiki iliyopangwa ndani yake. Huu hapa ni mfano rahisi wa jinsi mashine hii ya kuuza ingeonekana kama ingekuwa mkataba-erevu ulioandikwa kwa Solidity:
+
+```solidity
+pragma solidity 0.8.7;
+
+contract VendingMachine {
+
+ // Tangaza vigezo vya hali ya mkataba
+ address public owner;
+ mapping (address => uint) public cupcakeBalances;
+
+ // Wakati mkataba wa 'VendingMachine' unaposambazwa:
+ // 1. weka anwani ya usambazaji kama mmiliki wa mkataba
+ // 2. weka salio la cupcake la mkataba-erevu uliosambazwa kuwa 100
+ constructor() {
+ owner = msg.sender;
+ cupcakeBalances[address(this)] = 100;
+ }
+
+ // Ruhusu mmiliki aongeze salio la cupcake la mkataba-erevu
+ function refill(uint amount) public {
+ require(msg.sender == owner, "Ni mmiliki pekee anayeweza kujaza tena.");
+ cupcakeBalances[address(this)] += amount;
+ }
+
+ // Ruhusu mtu yeyote anunue cupcakes
+ function purchase(uint amount) public payable {
+ require(msg.value >= amount * 1 ether, "Lazima ulipe angalau ETH 1 kwa kila cupcake");
+ require(cupcakeBalances[address(this)] >= amount, "Hakuna cupcakes za kutosha kwenye hifadhi ili kukamilisha ununuzi huu");
+ cupcakeBalances[address(this)] -= amount;
+ cupcakeBalances[msg.sender] += amount;
+ }
+}
+```
+
+Kama vile mashine ya kuuza inavyoondoa hitaji la mfanyakazi muuzaji, mikataba-erevu inaweza kuchukua nafasi ya wasuluhishi katika tasnia nyingi.
+
+## Bila ruhusa {#permissionless}
+
+Mtu yeyote anaweza kuandika mkataba-erevu na kuusambaza kwenye mtandao. Unahitaji tu kujifunza jinsi ya kuandika msimbo katika [lugha ya mkataba-erevu](/developers/docs/smart-contracts/languages/), na kuwa na ETH ya kutosha kusambaza mkataba wako. Kusambaza mkataba-erevu kimsingi ni muamala, kwa hivyo unahitaji kulipa [gesi](/developers/docs/gas/) kwa njia ile ile unayohitaji kulipa gesi kwa uhamisho rahisi wa ETH. Hata hivyo, gharama za gesi kwa usambazaji wa mkataba ni kubwa zaidi.
+
+Ethereum ina lugha zinazofaa kwa wasanidi programu za kuandikia mikataba-erevu:
+
+- Solidity
+- Vyper
+
+[Zaidi kuhusu lugha](/developers/docs/smart-contracts/languages/)
+
+Hata hivyo, ni lazima zikusanywe kabla ya kusambazwa ili mashine halisi ya Ethereum iweze kutafsiri na kuhifadhi mkataba. [Zaidi kuhusu ukusanyaji](/developers/docs/smart-contracts/compiling/)
+
+## Uwezo wa kuunganisha {#composability}
+
+Mikataba-erevu ni ya umma kwenye Ethereum na inaweza kufikiriwa kama API zilizo wazi. Hii inamaanisha unaweza kuita mikataba-erevu mingine ndani ya mkataba wako mwenyewe ili kupanua pakubwa kile kinachowezekana. Mikataba inaweza hata kusambaza mikataba mingine.
+
+Jifunze zaidi kuhusu [uwezo wa kuunganisha wa mikataba-erevu](/developers/docs/smart-contracts/composability/).
+
+## Vizuizi {#limitations}
+
+Mikataba-erevu peke yake haiwezi kupata taarifa kuhusu matukio ya "ulimwengu halisi" kwa sababu haiwezi kupata data kutoka kwa vyanzo vya nje ya mnyororo. Hii inamaanisha haziwezi kujibu matukio katika ulimwengu halisi. Hii ni kwa makusudi. Kutegemea taarifa za nje kunaweza kuhatarisha makubaliano, ambayo ni muhimu kwa usalama na ugatuaji.
+
+Hata hivyo, ni muhimu kwa mifumo ya mnyororo wa bloku kuweza kutumia data ya nje ya mnyororo. Suluhisho ni [oracles](/developers/docs/oracles/) ambazo ni zana zinazokusanya data ya nje ya mnyororo na kuifanya ipatikane kwa mikataba-erevu.
+
+Kikomo kingine cha mikataba-erevu ni saizi ya juu ya mkataba. Mkataba-erevu unaweza kuwa na upeo wa 24KB la sivyo utaishiwa na gesi. Hili linaweza kuepukwa kwa kutumia [The Diamond Pattern](https://eips.ethereum.org/EIPS/eip-2535).
+
+## Mikataba ya Multisig {#multisig}
+
+Mikataba ya Multisig (saini-nyingi) ni akaunti za mkataba-erevu zinazohitaji saini nyingi halali ili kutekeleza muamala. Hii ni muhimu sana kwa kuepuka sehemu moja ya kutofaulu kwa mikataba inayoshikilia kiasi kikubwa cha ether au tokeni zingine. Multisigs pia hugawanya jukumu la utekelezaji wa mkataba na usimamizi wa ufunguo kati ya pande nyingi na kuzuia upotezaji wa ufunguo mmoja binafsi unaosababisha upotezaji usioweza kurekebishwa wa fedha. Kwa sababu hizi, mikataba ya multisig inaweza kutumika kwa utawala rahisi wa DAO. Multisigs huhitaji saini N kati ya M saini zinazokubalika (ambapo N ≤ M, na M > 1) ili kutekeleza. `N = 3, M = 5` na `N = 4, M = 7` hutumika sana. Multisig ya 4/7 inahitaji saini nne kati ya saini saba halali zinazowezekana. Hii inamaanisha fedha bado zinaweza kupatikana hata kama saini tatu zimepotea. Katika kesi hii, inamaanisha pia kwamba wamiliki wengi wa funguo lazima wakubaliane na kusaini ili mkataba utekelezwe.
+
+## Rasilimali za mkataba-erevu {#smart-contract-resources}
+
+**Mikataba ya OpenZeppelin -** **_Maktaba ya uundaji salama wa mikataba-erevu._**
+
+- [openzeppelin.com/contracts/](https://openzeppelin.com/contracts/)
+- [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts)
+- [Jukwaa la Jumuiya](https://forum.openzeppelin.com/c/general/16)
+
+## Masomo zaidi {#further-reading}
+
+- [Coinbase: Mkataba-erevu ni nini?](https://www.coinbase.com/learn/crypto-basics/what-is-a-smart-contract)
+- [Chainlink: Mkataba-erevu ni nini?](https://chain.link/education/smart-contracts)
+- [Video: Imefafanuliwa Kirahisi - Mikataba-Erevu](https://youtu.be/ZE2HxTmxfrI)
+- [Cyfrin Updraft: Jukwaa la kujifunza na kukagua Web3](https://updraft.cyfrin.io)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/languages/index.md b/public/content/translations/sw/developers/docs/smart-contracts/languages/index.md
new file mode 100644
index 00000000000..a77326049c4
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/languages/index.md
@@ -0,0 +1,343 @@
+---
+title: Lugha za mikataba mahiri
+description: "Muhtasari na ulinganisho wa lugha mbili kuu za mikataba-erevu – Solidity na Vyper."
+lang: sw
+---
+
+Kipengele kikuu kuhusu Ethereum ni kwamba mikataba-erevu inaweza kupangwa kwa kutumia lugha ambazo ni rahisi kwa wasanidi programu. Ikiwa una uzoefu na Python au [lugha yoyote ya mabano](https://wikipedia.org/wiki/List_of_programming_languages_by_type#Curly-bracket_languages), unaweza kupata lugha yenye sintaksia unayoifahamu.
+
+Lugha mbili zinazotumika zaidi na kudumishwa ni:
+
+- Solidity
+- Vyper
+
+Remix IDE hutoa mazingira kamili ya uendelezaji kwa ajili ya kuunda na kujaribu mikataba katika Solidity na Vyper. [Jaribu Remix IDE ya kwenye kivinjari](https://remix.ethereum.org) ili kuanza kuandika msimbo.
+
+Wasanidi programu wenye uzoefu zaidi wanaweza pia kutaka kutumia Yul, lugha ya kati ya [Mashine ya mtandaoni ya Ethereum](/developers/docs/evm/), au Yul+, kiendelezi cha Yul.
+
+Ikiwa una hamu ya kujua na unapenda kusaidia kujaribu lugha mpya ambazo bado zinatengenezwa sana, unaweza kujaribu Fe, lugha mpya ya mkataba-erevu ambayo bado iko katika hatua za mwanzo.
+
+## Mahitaji ya awali {#prerequisites}
+
+Ujuzi wa awali wa lugha za programu, hasa JavaScript au Python, unaweza kukusaidia kuelewa tofauti katika lugha za mkataba-erevu. Pia tunapendekeza uelewe mikataba-erevu kama dhana kabla ya kuzama sana katika ulinganisho wa lugha. [Utangulizi wa mikataba-erevu](/developers/docs/smart-contracts/).
+
+## Solidity {#solidity}
+
+- Lugha ya kiwango cha juu, inayolenga vitu kwa ajili ya kutekeleza mikataba-erevu.
+- Lugha ya mabano ambayo imeathiriwa pakubwa na C++.
+- Aina tuli (aina ya kigezo hujulikana wakati wa kuandaliwa).
+- Inasaidia:
+ - Urithi (unaweza kupanua mikataba mingine).
+ - Maktaba (unaweza kuunda msimbo unaoweza kutumika tena ambao unaweza kuuita kutoka kwa mikataba tofauti - kama vile vitendaji tuli katika darasa tuli katika lugha zingine za programu zinazolenga vitu).
+ - Aina changamano zilizofafanuliwa na mtumiaji.
+
+### Viungo muhimu {#important-links}
+
+- [Nyaraka](https://docs.soliditylang.org/en/latest/)
+- [Tovuti ya Lugha ya Solidity](https://soliditylang.org/)
+- [Solidity kwa Mfano](https://docs.soliditylang.org/en/latest/solidity-by-example.html)
+- [GitHub](https://github.com/ethereum/solidity/)
+- [Chumba cha Gumzo cha Solidity Gitter](https://gitter.im/ethereum/solidity) kimeunganishwa na [Chumba cha Gumzo cha Solidity Matrix](https://matrix.to/#/#ethereum_solidity:gitter.im)
+- [Karatasi ya Kudokezea](https://reference.auditless.com/cheatsheet)
+- [Blogu ya Solidity](https://blog.soliditylang.org/)
+- [Twitter ya Solidity](https://twitter.com/solidity_lang)
+
+### Mfano wa mkataba {#example-contract}
+
+```solidity
+// SPDX-Kitambulisho-Leseni: GPL-3.0
+pragma solidity >= 0.7.0;
+
+contract Coin {
+ // Neno kuu "public" hufanya vigezo
+ // kupatikana kutoka kwa mikataba mingine
+ address public minter;
+ mapping (address => uint) public balances;
+
+ // Matukio huruhusu wateja kujibu mabadiliko maalum
+ // ya mkataba unaotangaza
+ event Sent(address from, address to, uint amount);
+
+ // Msimbo wa kiunda huendeshwa tu wakati mkataba
+ // unapoundwa
+ constructor() {
+ minter = msg.sender;
+ }
+
+ // Hutuma kiasi cha sarafu mpya zilizoundwa kwa anwani
+ // Inaweza kuitwa tu na muundaji wa mkataba
+ function mint(address receiver, uint amount) public {
+ require(msg.sender == minter);
+ require(amount < 1e60);
+ balances[receiver] += amount;
+ }
+
+ // Hutuma kiasi cha sarafu zilizopo
+ // kutoka kwa mpigaji simu yeyote hadi anwani
+ function send(address receiver, uint amount) public {
+ require(amount <= balances[msg.sender], "Salio halitoshi.");
+ balances[msg.sender] -= amount;
+ balances[receiver] += amount;
+ emit Sent(msg.sender, receiver, amount);
+ }
+}
+```
+
+Mfano huu unapaswa kukupa hisia ya jinsi sintaksia ya mkataba wa Solidity ilivyo. Kwa maelezo ya kina zaidi ya vitendaji na vigezo, [angalia nyaraka](https://docs.soliditylang.org/en/latest/contracts.html).
+
+## Vyper {#vyper}
+
+- Lugha ya programu ya Pythonic
+- Uchapaji imara
+- Msimbo mdogo na unaoeleweka wa mkusanyaji
+- Uundaji bora wa bytecode
+- Kwa makusudi ina vipengele vichache kuliko Solidity kwa lengo la kufanya mikataba iwe salama zaidi na rahisi kukagua. Vyper haiungi mkono:
+ - Virekebishaji
+ - Urithi
+ - Mkusanyiko wa ndani
+ - Upakiaji mwingi wa kitendaji
+ - Upakiaji mwingi wa kiendeshaji
+ - Wito unaojirudia
+ - Mizunguko ya urefu usio na kikomo
+ - Nukta zisizobadilika za mfumo wa namba mbili
+
+Kwa maelezo zaidi, [soma mantiki ya Vyper](https://vyper.readthedocs.io/en/latest/index.html).
+
+### Viungo muhimu {#important-links-1}
+
+- [Nyaraka](https://vyper.readthedocs.io)
+- [Vyper kwa Mfano](https://vyper.readthedocs.io/en/latest/vyper-by-example.html)
+- [Vyper Zaidi kwa Mfano](https://vyper-by-example.org/)
+- [GitHub](https://github.com/vyperlang/vyper)
+- [Gumzo la jumuiya ya Vyper Discord](https://discord.gg/SdvKC79cJk)
+- [Karatasi ya Kudokezea](https://reference.auditless.com/cheatsheet)
+- [Mifumo na zana za ukuzaji wa mkataba-erevu kwa Vyper](/developers/docs/programming-languages/python/)
+- [VyperPunk - jifunze kulinda na kudukua mikataba-erevu ya Vyper](https://github.com/SupremacyTeam/VyperPunk)
+- [Kitovu cha Vyper kwa ajili ya maendeleo](https://github.com/zcor/vyper-dev)
+- [Mifano bora zaidi ya mikataba-erevu ya Vyper](https://github.com/pynchmeister/vyper-greatest-hits/tree/main/contracts)
+- [Rasilimali zilizoratibiwa za Awesome Vyper](https://github.com/spadebuilders/awesome-vyper)
+
+### Mfano {#example}
+
+```python
+# Mnada Wazi
+
+# Vigezo vya mnada
+
+# Mpokeaji hupokea pesa kutoka kwa mzabuni wa juu zaidi
+
+beneficiary: public(address)
+auctionStart: public(uint256)
+auctionEnd: public(uint256)
+
+# Hali ya sasa ya mnada
+
+highestBidder: public(address)
+highestBid: public(uint256)
+
+# Imewekwa kuwa kweli mwishoni, inazuia mabadiliko yoyote
+
+ended: public(bool)
+
+# Fuatilia zabuni zilizorejeshwa ili tuweze kufuata mtindo wa kutoa pesa
+
+pendingReturns: public(HashMap[address, uint256])
+
+# Unda mnada rahisi na `_bidding_time`
+
+# muda wa sekunde za zabuni kwa niaba ya
+
+# anwani ya mpokeaji `_beneficiary`.
+
+@external
+def __init__(_beneficiary: address, _bidding_time: uint256):
+ self.beneficiary = _beneficiary
+ self.auctionStart = block.timestamp
+ self.auctionEnd = self.auctionStart + _bidding_time
+
+# Zabuni kwenye mnada na thamani iliyotumwa
+
+# pamoja na muamala huu.
+
+# Thamani itarejeshwa tu ikiwa
+
+# mnada haujashindwa.
+
+@external
+@payable
+def bid():
+ # Angalia kama muda wa zabuni umeisha.
+ assert block.timestamp < self.auctionEnd
+ # Angalia kama zabuni ni ya juu vya kutosha
+ assert msg.value > self.highestBid
+ # Fuatilia urejeshaji wa pesa kwa mzabuni wa awali wa juu
+ self.pendingReturns[self.highestBidder] += self.highestBid
+ # Fuatilia zabuni mpya ya juu
+ self.highestBidder = msg.sender
+ self.highestBid = msg.value
+
+# Toa zabuni iliyorejeshwa hapo awali. Mtindo wa kutoa pesa ni
+
+# hutumika hapa kuepuka suala la usalama. Kama urejeshaji fedha ungekuwa moja kwa moja
+
+# zilizotumwa kama sehemu ya bid(), mkataba hasidi wa zabuni ungeweza kuzuia
+
+# urejeshaji huo na hivyo kuzuia zabuni mpya za juu kuingia.
+
+@external
+def withdraw():
+ pending_amount: uint256 = self.pendingReturns[msg.sender]
+ self.pendingReturns[msg.sender] = 0
+ send(msg.sender, pending_amount)
+
+# Maliza mnada na tuma zabuni ya juu zaidi
+
+# kwa mpokeaji.
+
+@external
+def endAuction():
+ # Ni mwongozo mzuri wa kupanga vitendaji vinavyoingiliana
+ # na mikataba mingine (yaani, huita vitendaji au hutuma ether)
+ # katika awamu tatu:
+ # 1. kuangalia masharti
+ # 2. kufanya vitendo (vinavyoweza kubadilisha masharti)
+ # 3. kuingiliana na mikataba mingine
+ # Ikiwa awamu hizi zimechanganywa, mkataba mwingine unaweza kuita
+ # tena katika mkataba wa sasa na kurekebisha hali au kusababisha
+ # athari (malipo ya ether) kufanywa mara nyingi.
+ # Ikiwa vitendaji vinavyoitwa ndani ni pamoja na mwingiliano na nje
+ # mikataba, pia inapaswa kuzingatiwa mwingiliano na
+ # mikataba ya nje.
+
+ # 1. Masharti
+ # Angalia kama muda wa mwisho wa mnada umefikiwa
+ assert block.timestamp >= self.auctionEnd
+ # Angalia kama kitendaji hiki tayari kimeitwa
+ assert not self.ended
+
+ # 2. Athari
+ self.ended = True
+
+ # 3. Mwingiliano
+ send(self.beneficiary, self.highestBid)
+```
+
+Mfano huu unapaswa kukupa hisia ya jinsi sintaksia ya mkataba wa Vyper ilivyo. Kwa maelezo ya kina zaidi ya vitendaji na vigezo, [angalia nyaraka](https://vyper.readthedocs.io/en/latest/vyper-by-example.html#simple-open-auction).
+
+## Yul na Yul+ {#yul}
+
+Ikiwa wewe ni mgeni kwa Ethereum na bado hujafanya uandishi wowote wa msimbo na lugha za mkataba-erevu, tunapendekeza uanze na Solidity au Vyper. Angalia Yul au Yul+ mara tu unapofahamu mbinu bora za usalama wa mkataba-erevu na maelezo mahususi ya kufanya kazi na EVM.
+
+**Yul**
+
+- Lugha ya kati kwa Ethereum.
+- Inasaidia [EVM](/developers/docs/evm) na [Ewasm](https://github.com/ewasm), Mkusanyiko wa Wavuti wenye ladha ya Ethereum, na imeundwa kuwa kigawanyiko cha kawaida kinachoweza kutumika cha majukwaa yote mawili.
+- Lengo zuri kwa hatua za uboreshaji wa kiwango cha juu ambazo zinaweza kufaidi majukwaa ya EVM na Ewasm kwa usawa.
+
+**Yul+**
+
+- Kiendelezi cha kiwango cha chini, chenye ufanisi mkubwa kwa Yul.
+- Hapo awali iliyoundwa kwa ajili ya mkataba wa [optimistic rollup](/developers/docs/scaling/optimistic-rollups/).
+- Yul+ inaweza kutazamwa kama pendekezo la majaribio la sasisho kwa Yul, na kuongeza vipengele vipya kwake.
+
+### Viungo muhimu {#important-links-2}
+
+- [Nyaraka za Yul](https://docs.soliditylang.org/en/latest/yul.html)
+- [Nyaraka za Yul+](https://github.com/fuellabs/yulp)
+- [Chapisho la Utangulizi la Yul+](https://medium.com/@fuellabs/introducing-yul-a-new-low-level-language-for-ethereum-aa64ce89512f)
+
+### Mfano wa mkataba {#example-contract-2}
+
+Mfano rahisi ufuatao unatekeleza kitendaji cha nguvu. Inaweza kuandaliwa kwa kutumia `solc --strict-assembly --bin input.yul`. Mfano unapaswa
+kuhifadhiwa katika faili ya input.yul.
+
+```
+{
+ function power(base, exponent) -> result
+ {
+ switch exponent
+ case 0 { result := 1 }
+ case 1 { result := base }
+ default
+ {
+ result := power(mul(base, base), div(exponent, 2))
+ if mod(exponent, 2) { result := mul(base, result) }
+ }
+ }
+ let res := power(calldataload(0), calldataload(32))
+ mstore(0, res)
+ return(0, 32)
+}
+```
+
+Ikiwa tayari una uzoefu mzuri na mikataba-erevu, utekelezaji kamili wa ERC20 katika Yul unaweza kupatikana [hapa](https://solidity.readthedocs.io/en/latest/yul.html#complete-erc20-example).
+
+## Fe {#fe}
+
+- Lugha ya aina tuli kwa ajili ya Mashine ya mtandaoni ya Ethereum (EVM).
+- Imehamasishwa na Python na Rust.
+- Inalenga kuwa rahisi kujifunza -- hata kwa wasanidi programu ambao ni wapya kwenye mfumo ikolojia wa Ethereum.
+- Uendelezaji wa Fe bado uko katika hatua za mwanzo, lugha hiyo ilikuwa na toleo lake la alpha mnamo Januari 2021.
+
+### Viungo muhimu {#important-links-3}
+
+- [GitHub](https://github.com/ethereum/fe)
+- [Tangazo la Fe](https://snakecharmers.ethereum.org/fe-a-new-language-for-the-ethereum-ecosystem/)
+- [Ramani ya Fe 2021](https://notes.ethereum.org/LVhaTF30SJOpkbG1iVw1jg)
+- [Gumzo la Fe Discord](https://discord.com/invite/ywpkAXFjZH)
+- [Twitter ya Fe](https://twitter.com/official_fe)
+
+### Mfano wa mkataba {#example-contract-3}
+
+Ufuatao ni mkataba rahisi uliotekelezwa katika Fe.
+
+```
+type BookMsg = bytes[100]
+
+contract GuestBook:
+ pub guest_book: map
+
+ event Signed:
+ book_msg: BookMsg
+
+ pub def sign(book_msg: BookMsg):
+ self.guest_book[msg.sender] = book_msg
+
+ emit Signed(book_msg=book_msg)
+
+ pub def get_msg(addr: address) -> BookMsg:
+ return self.guest_book[addr].to_mem()
+
+```
+
+## Jinsi ya kuchagua {#how-to-choose}
+
+Kama ilivyo kwa lugha nyingine yoyote ya programu, mara nyingi ni kuhusu kuchagua zana inayofaa kwa kazi inayofaa na pia mapendeleo ya kibinafsi.
+
+Hapa kuna mambo machache ya kuzingatia ikiwa bado hujajaribu lugha yoyote:
+
+### Ni nini kizuri kuhusu Solidity? {#solidity-advantages}
+
+- Ikiwa wewe ni mwanzilishi, kuna mafunzo na zana nyingi za kujifunza. Angalia zaidi kuhusu hilo katika sehemu ya [Jifunze kwa Kuandika Msimbo](/developers/learning-tools/).
+- Zana nzuri za msanidi programu zinapatikana.
+- Solidity ina jumuiya kubwa ya wasanidi programu, ambayo inamaanisha kuna uwezekano mkubwa utapata majibu ya maswali yako haraka sana.
+
+### Ni nini kizuri kuhusu Vyper? {#vyper-advatages}
+
+- Njia nzuri ya kuanza kwa wasanidi wa Python wanaotaka kuandika mikataba-erevu.
+- Vyper ina idadi ndogo ya vipengele vinavyoifanya kuwa nzuri kwa ajili ya kuunda mifano ya haraka ya mawazo.
+- Vyper inalenga kuwa rahisi kukagua na kusomeka kwa urahisi iwezekanavyo kwa binadamu.
+
+### Ni nini kizuri kuhusu Yul na Yul+? {#yul-advantages}
+
+- Lugha rahisi na inayofanya kazi ya kiwango cha chini.
+- Inaruhusu kusogea karibu zaidi na EVM mbichi, ambayo inaweza kusaidia kuboresha matumizi ya gesi ya mikataba yako.
+
+## Ulinganisho wa lugha {#language-comparisons}
+
+Kwa ulinganisho wa sintaksia ya msingi, mzunguko wa maisha ya mkataba, violesura, viendeshaji, miundo ya data, vitendaji, mtiririko wa udhibiti, na zaidi angalia [karatasi hii ya kudokezea ya Auditless](https://reference.auditless.com/cheatsheet/)
+
+## Masomo zaidi {#further-reading}
+
+- [Maktaba ya Mikataba ya Solidity na OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/)
+- [Solidity kwa Mfano](https://solidity-by-example.org)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/libraries/index.md b/public/content/translations/sw/developers/docs/smart-contracts/libraries/index.md
new file mode 100644
index 00000000000..bf6c537f8a5
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/libraries/index.md
@@ -0,0 +1,117 @@
+---
+title: Maktaba za mikataba mahiri
+description: Gundua maktaba za mikataba-erevu zinazoweza kutumika tena na vizuizi vya ujenzi ili kuharakisha miradi yako ya maendeleo ya Ethereum.
+lang: sw
+---
+
+Huhitaji kuandika kila mkataba mahiri katika mradi wako kuanzia mwanzo. Kuna maktaba nyingi za mikataba mahiri za programu huria zinazopatikana ambazo hutoa vizuizi vya ujenzi vinavyoweza kutumika tena kwa mradi wako ambavyo vinaweza kukuepusha na kulazimika kuunda tena gurudumu.
+
+## Mahitaji ya awali {#prerequisites}
+
+Kabla ya kurukia maktaba mahiri za mikataba, ni wazo nzuri kuwa na ufahamu mzuri wa muundo wa mkataba mahiri. Nenda kwenye [muundo wa mkataba-erevu](/developers/docs/smart-contracts/anatomy/) ikiwa bado hujafanya hivyo.
+
+## Kuna nini ndani ya maktaba {#whats-in-a-library}
+
+Kwa kawaida unaweza kupata aina mbili za vizuizi vya ujenzi katika maktaba mahiri za mikataba: tabia zinazoweza kutumika tena unazoweza kuongeza kwenye kandarasi zako, na utekelezaji wa viwango mbalimbali.
+
+### Mienendo {#behaviors}
+
+Unapoandika mikataba-erevu, kuna uwezekano mkubwa utajikuta ukiandika mifumo inayofanana mara kwa mara, kama vile kugawa anwani ya _admin_ ili kutekeleza shughuli zilizolindwa katika mkataba, au kuongeza kitufe cha dharura cha _pause_ iwapo kutatokea suala lisilotarajiwa.
+
+Maktaba za mikataba-erevu kwa kawaida hutoa utekelezaji unaoweza kutumika tena wa mienendo hii kama [maktaba](https://solidity.readthedocs.io/en/v0.7.2/contracts.html#libraries) au kupitia [urithi](https://solidity.readthedocs.io/en/v0.7.2/contracts.html#inheritance) katika Solidity.
+
+Kwa mfano, ifuatayo ni toleo lililorahisishwa la [mkataba wa `Ownable`](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.2.0/contracts/access/Ownable.sol) kutoka [maktaba ya Mikataba ya OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts), ambayo huteua anwani kama mmiliki wa mkataba, na hutoa kirekebishaji cha kuzuia ufikiaji wa mbinu kwa mmiliki huyo pekee.
+
+```solidity
+contract Ownable {
+ address public owner;
+
+ constructor() internal {
+ owner = msg.sender;
+ }
+
+ modifier onlyOwner() {
+ require(owner == msg.sender, "Ownable: anayepiga simu si mmiliki");
+ _;
+ }
+}
+```
+
+Ili kutumia jengo kama hili katika mkataba wako, utahitaji kwanza kuagiza, na kisha kupanua kutoka humo katika mikataba yako mwenyewe. Hii itakuruhusu kutumia kirekebishaji kilichotolewa na mkataba msingi wa `Ownable` ili kulinda utendakazi wako mwenyewe.
+
+```solidity
+import ".../Ownable.sol"; // Njia ya kuelekea maktaba iliyoingizwa
+
+contract MyContract is Ownable {
+ // Utendakazi ufuatao unaweza kuitwa tu na mmiliki
+ function secured() onlyOwner public {
+ msg.sender.transfer(1 ether);
+ }
+}
+```
+
+Mfano mwingine maarufu ni [SafeMath](https://docs.openzeppelin.com/contracts/3.x/utilities#math) au [DsMath](https://dappsys.readthedocs.io/en/latest/ds_math.html). Hizi ni maktaba (kinyume na kandarasi za msingi) ambazo hutoa utendakazi wa hesabu na ukaguzi wa ziada, ambao haujatolewa na lugha. Ni utaratibu mzuri kutumia mojawapo ya maktaba hizi badala ya shughuli za hesabu asilia ili kulinda mkataba wako dhidi ya mafuriko, ambayo yanaweza kuwa na matokeo mabaya!
+
+### Viwango {#standards}
+
+Ili kuwezesha [utunzi na ushirikiano](/developers/docs/smart-contracts/composability/), jumuiya ya Ethereum imefafanua viwango kadhaa katika mfumo wa **ERCs**. Unaweza kusoma zaidi kuzihusu katika sehemu ya [viwango](/developers/docs/standards/).
+
+Unapojumuisha ERC kama sehemu ya kandarasi zako, ni vyema utafute utekelezaji wa kawaida badala ya kujaribu kuzindua yako. Maktaba nyingi za mikataba mahiri hujumuisha utekelezaji wa ERC maarufu zaidi. Kwa mfano, [kiwango cha tokeni inayoweza kubadilishwa cha ERC20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) kinachopatikana kila mahali kinaweza kupatikana katika [HQ20](https://github.com/HQ20/contracts/blob/master/contracts/token/README.md), [DappSys](https://github.com/dapphub/ds-token/) na [OpenZeppelin](https://docs.openzeppelin.com/contracts/3.x/erc20). Zaidi ya hayo, baadhi ya ERC pia hutoa utekelezaji wa kisheria kama sehemu ya ERC yenyewe.
+
+Inafaa kutaja kwamba baadhi ya ERCs hazijitegemei, lakini ni nyongeza kwa ERC zingine. Kwa mfano, [ERC2612](https://eips.ethereum.org/EIPS/eip-2612) inaongeza kiendelezi kwa ERC20 ili kuboresha utumiaji wake.
+
+## Jinsi ya kuongeza maktaba {#how-to}
+
+Daima rejelea hati za maktaba unayojumuisha kwa maagizo maalum ya jinsi ya kuijumuisha kwenye mradi wako. Maktaba kadhaa za mikataba ya Solidity zimefungashwa kwa kutumia `npm`, kwa hivyo unaweza kuzisakinisha kwa `npm install`. Zana nyingi za [kukusanya](/developers/docs/smart-contracts/compiling/) mikataba zitaangalia ndani ya `node_modules` yako kwa maktaba za mikataba-erevu, kwa hivyo unaweza kufanya yafuatayo:
+
+```solidity
+// Hii itapakia maktaba ya @openzeppelin/contracts kutoka kwa node_modules zako
+import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+contract MyNFT is ERC721 {
+ constructor() ERC721("MyNFT", "MNFT") public { }
+}
+```
+
+Bila kujali mbinu unayotumia, unapojumuisha maktaba, daima angalia toleo la [lugha](/developers/docs/smart-contracts/languages/). Kwa mfano, huwezi kutumia maktaba kwa Solidity 0.6 ikiwa unaandika mikataba yako katika Solidity 0.5.
+
+## Wakati wa kutumia {#when-to-use}
+
+Kutumia maktaba ya mkataba mahiri kwa mradi wako kuna manufaa kadhaa. Kwanza kabisa, inakuokoa wakati kwa kukupa vizuizi vya ujenzi ambavyo tayari kutumia unaweza kujumuisha kwenye mfumo wako, badala ya kulazimika kuziandika mwenyewe.
+
+Usalama pia ni nyongeza kuu. Maktaba huria za mikataba mahiri pia mara nyingi huchunguzwa sana. Ikizingatiwa miradi mingi inaitegemea, kuna motisha kubwa kutoka kwa jamii ya kuiweka chini ya ukaguzi wa kila wakati. Ni kawaida zaidi kupata makosa katika nambari ya maombi kuliko katika maktaba za mkataba zinazoweza kutumika tena. Baadhi ya maktaba pia hupitia [ukaguzi wa nje](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/audits) kwa ajili ya usalama wa ziada.
+
+Hata hivyo, kutumia maktaba za mikataba mahiri kuna hatari ya kujumuisha msimbo usioufahamu katika mradi wako. Inajaribu kuagiza mkataba na kuujumuisha moja kwa moja kwenye mradi wako, lakini bila kuelewa vizuri mkataba huo hufanya nini, unaweza kuwa unaanzisha suala katika mfumo wako bila kukusudia kutokana na tabia isiyotarajiwa. Daima hakikisha umesoma hati za msimbo unaoingiza, na kisha uhakiki msimbo wenyewe kabla ya kuufanya kuwa sehemu ya mradi wako!
+
+Mwisho, unapoamua kujumuisha maktaba, zingatia matumizi yake kwa jumla. Ile iliyopitishwa na wengi ina manufaa ya kuwa na jumuiya kubwa na macho zaidi kuiangalia kwa masuala. Usalama unapaswa kuwa lengo lako la msingi wakati wa kujenga na mikataba smart!
+
+## Zana zinazohusiana {#related-tools}
+
+**OpenZeppelin Contracts -** **_Maktaba maarufu zaidi kwa maendeleo salama ya mikataba-erevu._**
+
+- [Nyaraka](https://docs.openzeppelin.com/contracts/)
+- [GitHub](https://github.com/OpenZeppelin/openzeppelin-contracts)
+- [Jukwaa la Jumuiya](https://forum.openzeppelin.com/c/general/16)
+
+**DappSys -** **_Vizuizi salama, rahisi na vinavyoweza kunyumbulika vya mikataba-erevu._**
+
+- [Nyaraka](https://dappsys.readthedocs.io/)
+- [GitHub](https://github.com/dapphub/dappsys)
+
+**HQ20 -** **_Mradi wa Solidity wenye mikataba, maktaba na mifano ya kukusaidia kujenga programu-tumizi zilizotawanywa zilizo na vipengele kamili kwa ajili ya ulimwengu halisi._**
+
+- [GitHub](https://github.com/HQ20/contracts)
+
+**thirdweb Solidity SDK -** **_Hutoa zana zinazohitajika ili kujenga mikataba-erevu maalum kwa ufanisi_**
+
+- [Nyaraka](https://portal.thirdweb.com/contracts/build/overview)
+- [GitHub](https://github.com/thirdweb-dev/contracts)
+
+## Mafunzo yanayohusiana {#related-tutorials}
+
+- [Mazingatio ya usalama kwa wasanidi programu wa Ethereum](/developers/docs/smart-contracts/security/) _– Mafunzo kuhusu mazingatio ya usalama wakati wa kujenga mikataba-erevu, ikijumuisha matumizi ya maktaba._
+- [Elewa mkataba-erevu wa tokeni ya ERC-20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _-Mafunzo kuhusu kiwango cha ERC20, yanayotolewa na maktaba nyingi._
+
+## Masomo zaidi {#further-reading}
+
+_Unajua rasilimali ya jamii iliyokusaidia?_ Hariri ukurasa huu na uiongeze!_
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/naming/index.md b/public/content/translations/sw/developers/docs/smart-contracts/naming/index.md
new file mode 100644
index 00000000000..dd3b9635901
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/naming/index.md
@@ -0,0 +1,101 @@
+---
+title: Kutaja mikataba-erevu
+description: Mbinu bora za kutaja mikataba-erevu ya Ethereum kwa kutumia ENS
+lang: sw
+---
+
+Mikataba-erevu ni msingi wa miundombinu iliyogatuliwa ya Ethereum, inayowezesha programu na itifaki zinazojiendesha. Lakini hata uwezo wa mikataba unavyoendelea kubadilika, watumiaji na wasanidi programu bado wanategemea anwani ghafi za heksadesimali kutambua na kurejelea mikataba hii.
+
+Kutaja mikataba-erevu kwa kutumia [Huduma ya Majina ya Ethereum (ENS)](https://ens.domains/) inaboresha hali ya utumiaji kwa kuondoa anwani za mkataba za heksadesimali na kupunguza hatari kutokana na mashambulizi kama vile sumu ya anwani na mashambulizi ya udanganyifu. Mwongozo huu unaeleza kwa nini kutaja mikataba-erevu ni muhimu, jinsi inaweza kutekelezwa, na zana zinazopatikana kama vile [Enscribe](https://www.enscribe.xyz) ili kurahisisha mchakato na kusaidia wasanidi programu kufuata utaratibu huu.
+
+## Kwa nini tutaje mikataba-erevu? {#why-name-contracts}
+
+### Vitambulisho vinavyoweza kusomwa na binadamu {#human-readable-identifiers}
+
+Badala ya kuingiliana na anwani za mkataba zisizoeleweka kama `0x8f8e...f9e3`, wasanidi programu na watumiaji wanaweza kutumia majina yanayoweza kusomwa na binadamu kama `v2.myapp.eth`. Hii hurahisisha mwingiliano wa mikataba-erevu.
+
+Hii inawezekana kutokana na [Huduma ya Majina ya Ethereum](https://ens.domains/) ambayo hutoa huduma ya majina iliyogatuliwa kwa anwani za Ethereum. Hii ni sawa na jinsi Huduma ya Majina ya Vikoa (DNS) inavyowezesha watumiaji wa intaneti kufikia anwani za mtandao kwa kutumia jina kama vile ethereum.org badala ya anwani ya IP kama vile `104.18.176.152`.
+
+### Usalama na uaminifu ulioboreshwa {#improved-security-and-trust}
+
+Mikataba iliyotajwa husaidia kupunguza miamala ya kimakosa kwenda kwenye anwani isiyo sahihi. Pia husaidia watumiaji kutambua mikataba inayohusishwa na programu au chapa maalum. Hii inaongeza safu ya uaminifu wa sifa, hasa wakati majina yameunganishwa na vikoa vikuu vinavyojulikana kama `uniswap.eth`.
+
+Kutokana na urefu wa herufi 42 za anwani ya Ethereum, ni vigumu sana kwa watumiaji kutambua mabadiliko madogo katika anwani, ambapo herufi chache zimebadilishwa. Kwa mfano, anwani kama `0x58068646C148E313CB414E85d2Fe89dDc3426870` kwa kawaida ingefupishwa hadi `0x580...870` na programu zinazotumiwa na watumiaji kama vile mikoba. Mtumiaji hawezi kugundua kwa urahisi anwani yenye nia mbaya ambapo herufi chache zimebadilishwa.
+
+Aina hii ya mbinu hutumiwa na mashambulizi ya udanganyifu wa anwani na sumu ambapo watumiaji huongozwa kuamini kuwa wanashirikiana na au kutuma fedha kwenye anwani sahihi, wakati kwa kweli anwani hiyo inafanana tu na anwani sahihi, lakini si sawa.
+
+Majina ya ENS kwa mikoba na mikataba hulinda dhidi ya aina hizi za mashambulizi. Kama mashambulizi ya udanganyifu wa DNS, mashambulizi ya udanganyifu wa ENS yanaweza pia kutokea, hata hivyo, mtumiaji ana uwezekano mkubwa wa kugundua makosa ya tahajia katika jina la ENS kuliko mabadiliko madogo kwenye anwani ya heksadesimali.
+
+### UX bora kwa mikoba na wachunguzi {#better-ux}
+
+Wakati mkataba-erevu umesanidiwa na jina la ENS, inawezekana kwa programu kama vile mikoba na wachunguzi wa mnyororo wa bloku kuonyesha majina ya ENS kwa mikataba-erevu, badala ya anwani za heksadesimali. Hii inatoa uboreshaji mkubwa wa hali ya utumiaji (UX) kwa watumiaji.
+
+Kwa mfano, wakati wa kuingiliana na programu kama vile Uniswap, watumiaji kwa kawaida wataona kuwa programu wanayoingiliana nayo inapatikana kwenye tovuti `uniswap.org`, lakini wangeonyeshwa anwani ya mkataba ya heksadesimali ikiwa Uniswap haijataja mikataba-erevu yake kwa kutumia ENS. Ikiwa mkataba umetajwa, badala yake wangeweza kuona `v4.contracts.uniswap.eth` ambayo ni muhimu zaidi.
+
+## Kutaja wakati wa upelekaji dhidi ya baada ya upelekaji {#when-to-name}
+
+Kuna alama mbili ambazo mikataba-erevu inaweza kutajwa:
+
+- **Wakati wa upelekaji**: kupeana jina la ENS kwa mkataba unapopelekwa.
+- **Baada ya upelekaji**: kuoanisha anwani ya mkataba iliyopo na jina jipya la ENS.
+
+Njia zote mbili zinategemea kuwa na ufikiaji wa mmiliki au msimamizi wa kikoa cha ENS ili waweze kuunda na kuweka rekodi za ENS.
+
+## Jinsi utajaji wa ENS unavyofanya kazi kwa mikataba {#how-ens-naming-works}
+
+Majina ya ENS huhifadhiwa kwenye mnyororo na hutatuliwa kwa anwani za Ethereum kupitia visuluhishi vya ENS. Ili kutaja mkataba-erevu:
+
+1. Sajili au dhibiti kikoa kikuu cha ENS (k.m. `myapp.eth`)
+2. Unda kikoa kidogo (k.m. `v1.myapp.eth`)
+3. Weka rekodi ya `address` ya kikoa kidogo kwenye anwani ya mkataba
+4. Weka rekodi ya nyuma ya mkataba kwenye ENS ili kuruhusu jina kupatikana kupitia anwani yake
+
+Majina ya ENS yana mpangilio wa daraja na yanasaidia majina madogo yasiyo na kikomo. Kuweka rekodi hizi kwa kawaida kunahusisha kuingiliana na sajili ya ENS na mikataba ya visuluhishi vya umma.
+
+## Zana za kutaja mikataba {#tools}
+
+Kuna njia mbili za kutaja mikataba-erevu. Ama kutumia [Programu ya ENS](https://app.ens.domains) na hatua kadhaa za mwongozo, au kutumia [Enscribe](https://www.enscribe.xyz). Hizi zimeainishwa hapa chini.
+
+### Usanidi wa mwongozo wa ENS {#manual-ens-setup}
+
+Kwa kutumia [Programu ya ENS](https://app.ens.domains/), wasanidi programu wanaweza kuunda majina madogo kwa mikono na kuweka rekodi za anwani za mbele. Hata hivyo, hawawezi kuweka jina la msingi kwa mkataba-erevu kwa kuweka rekodi ya nyuma ya jina kupitia programu ya ENS. Hatua za mwongozo lazima zichukuliwe ambazo zimeelezwa katika [nyaraka za ENS](https://docs.ens.domains/web/naming-contracts/).
+
+### Enscribe {#enscribe}
+
+[Enscribe](https://www.enscribe.xyz) hurahisisha utajaji wa mikataba-erevu kwa kutumia ENS, na huongeza imani ya mtumiaji katika mikataba-erevu. Inatoa:
+
+- **Upelekaji wa atomiki na utajaji**: Peana jina la ENS wakati wa kupeleka mkataba mpya
+- **Utajaji baada ya upelekaji**: Ambatisha majina kwenye mikataba iliyokwishapelekwa
+- **Usaidizi wa minyororo mingi**: Inafanya kazi katika mitandao ya Ethereum na L2 ambapo ENS inasaidiwa
+- **Data ya uthibitishaji wa mkataba**: Inajumuisha data ya uthibitishaji wa mkataba inayotolewa kutoka vyanzo vingi ili kuongeza imani kwa watumiaji
+
+Enscribe inasaidia majina ya ENS yaliyotolewa na watumiaji, au vikoa vyake ikiwa mtumiaji hana jina la ENS.
+
+Unaweza kufikia [Programu ya Enscribe](https://app.enscribe.xyz) ili kuanza kutaja na kutazama mikataba-erevu.
+
+## Mbinu bora {#best-practices}
+
+- **Tumia majina wazi, yenye matoleo** kama `v1.myapp.eth` ili kufanya masasisho ya mkataba kuwa wazi
+- **Weka rekodi za nyuma** ili kuunganisha mikataba na majina ya ENS kwa mwonekano katika programu kama vile mikoba na wachunguzi wa mnyororo wa bloku.
+- **Fuatilia kwa karibu tarehe za mwisho wa matumizi** ikiwa unataka kuzuia mabadiliko ya umiliki kwa bahati mbaya
+- **Thibitisha chanzo cha mkataba** ili watumiaji waweze kuamini kuwa mkataba uliotajwa unafanya kazi kama inavyotarajiwa
+
+## Hatari {#risks}
+
+Kutaja mikataba-erevu kunatoa manufaa makubwa kwa watumiaji wa Ethereum, hata hivyo, wamiliki wa vikoa vya ENS lazima wawe macho kuhusiana na usimamizi wao. Hatari zinazojulikana ni pamoja na:
+
+- **Kumalizika muda**: Kama vile majina ya DNS, usajili wa majina ya ENS una muda maalum. Kwa hivyo ni muhimu wamiliki wafuatilie tarehe za kumalizika kwa vikoa vyao na kuzifanya upya mapema kabla ya kumalizika. Programu ya ENS na Enscribe zote mbili hutoa viashiria vya kuona kwa wamiliki wa vikoa wakati tarehe ya kumalizika inapokaribia.
+- **Mabadiliko katika umiliki**: Rekodi za ENS zinawakilishwa kama NFTs kwenye Ethereum, ambapo mmiliki wa kikoa maalum cha `.eth` anamiliki NFT inayohusiana. Kwa hivyo, ikiwa akaunti tofauti itachukua umiliki wa NFT hii, mmiliki mpya anaweza kurekebisha rekodi zozote za ENS atakavyoona inafaa.
+
+Ili kupunguza hatari kama hizo, akaunti ya mmiliki wa vikoa vya kiwango cha pili (2LD) vya `.eth` inapaswa kulindwa kupitia mkoba wa saini-nyingi huku vikoa vidogo vikiundwa ili kusimamia utajaji wa mikataba. Kwa njia hiyo, katika tukio la mabadiliko yoyote ya umiliki kwa bahati mbaya au yenye nia mbaya katika kiwango cha kikoa kidogo, yanaweza kubatilishwa na mmiliki wa 2LD.
+
+## Mustakabali wa utajaji wa mikataba {#future}
+
+Utajaji wa mikataba unakuwa mbinu bora kwa ajili ya uundaji wa mfumo mtawanyo wa kimamlaka, sawa na jinsi majina ya vikoa yalivyochukua nafasi ya anwani za IP kwenye wavuti. Kadiri miundombinu zaidi kama vile mikoba, wachunguzi na dashibodi zinavyojumuisha usuluhishi wa ENS kwa mikataba, mikataba iliyotajwa itaboresha usalama na kupunguza makosa katika mfumo mzima wa ikolojia.
+
+Kwa kufanya mikataba-erevu iwe rahisi kutambua na kuelewa, utajaji husaidia kuziba pengo kati ya watumiaji na programu kwenye Ethereum, kuboresha usalama na UX kwa watumiaji.
+
+## Masomo zaidi {#further-reading}
+
+- [Kutaja Mikataba-erevu kwa kutumia ENS](https://docs.ens.domains/web/naming-contracts/)
+- [Kutaja Mikataba-erevu kwa kutumia Enscribe](https://www.enscribe.xyz/docs).
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/security/index.md b/public/content/translations/sw/developers/docs/smart-contracts/security/index.md
new file mode 100644
index 00000000000..4e31a0a62fc
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/security/index.md
@@ -0,0 +1,576 @@
+---
+title: Usalama wa mkataba erevu
+description: Muhtasari wa miongozo ya kuunda mikataba-erevu salama ya Ethereum
+lang: sw
+---
+
+Mikataba mahiri ni rahisi kubadilika, na ina uwezo wa kudhibiti kiwango kikubwa cha thamani na data, huku ikiendesha mantiki isiyobadilika kulingana na msimbo uliowekwa kwenye kiambajengo. Hii imeunda mfumo mzuri wa ikolojia wa programu zisizoaminika na zilizotawanywa ambazo hutoa faida nyingi juu ya mifumo ya urithi. Pia zinawakilisha fursa kwa washambuliaji wanaotafuta faida kwa kutumia udhaifu katika mikataba mahiri.
+
+Minyororo ya bloku ya umma, kama Ethereum, inazidisha ugumu wa suala la kulinda mikataba-erevu. Msimbo wa mkataba-erevu uliotumwa _kawaida_ hauwezi kubadilishwa ili kurekebisha dosari za usalama, ilhali mali zilizoibwa kutoka kwa mikataba-erevu ni ngumu sana kufuatilia na mara nyingi hazipatikani kwa sababu ya kutobadilika.
+
+Ingawa takwimu zinatofautiana, inakadiriwa kuwa jumla ya thamani iliyoibiwa au kupotea kutokana na kasoro za kiusalama katika mikataba mahiri ni zaidi ya $1 bilioni kwa urahisi. Hii inajumuisha matukio mashuhuri, kama vile [udukuzi wa DAO](https://hackingdistributed.com/2016/06/18/analysis-of-the-dao-exploit/) (ETH milioni 3.6 ziliibwa, zenye thamani ya zaidi ya dola bilioni 1 kwa bei za leo), [udukuzi wa mkoba wa Parity wenye saini nyingi](https://www.coindesk.com/markets/2017/07/19/30-million-ether-reported-stolen-due-to-parity-wallet-breach) (dola milioni 30 zilipotea kwa wadukuzi), na [suala la mkoba ulioganda wa Parity](https://www.theguardian.com/technology/2017/nov/08/cryptocurrency-300m-dollars-stolen-bug-ether) (zaidi ya dola milioni 300 za ETH zimefungiwa milele).
+
+Masuala yaliyotajwa hapo juu yanafanya kuwa muhimu kwa wasanifu programu kuwekeza juhudi katika kujenga mkataba mahiri iliyo salama, thabiti na inayostahimili uthabiti. Usalama wa mkataba-erevu ni jambo zito, na kila msanidi programu atafanya vizuri kujifunza. Mwongozo huu utashughulikia masuala ya usalama kwa wasanifu wa Ethereum na kuchunguza nyenzo za kuboresha usalama wa mikataba mahiri.
+
+## Mahitaji ya awali {#prerequisites}
+
+Hakikisha unafahamu [misingi ya usanidi wa mkataba-erevu](/developers/docs/smart-contracts/) kabla ya kushughulikia usalama.
+
+## Miongozo ya kuunda mikataba-erevu salama ya Ethereum {#smart-contract-security-guidelines}
+
+### 1. Buni vidhibiti sahihi vya ufikiaji {#design-proper-access-controls}
+
+Katika mikataba-erevu, vitendaji vilivyowekwa alama ya `public` au `external` vinaweza kuitwa na akaunti zozote zinazomilikiwa na nje (EOAs) au akaunti za mkataba. Kubainisha mwonekano wa umma kwa vipengele ni muhimu ikiwa unataka wengine kuingiliana na mkataba wako. Hata hivyo, vitendaji vilivyowekwa alama ya `private` vinaweza tu kuitwa na vitendaji ndani ya mkataba-erevu, na si akaunti za nje. Kumpa kila mshiriki wa mtandao ufikiaji wa kazi za mkataba kunaweza kusababisha shida, haswa ikiwa inamaanisha kuwa mtu yeyote anaweza kufanya shughuli nyeti (k.m., kutengeneza tokeni mpya).
+
+Ili kuzuia matumizi yasiyoidhinishwa ya vitendaji vya mkataba-erevu, ni muhimu kutekeleza vidhibiti salama vya ufikiaji. Mbinu za udhibiti wa ufikiaji huzuia uwezo wa kutumia kazi fulani katika mkataba mahiri kwa vyombo vilivyoidhinishwa, kama vile akaunti zinazowajibika kudhibiti mkataba. Muundo wa **Ownable** na **udhibiti unaotegemea majukumu** ni miundo miwili muhimu kwa kutekeleza udhibiti wa ufikiaji katika mikataba-erevu:
+
+#### Muundo wa Ownable {#ownable-pattern}
+
+Katika muundo wa Kumiliki, anwani imewekwa kama "mmiliki" wa mkataba wakati wa mchakato wa kuunda mkataba. Vitendaji vilivyolindwa hupewa kirekebishaji cha `OnlyOwner`, ambacho huhakikisha mkataba unathibitisha utambulisho wa anwani inayopiga simu kabla ya kutekeleza kitendaji. Simu za utendajikazi zinazolindwa kutoka kwa anwani zingine kando na mmiliki wa mkataba hurejeshwa kila wakati, na hivyo kuzuia ufikiaji usiohitajika.
+
+#### Udhibiti wa ufikiaji unaotegemea majukumu {#role-based-access-control}
+
+Kusajili anwani moja kama `Owner` katika mkataba-erevu huleta hatari ya uwekaji kati na huwakilisha sehemu moja ya kushindwa. Ikiwa funguo za akaunti ya mmiliki zitaathiriwa, washambuliaji wanaweza kushambulia mkataba unaomilikiwa. Hii ndiyo sababu kutumia muundo wa udhibiti wa ufikiaji wenye msingi wa dhima na akaunti nyingi za usimamizi inaweza kuwa chaguo bora.
+
+Katika udhibiti wa ufikiaji unaotegemea jukumu, ufikiaji wa vipengele nyeti husambazwa kati ya seti ya washiriki wanaoaminika. Kwa mfano, akaunti moja inaweza kuwa na jukumu la kutengeneza tokeni, huku akaunti nyingine ikifanya marekebisho au kusitisha mkataba. Kutawanya udhibiti wa ufikiaji kwa njia hii huondoa alama moja ya kutofaulu na kupunguza mawazo ya kuaminiana kwa watumiaji.
+
+##### Kutumia mikoba ya saini nyingi
+
+Njia nyingine ya kutekeleza udhibiti salama wa ufikiaji ni kutumia [akaunti ya saini nyingi](/developers/docs/smart-contracts/#multisig) kudhibiti mkataba. Tofauti na EOA ya kawaida, akaunti zenye sahihi ni nyingi zinamilikiwa na mamlaka nyingi na zinahitaji sahihi kutoka kwa idadi ya chini ya akaunti—sema 3-ya-5—ili kutekeleza miamala.
+
+Kutumia sahihi nyingi kwa udhibiti wa ufikiaji huleta safu ya ziada ya usalama kwani vitendo kwenye mkataba lengwa vinahitaji idhini kutoka kwa wahusika wengi. Hili ni muhimu hasa ikiwa ni muhimu kutumia muundo wa Kumiliki, kwa kuwa inafanya iwe vigumu zaidi kwa mshambulizi au mtu wa ndani kulaghai utendaji kazi nyeti wa mkataba kwa madhumuni mabaya.
+
+### 2. Tumia kauli za require(), assert(), na revert() kulinda utendakazi wa mkataba {#use-require-assert-revert}
+
+Kama ilivyotajwa, mtu yeyote anaweza kupiga simu kazi za umma katika mkataba wako mahiri mara tu utakapowekwa kwenye kiambajengo. Kwa kuwa huwezi kujua mapema jinsi akaunti za nje zitakavyoingiliana na mkataba, ni vyema kutekeleza ulinzi wa ndani dhidi ya utendaji kazi wenye matatizo kabla ya kupeleka. Unaweza kutekeleza tabia sahihi katika mikataba-erevu kwa kutumia kauli za `require()`, `assert()`, na `revert()` ili kusababisha vighairi na kurudisha mabadiliko ya hali ikiwa utekelezaji utashindwa kukidhi mahitaji fulani.
+
+**`require()`**: `require` hufafanuliwa mwanzoni mwa vitendaji na huhakikisha masharti yaliyowekwa awali yanatimizwa kabla ya kitendaji kilichoitwa kutekelezwa. Kauli ya `require` inaweza kutumika kuthibitisha ingizo la mtumiaji, kuangalia vigezo vya hali, au kuthibitisha utambulisho wa akaunti inayopiga simu kabla ya kuendelea na kitendaji.
+
+**`assert()`**: `assert()` hutumika kugundua makosa ya ndani na kuangalia ukiukaji wa “kanuni zisizobadilika” katika msimbo wako. Tofauti ni madai ya kimantiki kuhusu hali ya mkataba ambayo inapaswa kuwa ya kweli kwa utekelezaji wote wa kazi. Mfano wa kanuni isiyobadilika ni jumla ya kiwango cha juu cha usambazaji au salio la mkataba wa tokeni. Kutumia `assert()` huhakikisha kuwa mkataba wako haufikii hali hatarishi, na ikitokea, mabadiliko yote kwenye vigezo vya hali yanarejeshwa nyuma.
+
+**`revert()`**: `revert()` inaweza kutumika katika kauli ya if-else ambayo husababisha kighairi ikiwa hali inayohitajika haijatimizwa. Mkataba wa sampuli hapa chini unatumia `revert()` kulinda utekelezaji wa vitendaji:
+
+```
+pragma solidity ^0.8.4;
+
+contract VendingMachine {
+ address owner;
+ error Unauthorized();
+ function buy(uint amount) public payable {
+ if (amount > msg.value / 2 ether)
+ revert("Hakuna Ether ya kutosha iliyotolewa.");
+ // Tekeleza ununuzi.
+ }
+ function withdraw() public {
+ if (msg.sender != owner)
+ revert Unauthorized();
+
+ payable(msg.sender).transfer(address(this).balance);
+ }
+}
+```
+
+### 3. Pima mikataba-erevu na thibitisha usahihi wa msimbo {#test-smart-contracts-and-verify-code-correctness}
+
+Kutobadilika kwa msimbo unaoendeshwa katika [Mashine Halisi ya Ethereum](/developers/docs/evm/) kunamaanisha mikataba-erevu inahitaji kiwango cha juu cha tathmini ya ubora wakati wa awamu ya usanidi. Kupima mkataba wako kwa kina na kuuangalia kwa matokeo yoyote yasiyotarajiwa kutaboresha usalama kwa kiasi kikubwa na kulinda watumiaji wako kwa muda mrefu.
+
+Njia ya kawaida ni kuandika majaribio madogo ya vitengo kwa kutumia data ya mfano ambayo mkataba unatarajiwa kupokea kutoka kwa watumiaji. [Upimaji wa vitengo](/developers/docs/smart-contracts/testing/#unit-testing) ni mzuri kwa kupima utendakazi wa vitendaji fulani na kuhakikisha mkataba-erevu unafanya kazi kama inavyotarajiwa.
+
+Kwa bahati mbaya, upimaji wa vitengo hauna ufanisi mdogo katika kuboresha usalama wa mkataba-erevu unapotumika peke yake. Jaribio la kitengo linaweza kuthibitisha kuwa kitendaji kinajitekeleza vizuri kwa data ya mfano, lakini majaribio ya kitengo yana ufanisi tu kama majaribio yaliyoandikwa. Hii inafanya iwe vigumu kugundua visa vya pembeni vilivyokosekana na udhaifu ambao unaweza kuvunja usalama wa mkataba wako-erevu.
+
+Njia bora ni kuchanganya upimaji wa vitengo na upimaji unaotegemea sifa unaofanywa kwa kutumia [uchanganuzi tuli na unaobadilika](/developers/docs/smart-contracts/testing/#static-dynamic-analysis). Uchanganuzi tuli hutegemea uwakilishi wa kiwango cha chini, kama vile [grafu za mtiririko wa udhibiti](https://en.wikipedia.org/wiki/Control-flow_graph) na [miti dhahania ya sintaksia](https://deepsource.io/glossary/ast/) ili kuchanganua hali za programu zinazoweza kufikiwa na njia za utekelezaji. Wakati huo huo, mbinu za uchanganuzi unaobadilika, kama vile [uchanganyaji wa mkataba-erevu](https://www.cyfrin.io/blog/smart-contract-fuzzing-and-invariants-testing-foundry), hutekeleza msimbo wa mkataba na thamani za ingizo nasibu ili kugundua operesheni zinazokiuka sifa za usalama.
+
+[Uthibitishaji rasmi](/developers/docs/smart-contracts/formal-verification) ni mbinu nyingine ya kuthibitisha sifa za usalama katika mikataba-erevu. Tofauti na upimaji wa kawaida, uthibitishaji rasmi unaweza kuthibitisha kwa uhakika kutokuwepo kwa makosa katika mkataba-erevu. Hii inafanikiwa kwa kuunda vipimo rasmi ambavyo vinanasa sifa za usalama zinazohitajika na kuthibitisha kuwa muundo rasmi wa kandarasi unafuata vipimo hivi.
+
+### 4. Omba mapitio huru ya msimbo wako {#get-independent-code-reviews}
+
+Baada ya kupima mkataba wako, ni vizuri kuwaomba wengine wakague msimbo chanzo kwa masuala yoyote ya usalama. Majaribio hayatafichua kila dosari katika mkataba mzuri, lakini kupata hakiki huru huongeza uwezekano wa kugundua udhaifu.
+
+#### Ukaguzi {#audits}
+
+Kuagiza ukaguzi wa mkataba-erevu ni njia moja ya kufanya mapitio huru ya msimbo. Wakaguzi wana jukumu muhimu katika kuhakikisha kuwa mikataba mahiri ni salama na haina kasoro za ubora na hitilafu za muundo.
+
+Hata hivyo, unapaswa kuepuka kuchukulia ukaguzi kama suluhisho la kila kitu. Ukaguzi mahiri wa mikataba hautashika kila hitilafu na mara nyingi umeundwa ili kutoa ukaguzi wa ziada, ambao unaweza kusaidia kugundua matatizo ambayo wasanidi programu hawakuyapata wakati wa utayarishaji na majaribio ya awali. Unapaswa pia kufuata mbinu bora za kufanya kazi na wakaguzi, kama vile kuandika msimbo ipasavyo na kuongeza maoni ya ndani, ili kuongeza manufaa ya ukaguzi wa mikataba mahiri.
+
+- [Vidokezo na mbinu za ukaguzi wa mkataba-erevu](https://twitter.com/tinchoabbate/status/1400170232904400897) - _@tinchoabbate_
+- [Tumia ukaguzi wako kikamilifu](https://inference.ag/blog/2023-08-14-tips/) - _Inference_
+
+#### Zawadi za mdudu {#bug-bounties}
+
+Kuanzisha programu ya zawadi ya mdudu ni njia nyingine ya kutekeleza mapitio ya msimbo wa nje. Zawadi ya mdudu ni malipo ya kifedha yanayotolewa kwa watu binafsi (kawaida wadukuzi wa kofia nyeupe) wanaogundua udhaifu katika programu.
+
+Zikitumiwa ipasavyo, zawadi za mdudu huwapa wanachama wa jumuiya ya wadukuzi motisha wa kukagua msimbo wako kwa dosari muhimu. Mfano halisi ni "mdudu wa pesa usio na kikomo" ambao ungemruhusu mshambuliaji kuunda kiasi kisicho na kikomo cha ether kwenye [Optimism](https://www.optimism.io/), itifaki ya [Safu ya 2](/layer-2/) inayoendeshwa kwenye Ethereum. Kwa bahati nzuri, mdukuzi wa kofia nyeupe [aligundua dosari hiyo](https://www.saurik.com/optimism.html) na kuijulisha timu, [na kupata malipo makubwa katika mchakato huo](https://cryptoslate.com/critical-bug-in-ethereum-l2-optimism-2m-bounty-paid/).
+
+Mkakati muhimu ni kuweka malipo ya programu ya zawadi ya mdudu kulingana na kiasi cha fedha zilizo hatarini. Ikifafanuliwa kama "[zawadi ya mdudu ya kuongeza kiwango](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7)", njia hii hutoa motisha wa kifedha kwa watu binafsi kufichua udhaifu kwa uwajibikaji badala ya kuutumia.
+
+### 5. Fuata mbinu bora wakati wa usanidi wa mkataba-erevu {#follow-smart-contract-development-best-practices}
+
+Uwepo wa ukaguzi na zawadi za mdudu haukuondolei jukumu lako la kuandika msimbo wa hali ya juu. Usalama mzuri wa mkataba-erevu huanza na kufuata michakato sahihi ya usanifu na usanidi:
+
+- Hifadhi msimbo wote katika mfumo wa kudhibiti matoleo, kama vile git
+
+- Fanya marekebisho yote ya msimbo kupitia maombi ya kuvuta
+
+- Hakikisha maombi ya kuvuta yana angalau mkaguzi mmoja huru ikiwa unafanya kazi peke yako kwenye mradi, zingatia kutafuta wasanifu programu wengine na ukaguzi wa nambari za biashara
+
+- Tumia [mazingira ya usanidi](/developers/docs/frameworks/) kwa kupima, kuandaa, na kutuma mikataba-erevu
+
+- Pitia msimbo wako kupitia zana za msingi za uchambuzi wa msimbo, kama vile [Cyfrin Aderyn](https://github.com/Cyfrin/aderyn), Mythril na Slither. Kimsingi, unapaswa kufanya hivi kabla ya kila ombi la kuvuta kuunganishwa na kulinganisha tofauti katika matokeo
+
+- Hakikisha msimbo wako unakusanywa bila makosa, na mkusanyaji wa Solidity hatoi maonyo yoyote
+
+- Andika nyaraka za msimbo wako ipasavyo (ukitumia [NatSpec](https://solidity.readthedocs.io/en/develop/natspec-format.html)) na ueleze maelezo kuhusu usanifu wa mkataba katika lugha rahisi kueleweka. Hii itarahisisha wengine kukagua na kupitia msimbo wako.
+
+### 6. Tekeleza mipango thabiti ya kukabiliana na maafa {#implement-disaster-recovery-plans}
+
+Kubuni vidhibiti salama vya ufikiaji, kutekeleza virekebishaji vya utendaji kazi na mapendekezo mengine kunaweza kuboresha usalama wa mikataba mahiri, lakini hakuwezi kuondoa uwezekano wa matumizi mabaya. Kuunda mikataba mahiri iliyo salama kunahitaji "kujitayarisha kwa kutofaulu" na kuwa na mpango mbadala wa kujibu mashambulizi kwa ufanisi. Mpango sahihi wa kukabiliana na maafa utajumuisha baadhi au yote ya vipengele vifuatavyo:
+
+#### Uboreshaji wa mkataba {#contract-upgrades}
+
+Ingawa mikataba mahiri ya Ethereum haiwezi kubadilika kwa chaguo msingi, inawezekana kufikia kiwango fulani cha kubadilika kwa kutumia mifumo ya uboreshaji. Kuboresha mikataba ni muhimu katika hali ambapo kosa kubwa hufanya mkataba wako wa zamani kutotumika na kupeleka mantiki mpya ndilo chaguo linalowezekana zaidi.
+
+Mbinu za uboreshaji wa mikataba hufanya kazi tofauti, lakini "mchoro wa seva mbadala" ni mojawapo ya mbinu maarufu zaidi za kuboresha mikataba mahiri. [Miundo ya proksi](https://www.cyfrin.io/blog/upgradeable-proxy-smart-contract-pattern) hugawanya hali na mantiki ya programu kati ya mikataba _miwili_. Mkataba wa kwanza (unaoitwa ‘mkataba wa wakala’) huhifadhi vigezo vya hali (k.m., salio la mtumiaji), huku mkataba wa pili (unaoitwa ‘mkataba wa mantiki’) unashikilia msimbo wa kutekeleza majukumu ya mkataba.
+
+Akaunti huingiliana na mkataba wa proksi, ambao hupeleka simu zote za vitendaji kwa mkataba wa mantiki kwa kutumia simu ya kiwango cha chini ya [`delegatecall()`](https://docs.soliditylang.org/en/v0.8.16/introduction-to-smart-contracts.html?highlight=delegatecall#delegatecall-callcode-and-libraries). Tofauti na simu ya kawaida ya ujumbe, `delegatecall()` huhakikisha kuwa msimbo unaoendeshwa kwenye anwani ya mkataba wa mantiki unatekelezwa katika muktadha wa mkataba unaopiga simu. Hii inamaanisha kuwa mkataba wa mantiki utaandika kila wakati kwenye hifadhi ya proksi (badala ya hifadhi yake yenyewe) na thamani asili za `msg.sender` na `msg.value` huhifadhiwa.
+
+Kukabidhi simu kwa mkataba wa mantiki kunahitaji kuhifadhi anwani yake katika hifadhi ya mkataba wa wakala. Kwa hivyo, kuboresha mantiki ya mkataba ni suala la kupeleka mkataba mwingine wa kimantiki na kuhifadhi anwani mpya katika mkataba wa wakala. Simu zinazofuata kwa mkataba wa wakala zinapoelekezwa kiotomatiki hadi kwa mkataba mpya wa kimantiki, ungekuwa "umeboresha" mkataba bila kurekebisha msimbo.
+
+[Zaidi kuhusu uboreshaji wa mikataba](/developers/docs/smart-contracts/upgrading/).
+
+#### Vituo vya dharura {#emergency-stops}
+
+Kama ilivyoelezwa, ukaguzi na upimaji wa kina hauwezi kugundua mende zote kwenye mkataba-erevu. Athari ikitokea kwenye msimbo wako baada ya kutumwa, haiwezekani kuweka alama kwa kuwa huwezi kubadilisha msimbo unaotumika kwenye anwani ya mkataba. Pia, mbinu za uboreshaji (k.m., ruwaza za seva mbadala) zinaweza kuchukua muda kutekelezwa (mara nyingi zinahitaji idhini kutoka kwa wahusika tofauti), ambayo huwapa washambuliaji muda zaidi wa kusababisha uharibifu zaidi.
+
+Chaguo la nyuklia ni kutekeleza chaguo la kukokotoa la "kusimamisha dharura" ambalo huzuia simu kwa kazi zinazoweza kuathiriwa katika mkataba. Vituo vya dharura kwa kawaida hujumuisha vipengele vifuatavyo:
+
+1. Kigezo cha Boolean cha kimataifa kinachoonyesha ikiwa mkataba-erevu uko katika hali ya kusimamishwa au la. Kigezo hiki huwekwa kuwa `false` wakati wa kusanidi mkataba, lakini kitarudi kuwa `true` mara mkataba utakapositishwa.
+
+2. Vitendaji vinavyorejelea kigezo cha Boolean katika utekelezaji wao. Vipengele kama hivyo vinaweza kufikiwa wakati mkataba mahiri haujasimamishwa, na hutoweza kufikiwa wakati kipengele cha kusimamisha dharura kinapoanzishwa.
+
+3. Hulka yenye ufikiaji wa kitendaji cha kusimamisha dharura, ambacho huweka kigezo cha Boolean kuwa `true`. Ili kuzuia vitendo viovu, simu kwa chaguo hili la kazi zinaweza kuzuiwa kwa anwani inayoaminika (k.m., mmiliki wa mkataba).
+
+Mara tu mkataba unapowasha kituo cha dharura, vitendaji fulani havitaitika. Hii inafanikiwa kwa kufunga vitendaji teule katika kirekebishaji kinachorejelea kigezo cha kimataifa. Hapo chini ni [mfano](https://github.com/fravoll/solidity-patterns/blob/master/EmergencyStop/EmergencyStop.sol) unaoelezea utekelezaji wa muundo huu katika mikataba:
+
+```solidity
+// Msimbo huu haujakaguliwa kitaalamu na hautoi ahadi yoyote kuhusu usalama au usahihi. Tumia kwa hatari yako mwenyewe.
+
+contract EmergencyStop {
+
+ bool isStopped = false;
+
+ modifier stoppedInEmergency {
+ require(!isStopped);
+ _;
+ }
+
+ modifier onlyWhenStopped {
+ require(isStopped);
+ _;
+ }
+
+ modifier onlyAuthorized {
+ // Angalia uidhinishaji wa msg.sender hapa
+ _;
+ }
+
+ function stopContract() public onlyAuthorized {
+ isStopped = true;
+ }
+
+ function resumeContract() public onlyAuthorized {
+ isStopped = false;
+ }
+
+ function deposit() public payable stoppedInEmergency {
+ // Mantiki ya kuweka amana inatokea hapa
+ }
+
+ function emergencyWithdraw() public onlyWhenStopped {
+ // Utoaji wa dharura unatokea hapa
+ }
+}
+```
+
+Mfano huu unaonyesha sifa za msingi za vituo vya dharura:
+
+- `isStopped` ni Boolean inayotathminiwa kuwa `false` mwanzoni na `true` wakati mkataba unapoingia katika hali ya dharura.
+
+- Virekebishaji vya vitendaji `onlyWhenStopped` na `stoppedInEmergency` hukagua kigezo cha `isStopped`. `stoppedInEmergency` hutumika kudhibiti vitendaji ambavyo havipaswi kufikiwa wakati mkataba uko hatarini (k.m., `deposit()`). Simu kwa vitendaji hivi zitarudi nyuma tu.
+
+`onlyWhenStopped` hutumika kwa vitendaji ambavyo vinapaswa kuitika wakati wa dharura (k.m., `emergencyWithdraw()`). Kazi kama hizo zinaweza kusaidia kutatua hali hiyo, kwa hivyo kutengwa kwao kutoka kwa orodha ya "kazi zilizozuiliwa".
+
+Kutumia utendaji kazi wa kusimamisha dharura kunatoa mwanya mzuri wa kushughulika na udhaifu mkubwa katika mkataba wako mahiri. Hata hivyo, huongeza hitaji la watumiaji kuamini wasanidi programu kutoiwasha kwa sababu za kibinafsi. Kufikia hili, kugatua udhibiti wa kituo cha dharura ama kwa kukiweka chini ya utaratibu wa upigaji kura wa mtandaoni, kufunga saa, au uidhinishaji kutoka kwa mikoba ya sahihi nyingni suluhisho zinazowezekana.
+
+#### Ufuatiliaji wa matukio {#event-monitoring}
+
+[Matukio](https://docs.soliditylang.org/en/v0.8.15/contracts.html#events) hukuruhusu kufuatilia simu kwa vitendaji vya mkataba-erevu na kufuatilia mabadiliko kwenye vigezo vya hali. Ni vyema kupanga mkataba wako mahiri ili kutangaza tukio wakati wowote mhusika anachukua hatua muhimu ya usalama (k.m., kutoa pesa).
+
+Kuweka matukio na kuyafuatilia nje ya mnyororo hutoa maarifa juu ya utendakazi wa mikataba na kusaidia ugunduzi wa haraka wa vitendo viovu. Hii inamaanisha kuwa timu yako inaweza kukabiliana haraka na udukuzi na kuchukua hatua ili kupunguza athari kwa watumiaji, kama vile kusitisha utendakazi au kufanya uboreshaji.
+
+Unaweza pia kuchagua zana ya ufuatiliaji ya nje ya rafu ambayo inasambaza arifa kiotomatiki wakati wowote mtu anapoingiliana na mikataba yako. Zana hizi zitakuruhusu kuunda arifa maalum kulingana na vichochezi tofauti, kama vile kiasi cha muamala, marudio ya simu za utendakazi, au vipengele maalum vinavyohusika. Kwa mfano, unaweza kupanga arifa inayokuja wakati kiasi kilichotolewa katika muamala mmoja kinavuka kiwango fulani.
+
+### 7. Buni mifumo salama ya utawala {#design-secure-governance-systems}
+
+Unaweza kutaka kugawa ombi lako kwa kugeuza udhibiti wa kandarasi za msingi kwa wanajamii. Katika hali hii, mfumo mahiri wa kandarasi utajumuisha moduli ya utawala utaratibu unaoruhusu wanajamii kuidhinisha vitendo vya usimamizi kupitia mfumo wa utawala wa mnyororo. Kwa mfano, pendekezo la kuboresha mkataba wa wakala hadi utekelezaji mpya linaweza kupigiwa kura na wenye tokeni.
+
+Utawala uliogawanyika unaweza kuwa wa manufaa, hasa kwa sababu unapatanisha maslahi ya wasanifu programu na watumiaji wa mwisho. Hata hivyo, mbinu mahiri za usimamizi wa mikataba zinaweza kuleta hatari mpya zikitekelezwa kimakosa. Hali inayowezekana ni ikiwa mshambuliaji anapata nguvu kubwa ya kupiga kura (inayopimwa kwa idadi ya tokeni zilizoshikiliwa) kwa kuchukua [mkopo wa ghafla](/defi/#flash-loans) na kusukuma pendekezo ovu.
+
+Njia moja ya kuzuia matatizo yanayohusiana na utawala kwenye mnyororo ni [kutumia kufuli ya muda](https://blog.openzeppelin.com/protect-your-users-with-smart-contract-timelocks/). Kufunga muda huzuia mkataba mahiri kutekeleza vitendo fulani hadi muda mahususi upite. Mikakati mingine ni pamoja na kugawa "uzito wa kupiga kura" kwa kila tokeni kulingana na muda ambao imekuwa imefungwa, au kupima uwezo wa kupiga kura wa anwani katika kipindi cha kihistoria (kwa mfano, vitalu 2-3 hapo awali) badala ya kizuizi cha sasa. Njia zote mbili hupunguza uwezekano wa kukusanya haraka nguvu ya kupiga kura ili kubadilisha kura kwenye mnyororo.
+
+Zaidi kuhusu [kubuni mifumo salama ya utawala](https://blog.openzeppelin.com/smart-contract-security-guidelines-4-strategies-for-safer-governance-systems/), [mifumo tofauti ya upigaji kura katika DAO](https://hackernoon.com/governance-is-the-holy-grail-for-daos), na [vejeta za kawaida za mashambulizi ya DAO zinazotumia DeFi](https://dacian.me/dao-governance-defi-attacks) katika viungo vilivyoshirikiwa.
+
+### 8. Punguza utata katika msimbo kwa kiwango cha chini {#reduce-code-complexity}
+
+Wasanidi programu wa jadi wanafahamu kanuni ya KISS (“weka rahisi, mjinga”), ambayo inashauri dhidi ya kuleta utata usio wa lazima katika usanifu wa programu. Hii inafuata fikra ya muda mrefu kwamba “mifumo tata hushindwa kwa njia tata” na iko katika hatari zaidi ya makosa ya gharama kubwa.
+
+Kuweka mambo rahisi ni muhimu sana wakati wa kuandika mikataba mahiri, ikizingatiwa kwamba mikataba mahiri inaweza kudhibiti kiwango kikubwa cha thamani. Kidokezo cha kufikia urahisi unapoandika mikataba-erevu ni kutumia tena maktaba zilizopo, kama vile [OpenZeppelin Contracts](https://docs.openzeppelin.com/contracts/5.x/), inapowezekana. Kwa sababu maktaba hizi zimekaguliwa sana na kujaribiwa na wasanifu programu, kuzitumia hupunguza uwezekano wa kuibua makosa kwa kuandika utendaji kazi mpya kuanzia mwanzo.
+
+Ushauri mwingine wa kawaida ni kuandika kazi ndogo ndogo na kuweka mikataba ya kawaida kwa kugawanya mantiki ya biashara katika mikataba mingi. Sio tu kwamba kuandika msimbo rahisi hupunguza eneo la mashambulizi katika mkataba mahiri, pia hurahisisha kufikiria juu ya usahihi wa mfumo mzima na kugundua makosa yanayoweza kutokea ya muundo mapema.
+
+### 9. Jilinde dhidi ya udhaifu wa kawaida wa mkataba-erevu {#mitigate-common-smart-contract-vulnerabilities}
+
+#### Uingiaji upya {#reentrancy}
+
+EVM hairuhusu upatanishi, kumaanisha kuwa mikataba miwili inayohusika katika simu ya ujumbe haiwezi kutekelezwa kwa wakati mmoja. Simu ya nje inasitisha utekelezaji wa mkataba wa kupiga simu na kumbukumbu hadi simu irudi, wakati ambapo utekelezaji unaendelea kama kawaida. Mchakato huu unaweza kuelezewa rasmi kama kuhamisha [mtiririko wa udhibiti](https://www.computerhope.com/jargon/c/contflow.htm) kwenda kwa mkataba mwingine.
+
+Ingawa mara nyingi haina madhara, kuhamisha mtiririko wa udhibiti kwa mikataba isiyoaminika inaweza kusababisha matatizo, kama vile kurejea tena. Shambulio la kurejesha tena hutokea wakati mkataba mbovu unaporejesha kwenye mkataba unaoweza kuathiriwa kabla ya ombi la awali la utendaji kazi kukamilika. Aina hii ya shambulio inaelezewa vizuri zaidi kwa mfano.
+
+Fikiria mkataba-erevu rahisi ('Mhanga') unaomruhusu yeyote kuweka na kutoa ether:
+
+```solidity
+// Mkataba huu una udhaifu. Usitumie katika uzalishaji
+
+contract Victim {
+ mapping (address => uint256) public balances;
+
+ function deposit() external payable {
+ balances[msg.sender] += msg.value;
+ }
+
+ function withdraw() external {
+ uint256 amount = balances[msg.sender];
+ (bool success, ) = msg.sender.call.value(amount)("");
+ require(success);
+ balances[msg.sender] = 0;
+ }
+}
+```
+
+Mkataba huu unafichua kitendaji cha `withdraw()` ili kuruhusu watumiaji kutoa ETH iliyowekwa awali kwenye mkataba. Wakati wa kuchakata utoaji, mkataba hufanya operesheni zifuatazo:
+
+1. Hukagua salio la ETH la mtumiaji
+2. Hutuma fedha kwa anwani inayopiga simu
+3. Huweka upya salio lao kuwa 0, kuzuia utoaji wa ziada kutoka kwa mtumiaji
+
+Kitendaji cha `withdraw()` katika mkataba wa `Victim` hufuata muundo wa “ukaguzi-maingiliano-athari”. _Hukagua_ ikiwa masharti muhimu kwa utekelezaji yanatimizwa (yaani, mtumiaji ana salio chanya la ETH) na hufanya _maingiliano_ kwa kutuma ETH kwa anwani ya mpigaji, kabla ya kutumia _athari_ za muamala (yaani, kupunguza salio la mtumiaji).
+
+Ikiwa `withdraw()` inaitwa kutoka kwa akaunti inayomilikiwa na nje (EOA), kitendaji hutekelezwa kama inavyotarajiwa: `msg.sender.call.value()` hutuma ETH kwa mpigaji. Hata hivyo, ikiwa `msg.sender` ni akaunti ya mkataba-erevu inayoita `withdraw()`, kutuma fedha kwa kutumia `msg.sender.call.value()` pia kutasababisha msimbo uliohifadhiwa kwenye anwani hiyo kuendeshwa.
+
+Fikiria huu ndio msimbo uliotumwa kwenye anwani ya mkataba:
+
+```solidity
+ contract Attacker {
+ function beginAttack() external payable {
+ Victim(victim_address).deposit.value(1 ether)();
+ Victim(victim_address).withdraw();
+ }
+
+ function() external payable {
+ if (gasleft() > 40000) {
+ Victim(victim_address).withdraw();
+ }
+ }
+}
+```
+
+Mkataba huu umebuniwa kufanya mambo matatu:
+
+1. Kubali amana kutoka kwa akaunti nyingine (labda EOA ya mshambuliaji)
+2. Weka ETH 1 kwenye mkataba wa Mhanga
+3. Toa ETH 1 iliyohifadhiwa kwenye mkataba-erevu
+
+Hakuna tatizo hapa, isipokuwa `Attacker` ana kitendaji kingine kinachoita `withdraw()` katika `Victim` tena ikiwa gesi iliyobaki kutoka kwa `msg.sender.call.value` inayoingia ni zaidi ya 40,000. Hii inampa `Attacker` uwezo wa kuingia tena `Victim` na kutoa fedha zaidi _kabla_ ya wito wa kwanza wa `withdraw` kukamilika. Mzunguko unaonekana hivi:
+
+```solidity
+- EOA ya Mshambuliaji inaita `Attacker.beginAttack()` na ETH 1
+- `Attacker.beginAttack()` inaweka ETH 1 kwenye `Victim`
+- `Attacker` inaita `withdraw()` katika `Victim`
+- `Victim` inakagua salio la `Attacker` (ETH 1)
+- `Victim` inatuma ETH 1 kwa `Attacker` (ambayo inasababisha kitendaji cha chaguo-msingi)
+- `Attacker` inaita `Victim.withdraw()` tena (kumbuka kwamba `Victim` haijapunguza salio la `Attacker` kutoka kwa utoaji wa kwanza)
+- `Victim` inakagua salio la `Attacker` (ambalo bado ni ETH 1 kwa sababu haijatumia athari za simu ya kwanza)
+- `Victim` inatuma ETH 1 kwa `Attacker` (ambayo inasababisha kitendaji cha chaguo-msingi na kumruhusu `Attacker` kuingia tena kwenye kitendaji cha `withdraw`)
+- Mchakato unarudiwa hadi `Attacker` aishiwe na gesi, ambapo `msg.sender.call.value` inarudi bila kusababisha utoaji wa ziada
+- `Victim` hatimaye inatumia matokeo ya muamala wa kwanza (na zinazofuata) kwenye hali yake, hivyo salio la `Attacker` linawekwa kuwa 0
+```
+
+Muhtasari ni kwamba kwa sababu salio la mpigaji simu halijawekwa kuwa 0 hadi utekelezaji wa chaguo la kazi ukamilike, maombi yatakayofuata yatafaulu na kumruhusu mpigaji simu kuondoa salio lake mara nyingi. Aina hii ya shambulio inaweza kutumika kumaliza fedha za mkataba-erevu, kama ilivyotokea katika [udukuzi wa DAO wa 2016](https://www.coindesk.com/learn/understanding-the-dao-attack). Mashambulio ya uingiaji upya bado ni suala muhimu kwa mikataba-erevu leo kama [orodha za umma za unyonyaji wa uingiaji upya](https://github.com/pcaversaccio/reentrancy-attacks) zinavyoonyesha.
+
+##### Jinsi ya kuzuia mashambulio ya uingiaji upya
+
+Njia moja ya kushughulikia uingiaji upya ni kufuata [muundo wa ukaguzi-athari-maingiliano](https://docs.soliditylang.org/en/develop/security-considerations.html#use-the-checks-effects-interactions-pattern). Mchoro huu huamuru utekelezaji wa chaguo za kukokotoa kwa njia ambayo msimbo unaofanya ukaguzi unaohitajika kabla ya kuendelea na utekelezaji huja kwanza, ikifuatiwa na msimbo unaodhibiti hali ya mkataba, na msimbo unaoingiliana na mikataba mingine au EOA zinazofika mwisho.
+
+Muundo wa ukaguzi-athari-maingiliano unatumika katika toleo lililorekebishwa la mkataba wa `Victim` ulioonyeshwa hapa chini:
+
+```solidity
+contract NoLongerAVictim {
+ function withdraw() external {
+ uint256 amount = balances[msg.sender];
+ balances[msg.sender] = 0;
+ (bool success, ) = msg.sender.call.value(amount)("");
+ require(success);
+ }
+}
+```
+
+Mkataba huu hufanya _ukaguzi_ kwenye salio la mtumiaji, hutumia _athari_ za kitendaji cha `withdraw()` (kwa kuweka upya salio la mtumiaji kuwa 0), na huendelea kufanya _maingiliano_ (kutuma ETH kwa anwani ya mtumiaji). Hii inahakikisha kwamba mkataba unasasisha hifadhi yake kabla ya simu ya nje, kuondoa hali ya kuingia tena iliyowezesha shambulio la kwanza. Mkataba wa `Attacker` bado ungeweza kurudi nyuma kwenye `NoLongerAVictim`, lakini kwa kuwa `balances[msg.sender]` imewekwa kuwa 0, utoaji wa ziada utatupa kosa.
+
+Chaguo jingine ni kutumia kufuli ya kujumuisha (inayojulikana kama "mutex") ambayo hufunga sehemu ya hali ya mkataba hadi ombi la kukokotoa likamilike. Hii inatekelezwa kwa kutumia kigezo cha Boolean ambacho huwekwa kuwa `true` kabla ya kitendaji kutekelezwa na kurudi kuwa `false` baada ya wito kukamilika. Kama inavyoonekana katika mfano ulio hapa chini, kutumia mwito hulinda chaguo za kukokotoa dhidi ya simu zinazorudiwa wakati ombi la asili likiendelea kuchakatwa, hivyo basi kusimamisha kwa njia sahihi kurejesha.
+
+```solidity
+pragma solidity ^0.7.0;
+
+contract MutexPattern {
+ bool locked = false;
+ mapping(address => uint256) public balances;
+
+ modifier noReentrancy() {
+ require(!locked, "Umezuiliwa kuingia upya.");
+ locked = true;
+ _;
+ locked = false;
+ }
+ // Kitendaji hiki kinalindwa na mutex, kwa hivyo simu za kuingia upya kutoka ndani ya `msg.sender.call` haziwezi kuita `withdraw` tena.
+ // Kauli ya `return` inatathminiwa kuwa `true` lakini bado inatathmini kauli ya `locked = false` katika kirekebishaji
+ function withdraw(uint _amount) public payable noReentrancy returns(bool) {
+ require(balances[msg.sender] >= _amount, "Hakuna salio la kutoa.");
+
+ balances[msg.sender] -= _amount;
+ (bool success, ) = msg.sender.call{value: _amount}("");
+ require(success);
+
+ return true;
+ }
+}
+```
+
+Unaweza pia kutumia mfumo wa [malipo ya kuvuta](https://docs.openzeppelin.com/contracts/5.x/api/security#PullPayment) unaohitaji watumiaji kutoa fedha kutoka kwa mikataba-erevu, badala ya mfumo wa "malipo ya kusukuma" unaotuma fedha kwenye akaunti. Hii huondoa uwezekano wa kuanzisha msimbo bila kukusudia katika anwani zisizojulikana (na pia inaweza kuzuia mashambulizi fulani ya kunyimwa huduma).
+
+#### Kupungua na kufurika kwa nambari kamili {#integer-underflows-and-overflows}
+
+Kuongezeka kamili hutokea wakati matokeo ya utendaji kazi wa hesabu yanapotoka nje ya anuwai ya thamani zinazokubalika, na kusababisha "kupinduka" hadi thamani ya chini kabisa inayoweza kuwakilishwa. Kwa mfano, `uint8` inaweza tu kuhifadhi thamani hadi 2^8-1=255. Operesheni za hesabu zinazosababisha thamani za juu kuliko `255` zitafurika na kuweka upya `uint` kuwa `0`, sawa na jinsi odomita kwenye gari inavyowekwa upya kuwa 0 mara inapofikia maili ya juu zaidi (999999).
+
+Kupungua kupita kiasi kwa namba kamili chini ya thamanini inayoweza kuwakilishwa hutokea kwa sababu sawa: matokeo ya utekelezaji ya hesabu huanguka chini ya masafa yanayokubalika. Sema ulijaribu kupunguza `0` katika `uint8`, matokeo yangevuka tu hadi thamani ya juu inayoweza kuwakilishwa (`255`).
+
+Kujaza kamili na kupunguka kunaweza kusababisha mabadiliko yasiyotarajiwa kwa vigezo vya hali ya mkataba na kusababisha utekelezaji usiopangwa. Ufuatao ni mfano unaoonyesha jinsi mshambulizi anavyoweza kutumia wingi wa hesabu katika mikataba mahiri ili kutekeleza utekelezaji usio sahihi:
+
+```
+pragma solidity ^0.7.6;
+
+// Mkataba huu umebuniwa kufanya kazi kama hifadhi ya muda.
+// Mtumiaji anaweza kuweka amana kwenye mkataba huu lakini hawezi kutoa kwa angalau wiki moja.
+// Mtumiaji anaweza pia kuongeza muda wa kusubiri zaidi ya kipindi cha kusubiri cha wiki 1.
+
+/*
+1. Tumia TimeLock
+2. Tumia Attack na anwani ya TimeLock
+3. Ita Attack.attack ukituma ether 1. Utaweza mara moja
+ kutoa ether yako.
+
+Nini kilitokea?
+Attack ilisababisha TimeLock.lockTime kufurika na iliweza kutoa
+kabla ya kipindi cha kusubiri cha wiki 1.
+*/
+
+contract TimeLock {
+ mapping(address => uint) public balances;
+ mapping(address => uint) public lockTime;
+
+ function deposit() external payable {
+ balances[msg.sender] += msg.value;
+ lockTime[msg.sender] = block.timestamp + 1 weeks;
+ }
+
+ function increaseLockTime(uint _secondsToIncrease) public {
+ lockTime[msg.sender] += _secondsToIncrease;
+ }
+
+ function withdraw() public {
+ require(balances[msg.sender] > 0, "Fedha haitoshi");
+ require(block.timestamp > lockTime[msg.sender], "Muda wa kufunga haujaisha");
+
+ uint amount = balances[msg.sender];
+ balances[msg.sender] = 0;
+
+ (bool sent, ) = msg.sender.call{value: amount}("");
+ require(sent, "Imeshindwa kutuma Ether");
+ }
+}
+
+contract Attack {
+ TimeLock timeLock;
+
+ constructor(TimeLock _timeLock) {
+ timeLock = TimeLock(_timeLock);
+ }
+
+ fallback() external payable {}
+
+ function attack() public payable {
+ timeLock.deposit{value: msg.value}();
+ /*
+ kama t = muda wa sasa wa kufunga basi tunahitaji kupata x kiasi kwamba
+ x + t = 2**256 = 0
+ hivyo x = -t
+ 2**256 = type(uint).max + 1
+ hivyo x = type(uint).max + 1 - t
+ */
+ timeLock.increaseLockTime(
+ type(uint).max + 1 - timeLock.lockTime(address(this))
+ );
+ timeLock.withdraw();
+ }
+}
+```
+
+##### Jinsi ya kuzuia kupungua na kufurika kwa nambari kamili
+
+Kuanzia toleo la 0.8.0, mkusanyaji wa Solidity hukataa msimbo unaosababisha kupungua na kufurika kwa nambari kamili. Hata hivyo, mikataba iliyokusanywa na toleo la chini la mkusanyaji inapaswa kufanya ukaguzi kwenye vitendaji vinavyohusisha operesheni za hesabu au kutumia maktaba (k.m., [SafeMath](https://docs.openzeppelin.com/contracts/2.x/api/math)) inayokagua kupungua/kufurika.
+
+#### Udanganyifu wa Oracle {#oracle-manipulation}
+
+[Maneno](/developers/docs/oracles/) hupata taarifa nje ya mnyororo na kuituma kwenye mnyororo ili mikataba-erevu itumie. Ukiwa na maneno, unaweza kubuni mikataba mahiri ambayo inashirikiana na mifumo ya nje ya mnyororo, kama vile masoko ya mitaji, na kupanua matumizi yao kwa kiasi kikubwa.
+
+Lakini ikiwa chumba cha ndani kimeharibika na kutuma taarifa zisizo sahihi kwenye mnyororo, mikataba mahiri itatekelezwa kulingana na maingizo yenye makosa, ambayo yanaweza kusababisha matatizo. Huu ndio msingi wa "tatizo la chanzo cha data cha nje", ambalo linahusu kazi ya kuhakikisha habari kutoka kwa chumba cha kuzuia kiambajengo ni sahihi, ya kisasa na ya wakati.
+
+Hoja inayohusiana na usalama ni kutumia oracle ya onchain, kama vile ubadilishanaji wa madaraka, ili kupata bei halisi ya mali. Mifumo ya ukopeshaji katika tasnia ya [fedha zilizogatuliwa (DeFi)](/defi/) mara nyingi hufanya hivi ili kubaini thamani ya dhamana ya mtumiaji ili kubaini ni kiasi gani wanaweza kukopa.
+
+Bei za DEX mara nyingi huwa sahihi, hasa kutokana na wasuluhishi kurejesha usawa katika masoko. Hata hivyo, zinaweza kubadilishwa, hasa ikiwa chumba cha ndani cha mnyororo hukokotoa bei za vipengee kulingana na mifumo ya kihistoria ya biashara (kama kawaida).
+
+Kwa mfano, mshambulizi anaweza kusukuma bei ya bidhaa kwa njia isiyo halali kwa kuchukua mkopo wa haraka kabla ya kuingiliana na mkataba wako wa ukopeshaji. Kuuliza DEX kwa bei ya kipengee kunaweza kurudisha thamani ya juu kuliko ya kawaida (kutokana na hitaji kubwa la mvamizi la "kununua" la kipengee), na kuwaruhusu kukopa zaidi ya inavyopaswa. "Mashambulizi ya mkopo wa flash" kama hayo yametumiwa kutumia utegemezi wa maneno ya bei kati ya programu za DeFi, na kugharimu itifaki za mamilioni ya pesa zilizopotea.
+
+##### Jinsi ya kuzuia udanganyifu wa oracle
+
+Sharti la chini kabisa la [kuepuka udanganyifu wa oracle](https://www.cyfrin.io/blog/price-oracle-manipultion-attacks-with-examples) ni kutumia mtandao wa oracle uliogatuliwa unaouliza taarifa kutoka vyanzo vingi ili kuepuka sehemu moja ya kushindwa. Mara nyingi, chanzo cha data cha nje kilichotawanywa huwa na motisha za kiuchumi za kikriptomito ili kuhimiza nodi za oracle kuripoti habari sahihi, na kuzifanya kuwa salama zaidi kuliko chanzo cha data cha kati.
+
+Ikiwa unapanga kuuliza chanzo cha data cha ndani ya mnyororo kwa bei za mali, zingatia kutumia ile inayotekeleza utaratibu wa wastani wa bei uliopimwa kwa wakati (TWAP). Oracle ya [TWAP](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/oracles) huuliza bei ya mali kwa nyakati mbili tofauti (ambazo unaweza kurekebisha) na kukokotoa bei ya papo hapo kulingana na wastani uliopatikana. Kuchagua muda mrefu hulinda itifaki yako dhidi ya udanganyifu wa bei kwa kuwa maagizo makubwa yaliyotekelezwa hivi majuzi hayawezi kuathiri bei za mali.
+
+## Rasilimali za usalama wa mkataba-erevu kwa wasanidi programu {#smart-contract-security-resources-for-developers}
+
+### Zana za kuchambua mikataba-erevu na kuthibitisha usahihi wa msimbo {#code-analysis-tools}
+
+- **[Zana na maktaba za upimaji](/developers/docs/smart-contracts/testing/#testing-tools-and-libraries)** - _Mkusanyiko wa zana na maktaba za kiwango cha tasnia za kufanya majaribio ya kitengo, uchambuzi tuli, na uchambuzi unaobadilika kwenye mikataba-erevu._
+
+- **[Zana za uthibitishaji rasmi](/developers/docs/smart-contracts/formal-verification/#formal-verification-tools)** - _Zana za kuthibitisha usahihi wa utendaji katika mikataba-erevu na kuangalia kanuni zisizobadilika._
+
+- **[Huduma za ukaguzi wa mkataba-erevu](/developers/docs/smart-contracts/testing/#smart-contract-auditing-services)** - _Orodha ya mashirika yanayotoa huduma za ukaguzi wa mkataba-erevu kwa miradi ya maendeleo ya Ethereum._
+
+- **[Mifumo ya zawadi za mdudu](/developers/docs/smart-contracts/testing/#bug-bounty-platforms)** - _Mifumo ya kuratibu zawadi za mdudu na kuthawabisha ufichuzi wa kuwajibika wa udhaifu muhimu katika mikataba-erevu._
+
+- **[Kikagua Uma](https://forkchecker.hashex.org/)** - _Zana ya mtandaoni isiyolipishwa ya kuangalia taarifa zote zinazopatikana kuhusu mkataba uliogawanywa._
+
+- **[Kisimbaji cha ABI](https://abi.hashex.org/)** - _Huduma ya mtandaoni isiyolipishwa ya kusimba vitendaji vya mkataba wako wa Solidity na hoja za ujenzi._
+
+- **[Aderyn](https://github.com/Cyfrin/aderyn)** - _Kichanganuzi Tuli cha Solidity, kinachopitia Miti ya Sintaksia Dhahania (AST) ili kubainisha udhaifu unaoshukiwa na kuchapisha masuala katika umbizo la markdown linalotumika kwa urahisi._
+
+### Zana za ufuatiliaji wa mikataba-erevu {#smart-contract-monitoring-tools}
+
+- **[Arifa za Wakati Halisi za Tenderly](https://tenderly.co/monitoring)** - _Zana ya kupata arifa za wakati halisi wakati matukio yasiyo ya kawaida au yasiyotarajiwa yanapotokea kwenye mikataba yako erevu au mikoba._
+
+### Zana za usimamizi salama wa mikataba-erevu {#smart-contract-administration-tools}
+
+- **[Safe](https://safe.global/)** - _Mkoba wa mkataba-erevu unaoendeshwa kwenye Ethereum unaohitaji idadi ya chini ya watu kuidhinisha muamala kabla haujatokea (M-of-N)._
+
+- **[OpenZeppelin Contracts](https://docs.openzeppelin.com/contracts/5.x/)** - _Maktaba za mikataba za kutekeleza vipengele vya kiutawala, ikiwa ni pamoja na umiliki wa mkataba, uboreshaji, vidhibiti vya ufikiaji, utawala, uwezo wa kusitishwa, na zaidi._
+
+### Huduma za ukaguzi wa mkataba-erevu {#smart-contract-auditing-services}
+
+- **[ConsenSys Diligence](https://diligence.consensys.io/)** - _Huduma ya ukaguzi wa mkataba-erevu inayosaidia miradi katika mfumo mzima wa mnyororo wa bloku kuhakikisha itifaki zao ziko tayari kwa uzinduzi na zimejengwa ili kuwalinda watumiaji._
+
+- **[CertiK](https://www.certik.com/)** - _Kampuni ya usalama ya mnyororo wa bloku inayoanzisha matumizi ya teknolojia ya kisasa ya Uthibitishaji rasmi kwenye mikataba-erevu na mitandao ya mnyororo wa bloku._
+
+- **[Trail of Bits](https://www.trailofbits.com/)** - _Kampuni ya usalama wa mtandao inayochanganya utafiti wa usalama na mtazamo wa mshambuliaji ili kupunguza hatari na kuimarisha msimbo._
+
+- **[PeckShield](https://peckshield.com/)** - _Kampuni ya usalama ya mnyororo wa bloku inayotoa bidhaa na huduma kwa ajili ya usalama, faragha, na utumiaji wa mfumo mzima wa mnyororo wa bloku._
+
+- **[QuantStamp](https://quantstamp.com/)** - _Huduma ya ukaguzi inayowezesha upitishaji mkuu wa teknolojia ya mnyororo wa bloku kupitia huduma za usalama na tathmini ya hatari._
+
+- **[OpenZeppelin](https://www.openzeppelin.com/security-audits)** - _Kampuni ya usalama wa mkataba-erevu inayotoa ukaguzi wa usalama kwa mifumo iliyogatuliwa._
+
+- **[Runtime Verification](https://runtimeverification.com/)** - _Kampuni ya usalama inayobobea katika uundaji rasmi na uthibitishaji wa mikataba-erevu._
+
+- **[Hacken](https://hacken.io)** - _Mkaguzi wa usalama wa mtandao wa Web3 anayeleta mbinu ya 360-degree kwa usalama wa mnyororo wa bloku._
+
+- **[Nethermind](https://www.nethermind.io/smart-contract-audits)** - _Huduma za ukaguzi za Solidity na Cairo, zinazohakikisha uadilifu wa mikataba-erevu na usalama wa watumiaji kote Ethereum na Starknet._
+
+- **[HashEx](https://hashex.org/)** - _HashEx inazingatia ukaguzi wa mnyororo wa bloku na mkataba-erevu ili kuhakikisha usalama wa sarafu za kidigitali, ikitoa huduma kama vile maendeleo ya mkataba-erevu, upimaji wa kupenya, ushauri wa mnyororo wa bloku._
+
+- **[Code4rena](https://code4rena.com/)** - _Jukwaa la ukaguzi shindani linalowapa motisha wataalam wa usalama wa mkataba-erevu kutafuta udhaifu na kusaidia kufanya web3 iwe salama zaidi._
+
+- **[CodeHawks](https://codehawks.com/)** - _Jukwaa la ukaguzi shindani linaloandaa mashindano ya ukaguzi wa mikataba-erevu kwa watafiti wa usalama._
+
+- **[Cyfrin](https://cyfrin.io)** - _Nguvu ya usalama ya Web3, inayokuza usalama wa crypto kupitia bidhaa na huduma za ukaguzi wa mkataba-erevu._
+
+- **[ImmuneBytes](https://immunebytes.com/smart-contract-audit/)** - _Kampuni ya usalama ya Web3 inayotoa ukaguzi wa usalama kwa mifumo ya mnyororo wa bloku kupitia timu ya wakaguzi wenye uzoefu na zana bora zaidi._
+
+- **[Oxorio](https://oxor.io/)** - _Ukaguzi wa mikataba-erevu na huduma za usalama za mnyororo wa bloku zenye utaalamu katika EVM, Solidity, ZK, teknolojia ya minyororo-tofauti kwa kampuni za crypto na miradi ya DeFi._
+
+- **[Inference](https://inference.ag/)** - _Kampuni ya ukaguzi wa usalama, iliyobobea katika ukaguzi wa mkataba-erevu kwa minyororo ya bloku inayotegemea EVM. Shukrani kwa wakaguzi wake waliobobea, wanatambua matatizo yanayoweza kutokea na kupendekeza njia zinazoweza kuchukuliwa ili kuyasuluhisha kabla ya kutumwa._
+
+### Mifumo ya zawadi za mdudu {#bug-bounty-platforms}
+
+- **[Immunefi](https://immunefi.com/)** - _Jukwaa la zawadi za mdudu kwa mikataba-erevu na miradi ya DeFi, ambapo watafiti wa usalama hupitia msimbo, hufichua udhaifu, hulipwa, na kufanya crypto iwe salama zaidi._
+
+- **[HackerOne](https://www.hackerone.com/)** - _Jukwaa la uratibu wa udhaifu na zawadi za mdudu linalounganisha biashara na wapimaji wa kupenya na watafiti wa usalama wa mtandao._
+
+- **[HackenProof](https://hackenproof.com/)** - _Jukwaa la kitaalamu la zawadi za mdudu kwa miradi ya crypto (DeFi, Mikataba-erevu, Mikoba, CEX na zaidi), ambapo wataalamu wa usalama hutoa huduma za uchunguzi na watafiti hulipwa kwa ripoti za mdudu zinazofaa na zilizothibitishwa._
+
+- **[Sherlock](https://www.sherlock.xyz/)** - _Mtoa dhamana katika Web3 kwa usalama wa mkataba-erevu, na malipo kwa wakaguzi yanasimamiwa kupitia mikataba-erevu ili kuhakikisha kwamba mende husika zinalipwa kwa haki._
+
+- **[CodeHawks](https://www.codehawks.com/)** - _Jukwaa la ushindani la zawadi za mdudu ambapo wakaguzi hushiriki katika mashindano na changamoto za usalama, na (hivi karibuni) katika ukaguzi wao wa kibinafsi._
+
+### Machapisho ya udhaifu na unyonyaji unaojulikana wa mkataba-erevu {#common-smart-contract-vulnerabilities-and-exploits}
+
+- **[ConsenSys: Mashambulizi Yanayojulikana ya Mkataba-erevu](https://consensysdiligence.github.io/smart-contract-best-practices/attacks/)** - _Maelezo rahisi kwa wanaoanza kuhusu udhaifu muhimu zaidi wa mkataba, na msimbo wa sampuli kwa visa vingi._
+
+- **[Rejesta ya SWC](https://swcregistry.io/)** - _Orodha iliyoratibiwa ya vitu vya Uorodheshaji wa Udhaifu wa Kawaida (CWE) vinavyotumika kwa mikataba-erevu ya Ethereum._
+
+- **[Rekt](https://rekt.news/)** - _Chapisho linalosasishwa mara kwa mara la udukuzi na unyonyaji wa hali ya juu wa crypto, pamoja na ripoti za kina za baada ya tukio._
+
+### Changamoto za kujifunza usalama wa mkataba-erevu {#challenges-for-learning-smart-contract-security}
+
+- **[Awesome BlockSec CTF](https://github.com/blockthreat/blocksec-ctfs)** - _Orodha iliyoratibiwa ya michezo ya vita ya usalama wa mnyororo wa bloku, changamoto, na mashindano ya [Kamata Bendera](https://www.webopedia.com/definitions/ctf-event/amp/) na maelezo ya suluhisho._
+
+- **[Damn Vulnerable DeFi](https://www.damnvulnerabledefi.xyz/)** - _Mchezo wa vita wa kujifunza usalama wa mashambulizi wa mikataba-erevu ya DeFi na kujenga ujuzi katika uwindaji wa mende na ukaguzi wa usalama._
+
+- **[Ethernaut](https://ethernaut.openzeppelin.com/)** - _Mchezo wa vita unaotegemea Web3/Solidity ambapo kila ngazi ni mkataba-erevu unaohitaji 'kudukuliwa'._
+
+- **[HackenProof x HackTheBox](https://app.hackthebox.com/tracks/HackenProof-Track)** - _Changamoto ya udukuzi wa mkataba-erevu, iliyowekwa katika matukio ya njozi. Kukamilisha changamoto kwa mafanikio pia kunatoa ufikiaji kwa programu ya kibinafsi ya zawadi za mdudu._
+
+### Mbinu bora za kulinda mikataba-erevu {#smart-contract-security-best-practices}
+
+- **[ConsenSys: Mbinu Bora za Usalama wa Mkataba-erevu wa Ethereum](https://consensys.github.io/smart-contract-best-practices/)** - _Orodha pana ya miongozo ya kulinda mikataba-erevu ya Ethereum._
+
+- **[Nascent: Zana Rahisi ya Usalama](https://github.com/nascentxyz/simple-security-toolkit)** - _Mkusanyiko wa miongozo na orodha za ukaguzi zinazozingatia usalama kwa maendeleo ya mkataba-erevu._
+
+- **[Miundo ya Solidity](https://fravoll.github.io/solidity-patterns/)** - _Mkusanyiko muhimu wa miundo salama na mbinu bora za lugha ya programu ya mkataba-erevu Solidity._
+
+- **[Nyaraka za Solidity: Mambo ya Kuzingatia ya Usalama](https://docs.soliditylang.org/en/v0.8.16/security-considerations.html)** - _Miongozo ya kuandika mikataba-erevu salama na Solidity._
+
+- **[Kiwango cha Uthibitishaji wa Usalama wa Mkataba-erevu](https://github.com/securing/SCSVS)** - _Orodha ya ukaguzi ya sehemu kumi na nne iliyoundwa ili kusawazisha usalama wa mikataba-erevu kwa wasanidi programu, wasanifu, wakaguzi wa usalama na wachuuzi._
+
+- **[Jifunze Usalama na Ukaguzi wa Mkataba-erevu](https://updraft.cyfrin.io/courses/security)** - _Kozi ya mwisho ya usalama na ukaguzi wa mkataba-erevu, iliyoundwa kwa wasanidi programu wa mikataba-erevu wanaotaka kuboresha mbinu zao bora za usalama na kuwa watafiti wa usalama._
+
+### Mafunzo kuhusu usalama wa mkataba-erevu {#tutorials-on-smart-contract-security}
+
+- [Jinsi ya kuandika mikataba-erevu salama](/developers/tutorials/secure-development-workflow/)
+
+- [Jinsi ya kutumia Slither kupata mende za mkataba-erevu](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
+
+- [Jinsi ya kutumia Manticore kupata mende za mkataba-erevu](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
+
+- [Miongozo ya usalama wa mkataba-erevu](/developers/tutorials/smart-contract-security-guidelines/)
+
+- [Jinsi ya kuunganisha kwa usalama mkataba wako wa tokeni na tokeni holela](/developers/tutorials/token-integration-checklist/)
+
+- [Cyfrin Updraft - Kozi kamili ya usalama na ukaguzi wa mikataba-erevu](https://updraft.cyfrin.io/courses/security)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/testing/index.md b/public/content/translations/sw/developers/docs/smart-contracts/testing/index.md
new file mode 100644
index 00000000000..784519a0c52
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/testing/index.md
@@ -0,0 +1,310 @@
+---
+title: Kujaribu mikataba ya mahiri
+description: Muhtasari wa mbinu na mazingatio ya kupima mikataba-erevu ya Ethereum.
+lang: sw
+---
+
+Minyororo ya kiambajengo cha umma kama vile Ethereum hakiwezi kubadilika, hivyo kufanya iwe vigumu kubadilisha msimbo wa mikataba mahiri baada ya kutumwa. [Mifumo ya kuboresha mikataba](/developers/docs/smart-contracts/upgrading/) kwa ajili ya kufanya "maboresho ya mtandaoni" ipo, lakini hii ni vigumu kuitekeleza na inahitaji makubaliano ya kijamii. Zaidi ya hayo, sasisho linaweza kurekebisha hitilafu _baada_ ya kugunduliwa—ikiwa mshambulizi atagundua udhaifu kwanza, mkataba wako-erevu uko katika hatari ya kutumiwa vibaya.
+
+Kwa sababu hizi, kupima mikataba-erevu kabla ya [kupeleka](/developers/docs/smart-contracts/deploying/) kwenye Mtandao Mkuu ni sharti la chini kabisa kwa [usalama](/developers/docs/smart-contracts/security/). Kuna mbinu nyingi za kupima mikataba na kutathmini usahihi wa kanuni, unachochagua kunategemea mahitaji yako. Hata hivyo kundi la majaribio linaloundwa na zana na mbinu tofauti ni bora kwa kupata dosari ndogo na kuu za usalama katika msimbo wa mkataba.
+
+## Mahitaji ya awali {#prerequisites}
+
+Ukurasa huu unaelezea jinsi ya kupima mikataba-erevu kabla ya kuipeleka kwenye mtandao wa Ethereum. Inachukulia kuwa unafahamu [mikataba-erevu](/developers/docs/smart-contracts/).
+
+## Upimaji wa mkataba-erevu ni nini? {#what-is-smart-contract-testing}
+
+Majaribio ya mkataba mahiri ni mchakato wa kuthibitisha kuwa msimbo wa mkataba mahiri hufanya kazi inavyotarajiwa. Majaribio ni muhimu kwa kuthibitisha kama mkataba mahiri unakidhi mahitaji ya kutegemewa, utumiaji na usalama.
+
+Ingawa mbinu hutofautiana, mbinu nyingi za majaribio zinahitaji kutekeleza mkataba mahiri na sampuli ndogo ya data inayotarajiwa kushughulikia. Ikiwa mkataba utatoa matokeo sahihi kwa data ya sampuli, inachukuliwa kuwa unafanya kazi ipasavyo. Zana nyingi za upimaji hutoa rasilimali za kuandika na kutekeleza [kesi za majaribio](https://en.m.wikipedia.org/wiki/Test_case) ili kuangalia kama utekelezaji wa mikataba unalingana na matokeo yanayotarajiwa.
+
+### Kwa nini ni muhimu kupima mikataba-erevu? {#importance-of-testing-smart-contracts}
+
+Kwa kuwa mikataba-erevu mara nyingi hudhibiti mali za kifedha za thamani ya juu, makosa madogo ya programu yanaweza na mara nyingi husababisha [hasara kubwa kwa watumiaji](https://rekt.news/leaderboard/). Majaribio thabiti yanaweza, hata hivyo, kukusaidia kugundua kasoro na matatizo katika msimbo mahiri wa mkataba na kuyarekebisha kabla ya kuzindua kwenye Mainnet.
+
+Ingawa inawezekana kuboresha mkataba ikiwa hitilafu itagunduliwa, maboresho ni magumu na yanaweza [kusababisha makosa](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) ikiwa hayatashughulikiwa ipasavyo. Kuboresha mkataba kunakanusha zaidi kanuni ya kutobadilika na kubebea watumiaji mawazo ya ziada ya uaminifu. Kinyume chake, mpango wa kina wa kupima mkataba wako hupunguza hatari za usalama wa mkataba na kupunguza hitaji la kufanya maboresho changamano baada ya kupeleka.
+
+## Mbinu za kupima mikataba-erevu {#methods-for-testing-smart-contracts}
+
+Mbinu za kupima mikataba-erevu ya Ethereum ziko chini ya kategoria mbili pana: **upimaji wa kiotomatiki** na **upimaji wa mikono**. Majaribio ya kiotomatiki na majaribio ya mikono hutoa manufaa ya kipekee na usuluhishi, lakini unaweza kuchanganya zote mbili ili kuunda mpango thabiti wa kuchanganua mikataba yako.
+
+### Upimaji wa kiotomatiki {#automated-testing}
+
+Jaribio la kiotomatiki hutumia zana zinazokagua kiotomatiki msimbo mahiri wa mikataba kwa hitilafu katika utekelezaji. Faida ya upimaji wa kiotomatiki hutokana na kutumia [skripti](https://www.techtarget.com/whatis/definition/script?amp=1) kuongoza tathmini ya utendakazi wa mkataba. Majaribio ya hati yanaweza kuratibiwa kufanya kazi mara kwa mara bila uingiliaji kati wa binadamu, hivyo kufanya majaribio ya kiotomatiki kuwa na ufanisi zaidi kuliko mbinu za mikono za majaribio.
+
+Jaribio la kiotomatiki ni muhimu sana wakati majaribio yanarudiwa na kuchukua muda; ngumu kutekeleza kwa mikono; hushambuliwa na makosa ya kibinadamu; au kuhusisha kutathmini kazi muhimu za mkataba. Lakini zana za kupima za kiotomatiki zinaweza kuwa na hasara—zinaweza kukosa hitilafu fulani na kutoa [chanya za uwongo](https://www.contrastsecurity.com/glossary/false-positive) nyingi. Hivyo, kuoanisha upimaji wa kiotomatiki na upimaji wa mikono kwa mikataba-erevu ni bora.
+
+### Upimaji wa mikono {#manual-testing}
+
+Uthibitishaji wa mikono linasaidiwa na binadamu na linahusisha kutekeleza kila kesi ya jaribio katika kundi lako la majaribio moja baada ya jingine wakati wa kuchanganua usahihi wa mikataba mahiri. Hii ni tofauti na majaribio ya kiotomatiki ambapo unaweza kufanya majaribio mengi ya pekee kwenye mkataba kwa wakati mmoja na kupata ripoti inayoonyesha majaribio yote yaliyofeli na kufaulu.
+
+Jaribio la kibinafsi linaweza kufanywa na mtu mmoja kufuatia mpango wa jaribio ulioandikwa ambao unashughulikia hali tofauti za majaribio. Unaweza pia kuwa na watu au vikundi vingi kushirikiana na mkataba mzuri katika kipindi fulani kama sehemu ya majaribio ya mikono. Wanaojaribu watalinganisha tabia halisi ya mkataba dhidi ya tabia inayotarajiwa, kuashiria tofauti yoyote kama kosa.
+
+Upimaji wa mwongozo unaofaa unahitaji rasilimali nyingi (ustadi, muda, pesa, na juhudi), na inawezekana—kutokana na makosa ya kibinadamu—kukosa makosa fulani wakati wa kufanya majaribio. Lakini uthibitishaji kwa mkono kunaweza pia kuwa na manufaa—kwa mfano, mtu anayejaribu (k.m., mkaguzi) anaweza kutumia angavu kutambua matukio makali ambayo chombo cha kupima kiotomatiki kinaweza kukosa.
+
+## Upimaji wa kiotomatiki kwa mikataba-erevu {#automated-testing-for-smart-contracts}
+
+### Upimaji wa vitengo {#unit-testing-for-smart-contracts}
+
+Upimaji wa kitengo hutathmini utendaji kazi wa mkataba kando na hukagua kuwa kila sehemu inafanya kazi kwa usahihi. Majaribio mazuri ya vipimo yanapaswa kuwa rahisi, ya haraka na kutoa wazo wazi la nini kilienda vibaya ikiwa majaribio hayatafaulu.
+
+Majaribio ya vipimo ni muhimu kwa kuangalia kuwa chaguo za kukokotoa hurejesha thamani zinazotarajiwa na kwamba hifadhi ya mkataba inaboreshashwa ipasavyo baada ya kutekeleza utendaji kazi. Zaidi ya hayo, kufanya majaribio ya kitengo baada ya kufanya mabadiliko kwa msingi wa mikataba huhakikisha kuongeza mantiki mpya hakuleti makosa. Hapa chini kuna miongozo ya kufanya upimaji wa vitengo kwa ufanisi:
+
+#### Miongozo ya upimaji wa vitengo vya mikataba-erevu {#unit-testing-guidelines}
+
+##### 1. Elewa mantiki ya biashara na mtiririko wa kazi wa mikataba yako
+
+Kabla ya kuandika uthibitishaji wa vipimo, inasaidia kujua ni utendaji gani ambao mkataba mahiri hutoa na jinsi watumiaji watakavyofikia na kutumia vipengele hivyo. Hii ni muhimu hasa kwa kufanya [majaribio ya njia ya furaha](https://en.m.wikipedia.org/wiki/Happy_path) ambayo huamua kama utendakazi katika mkataba hurejesha matokeo sahihi kwa ingizo halali za watumiaji. Tutaeleza dhana hii kwa kutumia mfano huu (uliofupishwa) wa [mkataba wa mnada](https://docs.soliditylang.org/en/v0.8.17/solidity-by-example.html?highlight=Auction%20contract#simple-open-auction)
+
+```solidity
+constructor(
+ uint biddingTime,
+ address payable beneficiaryAddress
+ ) {
+ beneficiary = beneficiaryAddress;
+ auctionEndTime = block.timestamp + biddingTime;
+ }
+
+function bid() external payable {
+
+ if (block.timestamp > auctionEndTime)
+ revert AuctionAlreadyEnded();
+
+ if (msg.value <= highestBid)
+ revert BidNotHighEnough(highestBid);
+
+ if (highestBid != 0) {
+ pendingReturns[highestBidder] += highestBid;
+ }
+ highestBidder = msg.sender;
+ highestBid = msg.value;
+ emit HighestBidIncreased(msg.sender, msg.value);
+ }
+
+ function withdraw() external returns (bool) {
+ uint amount = pendingReturns[msg.sender];
+ if (amount > 0) {
+ pendingReturns[msg.sender] = 0;
+
+ if (!payable(msg.sender).send(amount)) {
+ pendingReturns[msg.sender] = amount;
+ return false;
+ }
+ }
+ return true;
+ }
+
+function auctionEnd() external {
+ if (block.timestamp < auctionEndTime)
+ revert AuctionNotYetEnded();
+ if (ended)
+ revert AuctionEndAlreadyCalled();
+
+ ended = true;
+ emit AuctionEnded(highestBidder, highestBid);
+
+ beneficiary.transfer(highestBid);
+ }
+}
+```
+
+Huu ni mkataba rahisi wa mnada ulioundwa kupokea zabuni wakati wa kipindi cha kutoa zabuni. Ikiwa `highestBid` itaongezeka, mzabuni wa awali aliyetoa zabuni ya juu zaidi hupokea pesa zake; mara tu kipindi cha zabuni kinapoisha, `beneficiary` huita mkataba ili kupata pesa zake.
+
+Upimaji wa vitengo kwa mkataba kama huu ungejumuisha utendakazi tofauti ambao mtumiaji anaweza kuita anapoingiliana na mkataba. Mfano ungekuwa upimaji wa kitengo unaoangalia ikiwa mtumiaji anaweza kuweka zabuni wakati mnada unaendelea (yaani, wito kwa `bid()` hufaulu) au unaoangalia ikiwa mtumiaji anaweza kuweka zabuni ya juu kuliko `highestBid` ya sasa.
+
+Kuelewa mtiririko wa kazi wa utendaji wa mkataba pia husaidia katika kuandika upimaji wa vitengo unaoangalia ikiwa utekelezaji unakidhi mahitaji. Kwa mfano, mkataba wa mnada unabainisha kuwa watumiaji hawawezi kuweka zabuni wakati mnada umeisha (yaani, wakati `auctionEndTime` ni chini kuliko `block.timestamp`). Kwa hivyo, msanidi programu anaweza kufanya upimaji wa kitengo unaoangalia ikiwa wito kwa utendakazi wa `bid()` hufaulu au hushindwa wakati mnada umeisha (yaani, wakati `auctionEndTime` > `block.timestamp`).
+
+##### 2. Tathmini dhana zote zinazohusiana na utekelezaji wa mkataba
+
+Ni muhimu kuweka kumbukumbu ya dhana zozote kuhusu utekelezaji wa mkataba na kuandika upimaji wa vitengo ili kuthibitisha uhalali wa dhana hizo. Mbali na kutoa ulinzi dhidi ya utekelezaji usiotarajiwa, madai ya upimaji yanakulazimisha kufikiria juu ya shughuli ambazo zinaweza kuvunja mfumo wa usalama wa mkataba-erevu. Kidokezo muhimu ni kwenda mbali zaidi ya "majaribio ya mtumiaji mwenye furaha" na kuandika majaribio hasi yanayoangalia ikiwa utendakazi unashindwa kwa ingizo zisizo sahihi.
+
+Mifumo mingi ya upimaji wa vitengo inakuruhusu kuunda madai—kauli rahisi zinazoeleza kile mkataba unaweza na hauwezi kufanya—na kufanya majaribio kuona ikiwa madai hayo yanadumu chini ya utekelezaji. Msanidi programu anayeshughulikia mkataba wa mnada ulioelezwa hapo awali anaweza kutoa madai yafuatayo kuhusu tabia yake kabla ya kufanya majaribio hasi:
+
+- Watumiaji hawawezi kuweka zabuni wakati mnada umeisha au haujaanza.
+
+- Mkataba wa mnada hurejea nyuma ikiwa zabuni iko chini ya kiwango kinachokubalika.
+
+- Watumiaji wanaoshindwa kushinda zabuni hurejeshewa fedha zao
+
+**Kumbuka**: Njia nyingine ya kupima dhana ni kuandika majaribio yanayoanzisha [virekebishaji vya utendakazi](https://docs.soliditylang.org/en/v0.8.16/contracts.html#function-modifiers) katika mkataba, hasa kauli za `require`, `assert`, na `if…else`.
+
+##### 3. Pima ufikiaji wa msimbo
+
+[Ufikiaji wa msimbo](https://en.m.wikipedia.org/wiki/Code_coverage) ni kipimo cha upimaji kinachofuatilia idadi ya matawi, mistari, na kauli katika msimbo wako zilizotekelezwa wakati wa majaribio. Majaribio yanapaswa kuwa na ufikiaji mzuri wa msimbo ili kupunguza hatari ya udhaifu ambao haujapimwa. Bila ufikiaji wa kutosha, unaweza kudhani kimakosa kuwa mkataba wako ni salama kwa sababu majaribio yote yamefaulu, wakati udhaifu bado upo katika njia za msimbo ambazo hazijapimwa. Hata hivyo, kurekodi ufikiaji wa juu wa msimbo kunatoa uhakikisho kwamba kauli/utendakazi wote katika mkataba-erevu vilipimwa vya kutosha kwa usahihi.
+
+##### 4. Tumia mifumo ya upimaji iliyoendelezwa vizuri
+
+Ubora wa zana zinazotumika katika kufanya upimaji wa vitengo kwa mikataba-erevu yako ni muhimu sana. Mfumo bora wa upimaji ni ule unaotunzwa mara kwa mara; hutoa vipengele muhimu (k.m., uwezo wa kukata kumbukumbu na kutoa ripoti); na lazima uwe umetumiwa sana na kuchunguzwa na wasanidi programu wengine.
+
+Mifumo ya upimaji wa vitengo kwa mikataba-erevu ya Solidity huja katika lugha tofauti (zaidi JavaScript, Python, na Rust). Angalia baadhi ya miongozo hapa chini kwa taarifa juu ya jinsi ya kuanza kufanya upimaji wa vitengo na mifumo tofauti ya upimaji:
+
+- **[Kufanya upimaji wa vitengo na Brownie](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)**
+- **[Kufanya upimaji wa vitengo na Foundry](https://book.getfoundry.sh/forge/writing-tests)**
+- **[Kufanya upimaji wa vitengo na Waffle](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests)**
+- **[Kufanya upimaji wa vitengo na Remix](https://remix-ide.readthedocs.io/en/latest/unittesting.html#write-tests)**
+- **[Kufanya upimaji wa vitengo na Ape](https://docs.apeworx.io/ape/stable/userguides/testing.html)**
+- **[Kufanya upimaji wa vitengo na Hardhat](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)**
+- **[Kufanya upimaji wa vitengo na Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)**
+
+### Upimaji wa ujumuishaji {#integration-testing-for-smart-contracts}
+
+Wakati uthibitishaji wa vipimo hutatua kazi za mkataba kwa kutengwa, majaribio ya ujumuishaji hutathmini vipengele vya mkataba mahiri kwa ujumla. Jaribio la ujumuishaji linaweza kugundua matatizo yanayotokana na simu za mkataba mtambuka au mwingiliano kati ya utendakazi tofauti katika mkataba huo mahiri. Kwa mfano, majaribio ya ujumuishaji yanaweza kusaidia kuangalia kama mambo kama [urithi](https://docs.soliditylang.org/en/v0.8.12/contracts.html#inheritance) na sindano ya utegemezi hufanya kazi ipasavyo.
+
+Jaribio la ujumuishaji ni muhimu ikiwa mkataba wako utakubali usanifu wa kawaida au miingiliano na mikataba mingine ya onchain wakati wa utekelezaji. Njia moja ya kufanya majaribio ya ujumuishaji ni [kufanya uma mnyororo wa bloku](/glossary/#fork) katika urefu maalum (kwa kutumia zana kama [Forge](https://book.getfoundry.sh/forge/fork-testing) au [Hardhat](https://hardhat.org/hardhat-network/docs/guides/forking-other-networks) na kuiga mwingiliano kati ya mkataba wako na mikataba iliyopelekwa.
+
+Kiambajengo kiliyogawanyika itafanya kazi sawa na Mainnet na kuwa na akaunti na majimbo na salio zinazohusiana. Lakini inafanya kazi tu kama mazingira ya maendeleo ya ndani yaliyowekwa mchanga, kumaanisha kuwa hutahitaji ETH halisi kwa shughuli, kwa mfano, wala mabadiliko yako hayataathiri itifaki halisi ya Ethereum.
+
+### Upimaji unaozingatia sifa {#property-based-testing-for-smart-contracts}
+
+Upimaji kulingana na mali ni mchakato wa kuangalia kama mkataba mzuri unakidhi baadhi ya mali iliyobainishwa. Sifa huthibitisha ukweli kuhusu tabia ya mkataba ambao unatarajiwa kubaki kuwa kweli katika hali tofauti-mfano wa mali mahiri ya mkataba unaweza kuwa "Shughuli za hesabu katika mkataba kamwe hazifuriki au hazifukiwi."
+
+**Uchambuzi tuli** na **uchambuzi wa nguvu** ni mbinu mbili za kawaida za kutekeleza upimaji unaozingatia sifa, na zote mbili zinaweza kuthibitisha kuwa msimbo wa programu (mkataba-erevu katika kesi hii) unakidhi sifa fulani iliyoainishwa awali. Baadhi ya zana za kupima kulingana na mali huja na sheria zilizobainishwa mapema kuhusu sifa za mkataba zinazotarajiwa na kuangalia msimbo dhidi ya sheria hizo, huku zingine hukuruhusu kuunda sifa maalum kwa mkataba mzuri.
+
+#### Uchambuzi tuli {#static-analysis}
+
+Kichanganuzi tuli huchukua msimbo wa chanzo wa mkataba mahiri kama ingizo na matokeo ya matokeo yanayotangaza kama mkataba unakidhi mali au la. Tofauti na uchanganuzi unaobadilika, uchanganuzi tuli haujumuishi kutekeleza mkataba ili kuuchanganua kwa usahihi. Uchanganuzi thabiti badala yake unasababu kuhusu njia zote zinazowezekana ambazo mkataba mahiri unaweza kuchukua wakati wa utekelezaji (yaani, kwa kuchunguza muundo wa msimbo wa chanzo ili kubaini kitakachomaanisha kwa utendakazi wa mikataba wakati wa utekelezaji).
+
+[Linting](https://www.perforce.com/blog/qac/what-is-linting) na [upimaji tuli](https://www.techtarget.com/whatis/definition/static-analysis-static-code-analysis) ni mbinu za kawaida za kufanya uchambuzi tuli kwenye mikataba. Zote zinahitaji kuchanganua uwakilishi wa kiwango cha chini wa utekelezaji wa mikataba kama vile [miti ya sintaksia dhahania](https://en.m.wikipedia.org/wiki/Abstract_syntax_tree) na [grafu za mtiririko wa udhibiti](https://www.geeksforgeeks.org/software-engineering-control-flow-graph-cfg/amp/) zinazotolewa na mkusanyaji.
+
+Katika hali nyingi, uchanganuzi tuli ni muhimu kwa kugundua maswala ya usalama kama vile matumizi ya miundo isiyo salama, hitilafu za sintaksia, au ukiukaji wa viwango vya usimbaji katika msimbo wa mikataba. Hata hivyo, vichanganuzi tuli vinajulikana kwa ujumla kutokuwa sawa katika kugundua udhaifu mkubwa zaidi, na vinaweza kutoa chanya nyingi za uwongo.
+
+#### Uchambuzi wa nguvu {#dynamic-analysis}
+
+Uchambuzi wa nguvu hutoa ingizo za ishara (k.m., katika [utekelezaji wa ishara](https://en.m.wikipedia.org/wiki/Symbolic_execution)) au ingizo halisi (k.m., katika [fuzzing](https://owasp.org/www-community/Fuzzing)) kwa utendakazi wa mikataba-erevu ili kuona kama ufuatiliaji wowote wa utekelezaji unakiuka sifa maalum. Aina hii ya majaribio kulingana na mali hutofautiana na majaribio ya kitengo kwa kuwa kesi za majaribio hushughulikia hali nyingi na mpango hushughulikia uzalishaji wa kesi za majaribio.
+
+[Fuzzing](https://www.halborn.com/blog/post/what-is-fuzz-testing-fuzzing) ni mfano wa mbinu ya uchambuzi wa nguvu ya kuthibitisha sifa za kiholela katika mikataba-erevu. Fuzzer huomba utendakazi katika mkataba lengwa na tofauti za nasibu au zisizo na hitilafu za thamani iliyobainishwa ya ingizo. Iwapo mkataba mahiri utaingia katika hali ya hitilafu (k.m., ambapo madai hayatafaulu), tatizo hualamishwa na michango ambayo husababisha utekelezaji kuelekea njia hatarishi hutolewa katika ripoti.
+
+Fuzzing ni muhimu kwa kutathmini utaratibu mzuri wa uthibitishaji wa pembejeo za mikataba kwa kuwa utunzaji usiofaa wa pembejeo zisizotarajiwa kunaweza kusababisha utekelezaji usiotarajiwa na kutoa athari hatari. Aina hii ya upimaji unaozingatia sifa inaweza kuwa bora kwa sababu nyingi:
+
+1. **Kuandika kesi za majaribio kufunika hali nyingi ni ngumu.** Jaribio la sifa linahitaji tu uainishe tabia na anuwai ya data ili kujaribu tabia hiyo—programu huunda kesi za majaribio kiotomatiki kulingana na sifa iliyoainishwa.
+
+2. **Seti yako ya majaribio haiwezi kufunika vya kutosha njia zote zinazowezekana ndani ya programu.** Hata kwa ufikiaji wa 100%, inawezekana kukosa kesi za pembezoni.
+
+3. **Upimaji wa vitengo huthibitisha kuwa mkataba unatekelezwa kwa usahihi kwa data ya sampuli, lakini kama mkataba utatekelezwa kwa usahihi kwa ingizo nje ya sampuli bado haijulikani.** Majaribio ya sifa hutekeleza mkataba lengwa na tofauti nyingi za thamani ya ingizo ili kupata athari za utekelezaji zinazosababisha kushindwa kwa madai. Kwa hivyo, jaribio la mali hutoa hakikisho zaidi kwamba mkataba hutekelezwa kwa usahihi kwa darasa pana la data ya ingizo.
+
+### Miongozo ya kufanya upimaji unaozingatia sifa kwa mikataba-erevu {#running-property-based-tests}
+
+Kufanya upimaji unaozingatia sifa kwa kawaida huanza kwa kufafanua sifa (k.m., kutokuwepo kwa [mafuriko ya nambari kamili](https://github.com/ConsenSys/mythril/wiki/Integer-Overflow)) au mkusanyiko wa sifa ambazo unataka kuthibitisha katika mkataba-erevu. Unaweza pia kuhitaji kufafanua safu ya thamani ambazo programu inaweza kutoa data ya pembejeo za miamala wakati wa kuandika majaribio ya mali.
+
+Baada ya kupangwa ipasavyo, zana ya kupima mali itatekeleza utendakazi wako wa mikataba mahiri kwa ingizo zinazozalishwa bila mpangilio. Iwapo kuna ukiukaji wowote wa madai, unapaswa kupata ripoti iliyo na data thabiti ya ingizo ambayo inakiuka mali inayotathminiwa. Tazama baadhi ya miongozo hapa chini ili kuanza na kuendesha majaribio ya msingi wa mali kwa zana tofauti:
+
+- **[Uchambuzi tuli wa mikataba-erevu na Slither](https://github.com/crytic/slither)**
+- **[Uchambuzi tuli wa mikataba-erevu na Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)**
+- **[Upimaji unaozingatia sifa na Brownie](https://eth-brownie.readthedocs.io/en/stable/tests-hypothesis-property.html)**
+- **[Kufanya fuzzing kwenye mikataba na Foundry](https://book.getfoundry.sh/forge/fuzz-testing)**
+- **[Kufanya fuzzing kwenye mikataba na Echidna](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/echidna#echidna-tutorial)**
+- **[Kufanya fuzzing kwenye mikataba na Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/fuzzing/)**
+- **[Utekelezaji wa ishara wa mikataba-erevu na Manticore](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore#manticore-tutorial)**
+- **[Utekelezaji wa ishara wa mikataba-erevu na Mythril](https://mythril-classic.readthedocs.io/en/master/tutorial.html)**
+
+## Upimaji wa mikono kwa mikataba-erevu {#manual-testing-for-smart-contracts}
+
+Upimaji wa mikono wa mikataba-erevu mara nyingi huja baadaye katika mzunguko wa maendeleo baada ya kufanya majaribio ya kiotomatiki. Aina hii ya upimaji hutathmini mkataba-erevu kama bidhaa moja iliyojumuishwa kikamilifu ili kuona ikiwa inafanya kazi kama ilivyoainishwa katika mahitaji ya kiufundi.
+
+### Kupima mikataba kwenye mnyororo wa bloku wa ndani {#testing-on-local-blockchain}
+
+Ingawa upimaji wa kiotomatiki unaofanywa katika mazingira ya maendeleo ya ndani unaweza kutoa taarifa muhimu za utatuzi, utataka kujua jinsi mkataba-erevu wako unavyofanya kazi katika mazingira ya uzalishaji. Hata hivyo, kupeleka kwenye mnyororo mkuu wa Ethereum kunasababisha ada za gesi—bila kusahau kwamba wewe au watumiaji wako mnaweza kupoteza pesa halisi ikiwa mkataba-erevu wako bado una hitilafu.
+
+Kupima mkataba wako kwenye mnyororo wa bloku wa ndani (pia unajulikana kama [mtandao wa maendeleo](/developers/docs/development-networks/)) ni mbadala unaopendekezwa badala ya kupima kwenye Mtandao Mkuu. Mnyororo wa bloku wa ndani ni nakala ya mnyororo wa bloku wa Ethereum unaoendeshwa ndani ya kompyuta yako ambao unaiga tabia ya safu ya utekelezaji ya Ethereum. Kwa hivyo, unaweza kupanga miamala ili kuingiliana na mkataba bila kupata gharama kubwa.
+
+Kuendesha mikataba kwenye mnyororo wa bloku wa ndani kunaweza kuwa muhimu kama aina ya upimaji wa ujumuishaji wa mikono. [Mikataba-erevu inaweza kutungwa kwa urahisi sana](/developers/docs/smart-contracts/composability/), ikikuruhusu kujumuika na itifaki zilizopo—lakini bado utahitaji kuhakikisha kuwa mwingiliano huo changamano wa kwenye mnyororo unatoa matokeo sahihi.
+
+[Zaidi kuhusu mitandao ya maendeleo.](/developers/docs/development-networks/)
+
+### Kupima mikataba kwenye testnet {#testing-contracts-on-testnets}
+
+Mtandao wa majaribio au testnet hufanya kazi sawa kabisa na Mtandao Mkuu wa Ethereum, isipokuwa kwamba hutumia ether (ETH) isiyo na thamani ya ulimwengu halisi. Kupeleka mkataba wako kwenye [testnet](/developers/docs/networks/#ethereum-testnets) kunamaanisha mtu yeyote anaweza kuingiliana nao (k.m., kupitia sehemu ya mbele ya mfumo mtawanyo wa kimamlaka) bila kuweka fedha hatarini.
+
+Aina hii ya upimaji wa mikono ni muhimu kwa kutathmini mtiririko wa mwisho-hadi-mwisho wa programu yako kutoka kwa mtazamo wa mtumiaji. Hapa, wajaribu wa beta wanaweza pia kufanya majaribio na kuripoti masuala yoyote na mantiki ya biashara ya mkataba na utendakazi wa jumla.
+
+Kupeleka kwenye testnet baada ya kupima kwenye mnyororo wa bloku wa ndani ni bora kwani ya kwanza iko karibu zaidi na tabia ya mashine halisi ya ethereum. Kwa hivyo, ni kawaida kwa miradi mingi ya asili ya Ethereum kupeleka mfumo mtawanyo wa kimamlaka kwenye testnet kutathmini utendaji wa mkataba-erevu chini ya hali za ulimwengu halisi.
+
+[Zaidi kuhusu testnet za Ethereum.](/developers/docs/development-networks/#public-beacon-testchains)
+
+## Upimaji dhidi ya uthibitishaji rasmi {#testing-vs-formal-verification}
+
+Ingawa upimaji husaidia kuthibitisha kuwa mkataba unarudisha matokeo yanayotarajiwa kwa baadhi ya ingizo za data, hauwezi kuthibitisha kwa uhakika vivyo hivyo kwa ingizo ambazo hazikutumika wakati wa majaribio. Kupima mkataba-erevu, kwa hivyo, hakuwezi kuhakikisha "usahihi wa kiutendaji" (yaani, hakuwezi kuonyesha kwamba programu inafanya kazi kama inavyotakiwa kwa seti _zote_ za thamani za ingizo).
+
+Uthibitishaji rasmi ni mbinu ya kutathmini usahihi wa programu kwa kuangalia kama mfumo rasmi wa programu unalingana na vipimo rasmi. Mfumo rasmi ni uwakilishi dhahania wa kihisabati wa programu, wakati vipimo rasmi vinafafanua sifa za programu (yaani, madai ya kimantiki kuhusu utekelezaji wa programu).
+
+Kwa sababu sifa zimeandikwa kwa maneno ya kihisabati, inawezekana kuthibitisha kuwa mfumo rasmi (wa kihisabati) wa mfumo unakidhi vipimo kwa kutumia kanuni za kimantiki za kuhitimisha. Kwa hivyo, zana za uthibitishaji rasmi zinasemekana kutoa 'uthibitisho wa kihisabati' wa usahihi wa mfumo.
+
+Tofauti na upimaji, uthibitishaji rasmi unaweza kutumika kuthibitisha utekelezaji wa mkataba-erevu unakidhi vipimo rasmi kwa utekelezaji _wote_ (yaani, hauna hitilafu) bila kuhitaji kuutekeleza kwa data ya sampuli. Hii haipunguzi tu muda unaotumika kufanya majaribio kadhaa ya vitengo, lakini pia ni bora zaidi katika kugundua udhaifu uliofichwa. Hata hivyo, mbinu za uthibitishaji rasmi ziko kwenye wigo kulingana na ugumu wao wa utekelezaji na manufaa.
+
+[Zaidi kuhusu uthibitishaji rasmi wa mikataba-erevu.](/developers/docs/smart-contracts/formal-verification)
+
+## Upimaji dhidi ya ukaguzi na zawadi za hitilafu {#testing-vs-audits-bug-bounties}
+
+Kama ilivyoelezwa, upimaji mkali mara chache unaweza kuhakikisha kutokuwepo kwa hitilafu katika mkataba; mbinu za uthibitishaji rasmi zinaweza kutoa uhakikisho wenye nguvu zaidi wa usahihi lakini kwa sasa ni ngumu kutumia na zinahusisha gharama kubwa.
+
+Bado, unaweza kuongeza zaidi uwezekano wa kugundua udhaifu wa mkataba kwa kupata ukaguzi huru wa msimbo. [Ukaguzi wa mikataba-erevu](https://www.immunebytes.com/blog/what-is-a-smart-contract-audit/) na [zawadi za hitilafu](https://medium.com/immunefi/a-defi-security-standard-the-scaling-bug-bounty-9b83dfdc1ba7) ni njia mbili za kuwafanya wengine wachanganue mikataba yako.
+
+Ukaguzi hufanywa na wakaguzi wenye uzoefu katika kutafuta kesi za dosari za usalama na mazoea duni ya maendeleo katika kandarasi mahiri. Ukaguzi kwa kawaida utajumuisha majaribio (na ikiwezekana uthibitishaji rasmi) pamoja na uhakiki wa mwongozo wa msingi wote wa msimbo.
+
+Kinyume chake, programu ya zawadi ya hitilafu kwa kawaida huhusisha kutoa zawadi ya kifedha kwa mtu binafsi (anayejulikana kama [wadukuzi wa kofia nyeupe](https://en.wikipedia.org/wiki/White_hat_\(computer_security\))) anayegundua udhaifu katika mkataba-erevu na kuufichua kwa wasanidi programu. Fadhila za kosa ni sawa na ukaguzi kwa vile unahusisha kuwauliza wengine kusaidia kupata kasoro katika mikataba mahiri.
+
+Tofauti kuu ni kwamba programu za fadhila za kosa ziko wazi kwa jumuiya pana ya wasanifu/wadukuzi na kuvutia tabaka pana la wavamizi wa maadili na wataalamu huru wa usalama walio na ujuzi na uzoefu wa kipekee. Hii inaweza kuwa faida zaidi ya ukaguzi mzuri wa mikataba ambayo inategemea sana timu ambazo zinaweza kuwa na utaalamu mdogo au finyu.
+
+## Zana na maktaba za upimaji {#testing-tools-and-libraries}
+
+### Zana za upimaji wa vitengo {#unit-testing-tools}
+
+- **[solidity-coverage](https://github.com/sc-forks/solidity-coverage)** - _Zana ya kufunika msimbo kwa mikataba-erevu iliyoandikwa katika Solidity._
+
+- **[Waffle](https://ethereum-waffle.readthedocs.io/en/latest/)** - _Mfumo wa maendeleo ya hali ya juu ya mkataba-erevu na upimaji (kwa kuzingatia ethers.js)_.
+
+- **[Remix Tests](https://github.com/ethereum/remix-project/tree/master/libs/remix-tests)** - _Zana ya kupima mikataba-erevu ya Solidity. Hufanya kazi chini ya programu-jalizi ya Remix IDE "Solidity Unit Testing" ambayo hutumika kuandika na kuendesha kesi za majaribio kwa mkataba._
+
+- **[OpenZeppelin Test Helpers](https://github.com/OpenZeppelin/openzeppelin-test-helpers)** - _Maktaba ya madai kwa ajili ya upimaji wa mkataba-erevu wa Ethereum. Hakikisha mikataba yako inafanya kazi kama inavyotarajiwa!_
+
+- **[Mfumo wa upimaji wa kitengo wa Brownie](https://eth-brownie.readthedocs.io/en/v1.0.0_a/tests.html)** - _Brownie hutumia Pytest, mfumo wa majaribio wenye vipengele vingi unaokuruhusu kuandika majaribio madogo na msimbo mdogo, unaongezeka vizuri kwa miradi mikubwa, na unaweza kupanuliwa sana._
+
+- **[Majaribio ya Foundry](https://github.com/foundry-rs/foundry/tree/master/crates/forge)** - _Foundry inatoa Forge, mfumo wa upimaji wa haraka na rahisi wa Ethereum unaoweza kutekeleza upimaji rahisi wa vitengo, ukaguzi wa uboreshaji wa gesi, na ufanyaji wa fuzzing kwenye mikataba._
+
+- **[Majaribio ya Hardhat](https://hardhat.org/hardhat-runner/docs/guides/test-contracts)** - _Mfumo wa kupima mikataba-erevu unaozingatia ethers.js, Mocha, na Chai._
+
+- **[ApeWorx](https://docs.apeworx.io/ape/stable/userguides/testing.html)** - _Mfumo wa maendeleo na upimaji unaotegemea Python kwa mikataba-erevu unaolenga mashine halisi ya ethereum._
+
+- **[Wake](https://ackeeblockchain.com/wake/docs/latest/testing-framework/overview/)** - _Mfumo unaotegemea Python kwa upimaji wa vitengo na fuzzing na uwezo mkubwa wa utatuzi na usaidizi wa upimaji wa minyororo mbalimbali, ukitumia pytest na Anvil kwa uzoefu bora wa mtumiaji na utendakazi._
+
+### Zana za upimaji unaozingatia sifa {#property-based-testing-tools}
+
+#### Zana za uchambuzi tuli {#static-analysis-tools}
+
+- **[Slither](https://github.com/crytic/slither)** - _Mfumo wa uchambuzi tuli wa Solidity unaotegemea Python wa kupata udhaifu, kuboresha uelewa wa msimbo, na kuandika uchambuzi maalum wa mikataba-erevu._
+
+- **[Ethlint](https://ethlint.readthedocs.io/en/latest/)** - _Linter ya kutekeleza mtindo na mbinu bora za usalama kwa lugha ya programu ya mkataba-erevu ya Solidity._
+
+- **[Cyfrin Aderyn](https://cyfrin.io/tools/aderyn)** - _Kichanganuzi tuli chenye msingi wa Rust kilichoundwa mahsusi kwa usalama na maendeleo ya mkataba-erevu wa Web3._
+
+- **[Wake](https://ackeeblockchain.com/wake/docs/latest/static-analysis/using-detectors/)** - _Mfumo wa uchambuzi tuli unaotegemea Python na vigunduzi vya udhaifu na ubora wa msimbo, vichapishi vya kutoa taarifa muhimu kutoka kwa msimbo na usaidizi wa kuandika moduli ndogo maalum._
+
+- **[Slippy](https://github.com/fvictorio/slippy)** - _Linter rahisi na yenye nguvu kwa Solidity._
+
+#### Zana za uchambuzi wa nguvu {#dynamic-analysis-tools}
+
+- **[Echidna](https://github.com/crytic/echidna/)** - _Fuzzer ya mikataba ya haraka ya kugundua udhaifu katika mikataba-erevu kupitia upimaji unaozingatia sifa._
+
+- **[Diligence Fuzzing](https://consensys.net/diligence/fuzzing/)** - _Zana ya kiotomatiki ya fuzzing inayofaa kugundua ukiukaji wa sifa katika msimbo wa mkataba-erevu._
+
+- **[Manticore](https://manticore.readthedocs.io/en/latest/index.html)** - _Mfumo wa utekelezaji wa ishara wa nguvu wa kuchambua bytecode ya EVM._
+
+- **[Mythril](https://github.com/ConsenSys/mythril-classic)** - _Zana ya tathmini ya bytecode ya EVM ya kugundua udhaifu wa mkataba kwa kutumia uchambuzi wa doa, uchambuzi wa concolic, na ukaguzi wa mtiririko wa udhibiti._
+
+- **[Diligence Scribble](https://consensys.net/diligence/scribble/)** - _Scribble ni lugha ya vipimo na zana ya uthibitishaji wakati wa utekelezaji inayokuruhusu kufafanua mikataba-erevu na sifa zinazokuwezesha kupima mikataba kiotomatiki na zana kama vile Diligence Fuzzing au MythX._
+
+## Mafunzo yanayohusiana {#related-tutorials}
+
+- [Muhtasari na ulinganisho wa bidhaa tofauti za upimaji](/developers/tutorials/guide-to-smart-contract-security-tools/) \_
+- [Jinsi ya kutumia Echidna kupima mikataba-erevu](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/)
+- [Jinsi ya kutumia Manticore kupata mende za mkataba-erevu](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/)
+- [Jinsi ya kutumia Slither kupata mende za mkataba-erevu](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
+- [Jinsi ya kuiga mikataba ya Solidity kwa ajili ya upimaji](/developers/tutorials/how-to-mock-solidity-contracts-for-testing/)
+- [Jinsi ya kufanya upimaji wa vitengo katika Solidity kwa kutumia Foundry](https://www.rareskills.io/post/foundry-testing-solidity)
+
+## Masomo zaidi {#further-reading}
+
+- [Mwongozo wa kina wa kupima mikataba-erevu ya Ethereum](https://iamdefinitelyahuman.medium.com/an-in-depth-guide-to-testing-ethereum-smart-contracts-2e41b2770297)
+- [Jinsi ya kupima mikataba-erevu ya Ethereum](https://betterprogramming.pub/how-to-test-ethereum-smart-contracts-35abc8fa199d)
+- [Mwongozo wa MolochDAO wa upimaji wa vitengo kwa wasanidi programu](https://github.com/MolochVentures/moloch/tree/4e786db8a4aa3158287e0935dcbc7b1e43416e38/test#moloch-testing-guide)
+- [Jinsi ya kupima mikataba-erevu kama nyota wa rock](https://forum.openzeppelin.com/t/test-smart-contracts-like-a-rockstar/1001)
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/upgrading/index.md b/public/content/translations/sw/developers/docs/smart-contracts/upgrading/index.md
new file mode 100644
index 00000000000..15ca5501197
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/upgrading/index.md
@@ -0,0 +1,165 @@
+---
+title: Kuboresha mikataba erevu
+description: Muhtasari wa mifumo ya usasishaji kwa mikataba-erevu ya Ethereum
+lang: sw
+---
+
+Mikataba-erevu kwenye Ethereum ni programu zinazojitekeleza zinazoendeshwa kwenye mashine halisi ya ethereum (EVM). Programu hizi hazibadiliki kimuundo, jambo ambalo huzuia masasisho yoyote kwa mantiki ya kibiashara mara tu mkataba unapopelekwa.
+
+Ingawa kutobadilika ni muhimu kwa kutokuwa na haja ya kuaminiana, ugatuzi, na usalama wa mikataba-erevu, inaweza kuwa hasara katika hali fulani. Kwa mfano, msimbo usiobadilika unaweza kufanya iwe vigumu kwa wasanidi programu kurekebisha mikataba iliyo hatarini.
+
+Hata hivyo, utafiti ulioongezeka katika kuboresha mikataba-erevu umesababisha kuanzishwa kwa mifumo kadhaa ya usasishaji. Mifumo hii ya usasishaji huwawezesha wasanidi programu kusasisha mikataba-erevu (huku wakihifadhi kutobadilika) kwa kuweka mantiki ya biashara katika mikataba tofauti.
+
+## Mahitaji ya awali {#prerequisites}
+
+Unapaswa kuwa na uelewa mzuri wa [mikataba-erevu](/developers/docs/smart-contracts/), [muundo wa mkataba-erevu](/developers/docs/smart-contracts/anatomy/), na [mashine halisi ya ethereum (EVM)](/developers/docs/evm/). Mwongozo huu pia unachukulia kuwa wasomaji wana uelewa wa kupanga programu za mikataba-erevu.
+
+## Usasishaji wa mkataba-erevu ni nini? {#what-is-a-smart-contract-upgrade}
+
+Usasishaji wa mkataba-erevu unahusisha kubadilisha mantiki ya biashara ya mkataba-erevu huku ukihifadhi hali ya mkataba. Ni muhimu kufafanua kwamba uwezo wa kusasishwa na uwezo wa kubadilika si kitu kimoja, hasa katika muktadha wa mikataba-erevu.
+
+Bado huwezi kubadilisha programu iliyotumwa kwenye anwani katika mtandao wa Ethereum. Lakini unaweza kubadilisha msimbo unaotekelezwa watumiaji wanapoingiliana na mkataba-erevu.
+
+Hili linaweza kufanywa kupitia njia zifuatazo:
+
+1. Kuunda matoleo mengi ya mkataba-erevu na kuhamisha hali (yaani, data) kutoka kwa mkataba wa zamani hadi nakala mpya ya mkataba.
+
+2. Kuunda mikataba tofauti ya kuhifadhi mantiki ya biashara na hali.
+
+3. Kutumia mifumo ya proksi ili kukasimu miito ya chaguo za kukokotoa kutoka kwa mkataba wa proksi usiobadilika hadi mkataba wa kimantiki unaoweza kurekebishwa.
+
+4. Kuunda mkataba mkuu usiobadilika unaounganishwa na kutegemea mikataba rahisi ya setilaiti ili kutekeleza chaguo za kukokotoa mahususi.
+
+5. Kutumia mfumo wa almasi ili kukasimu miito ya chaguo za kukokotoa kutoka kwa mkataba wa proksi hadi kwa mikataba ya kimantiki.
+
+### Utaratibu wa usasishaji #1: Uhamishaji wa mkataba {#contract-migration}
+
+Uhamishaji wa mkataba unategemea uwekaji matoleo—wazo la kuunda na kudhibiti hali za kipekee za programu moja. Uhamishaji wa mkataba unahusisha kupeleka nakala mpya ya mkataba-erevu uliopo na kuhamisha ghala na salio kwenye mkataba mpya.
+
+Mkataba mpya uliotumwa utakuwa na ghala tupu, inayokuruhusu kupata data kutoka kwa mkataba wa zamani na kuiandika kwenye utekelezaji mpya. Baadaye, utahitaji kusasisha mikataba yote iliyoingiliana na mkataba wa zamani ili kuonyesha anwani mpya.
+
+Hatua ya mwisho katika uhamishaji wa mkataba ni kuwashawishi watumiaji wabadili na kutumia mkataba mpya. Toleo jipya la mkataba litahifadhi salio na anwani za watumiaji, jambo ambalo huhifadhi kutobadilika. Ikiwa ni mkataba unaotegemea tokeni, utahitaji pia kuwasiliana na mabadilishano ili kuachana na mkataba wa zamani na kutumia mkataba mpya.
+
+Uhamishaji wa mkataba ni hatua rahisi na salama kwa kusasisha mikataba-erevu bila kuvunja mwingiliano wa watumiaji. Hata hivyo, kuhamisha ghala na salio za mtumiaji kwa mkono hadi kwa mkataba mpya kunachukua muda mwingi na kunaweza kusababisha gharama kubwa za gesi.
+
+[Zaidi kuhusu uhamishaji wa mkataba.](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/)
+
+### Utaratibu wa usasishaji #2: Utengano wa data {#data-separation}
+
+Njia nyingine ya kusasisha mikataba-erevu ni kutenganisha mantiki ya biashara na ghala la data katika mikataba tofauti. Hii inamaanisha watumiaji huingiliana na mkataba wa kimantiki, huku data ikihifadhiwa kwenye mkataba wa ghala.
+
+Mkataba wa kimantiki una msimbo unaotekelezwa wakati watumiaji wanapoingiliana na programu. Pia unashikilia anwani ya mkataba wa ghala na huingiliana nao ili kupata na kuweka data.
+
+Wakati huo huo, mkataba wa ghala unashikilia hali inayohusishwa na mkataba-erevu, kama vile salio na anwani za watumiaji. Kumbuka kuwa mkataba wa ghala unamilikiwa na mkataba wa kimantiki na umesanidiwa na anwani ya mkataba huo wa kimantiki wakati wa kupelekwa. Hii inazuia mikataba isiyoidhinishwa kuita mkataba wa ghala au kusasisha data yake.
+
+Kwa chaguo-msingi, mkataba wa ghala haubadiliki—lakini unaweza kubadilisha mkataba wa kimantiki unaoelekeza na utekelezaji mpya. Hii itabadilisha msimbo unaoendeshwa katika EVM, huku ukiweka ghala na salio bila kubadilika.
+
+Kutumia njia hii ya usasishaji kunahitaji kusasisha anwani ya mkataba wa kimantiki katika mkataba wa ghala. Ni lazima pia usanidi mkataba mpya wa kimantiki na anwani ya mkataba wa ghala kwa sababu zilizoelezwa hapo awali.
+
+Mfumo wa utengano wa data bila shaka ni rahisi kutekeleza ikilinganishwa na uhamishaji wa mkataba. Hata hivyo, itabidi udhibiti mikataba mingi na utekeleze mifumo changamano ya uidhinishaji ili kulinda mikataba-erevu dhidi ya masasisho dhalimu.
+
+### Utaratibu wa usasishaji #3: Mifumo ya proksi {#proxy-patterns}
+
+Mfumo wa proksi pia hutumia utengano wa data ili kuweka mantiki ya biashara na data katika mikataba tofauti. Hata hivyo, katika mfumo wa proksi, mkataba wa ghala (unaoitwa proksi) huita mkataba wa kimantiki wakati wa utekelezaji wa msimbo. Hii ni kinyume cha njia ya kutenganisha data, ambapo mkataba wa kimantiki huita mkataba wa ghala.
+
+Hivi ndivyo hutokea katika mfumo wa proksi:
+
+1. Watumiaji huingiliana na mkataba wa proksi, ambao huhifadhi data, lakini haushikilii mantiki ya biashara.
+
+2. Mkataba wa proksi huhifadhi anwani ya mkataba wa kimantiki na hukasimu miito yote ya chaguo za kukokotoa kwa mkataba wa kimantiki (unaoshikilia mantiki ya biashara) kwa kutumia chaguo za kukokotoa la `delegatecall`.
+
+3. Baada ya wito kupelekwa kwa mkataba wa kimantiki, data iliyorejeshwa kutoka kwa mkataba wa kimantiki inapatikana na kurejeshwa kwa mtumiaji.
+
+Kutumia mifumo ya proksi kunahitaji uelewa wa chaguo za kukokotoa la **delegatecall**. Kimsingi, `delegatecall` ni opcode inayoruhusu mkataba kuita mkataba mwingine, wakati utekelezaji halisi wa msimbo unafanyika katika muktadha wa mkataba unaopiga simu. Athari ya kutumia `delegatecall` katika mifumo ya proksi ni kwamba mkataba wa proksi husoma na kuandika kwenye ghala lake na kutekeleza mantiki iliyohifadhiwa kwenye mkataba wa kimantiki kana kwamba inaita chaguo za kukokotoa la ndani.
+
+Kutoka [nyaraka za Solidity](https://docs.soliditylang.org/en/latest/introduction-to-smart-contracts.html#delegatecall-callcode-and-libraries):
+
+> _Kuna lahaja maalum ya wito wa ujumbe, inayoitwa **delegatecall** ambayo ni sawa na wito wa ujumbe isipokuwa ukweli kwamba msimbo katika anwani lengwa unatekelezwa katika muktadha (yaani, katika anwani) ya mkataba unaoita na `msg.sender` na `msg.value` hazibadilishi thamani zao._ _Hii ina maana kwamba mkataba unaweza kupakia msimbo kutoka kwa anwani tofauti kwa nguvu wakati wa uendeshaji. Ghala, anwani ya sasa na salio bado zinarejelea mkataba unaopiga simu, ni msimbo tu unachukuliwa kutoka kwa anwani inayoitwa._
+
+Mkataba wa proksi unajua kuomba `delegatecall` wakati wowote mtumiaji anapoita chaguo za kukokotoa kwa sababu una chaguo za kukokotoa la `fallback` lililojengwa ndani yake. Katika programu ya Solidity, [chaguo za kukokotoa mbadala](https://docs.soliditylang.org/en/latest/contracts.html#fallback-function) hutekelezwa wakati wito wa chaguo za kukokotoa hailingani na chaguo za kukokotoa zilizobainishwa katika mkataba.
+
+Kufanya mfumo wa proksi ufanye kazi kunahitaji kuandika chaguo za kukokotoa mbadala maalum ambalo hubainisha jinsi mkataba wa proksi unapaswa kushughulikia miito ya chaguo za kukokotoa usiyounga mkono. Katika hali hii, chaguo za kukokotoa mbadala la proksi limepangwa kuanzisha delegatecall na kuelekeza ombi la mtumiaji kwa utekelezaji wa sasa wa mkataba wa kimantiki.
+
+Mkataba wa proksi haubadiliki kwa chaguo-msingi, lakini mikataba mipya ya kimantiki yenye mantiki ya biashara iliyosasishwa inaweza kuundwa. Kufanya usasishaji basi ni suala la kubadilisha anwani ya mkataba wa kimantiki unaorejelewa katika mkataba wa proksi.
+
+Kwa kuelekeza mkataba wa proksi kwenye mkataba mpya wa kimantiki, msimbo unaotekelezwa watumiaji wanapoita chaguo za kukokotoa la mkataba wa proksi hubadilika. Hii inatuwezesha kusasisha mantiki ya mkataba bila kuwauliza watumiaji kuingiliana na mkataba mpya.
+
+Mifumo ya proksi ni njia maarufu ya kusasisha mikataba-erevu kwa sababu huondoa ugumu unaohusishwa na uhamishaji wa mkataba. Hata hivyo, mifumo ya proksi ni ngumu zaidi kutumia na inaweza kuleta dosari kubwa, kama vile [migongano ya viteuzi vya chaguo za kukokotoa](https://medium.com/nomic-foundation-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357), ikitumiwa isivyofaa.
+
+[Zaidi kuhusu mifumo ya proksi](https://blog.openzeppelin.com/proxy-patterns/).
+
+### Utaratibu wa usasishaji #4: Mfumo wa mkakati {#strategy-pattern}
+
+Mbinu hii inaathiriwa na [mfumo wa mkakati](https://en.wikipedia.org/wiki/Strategy_pattern), ambayo inahimiza kuunda programu za kompyuta zinazoungana na programu nyingine ili kutekeleza vipengele maalum. Kutumia mfumo wa mkakati kwenye usanidi wa Ethereum kutamaanisha kujenga mkataba-erevu unaoita chaguo za kukokotoa kutoka kwa mikataba mingine.
+
+Mkataba mkuu katika kesi hii una mantiki ya msingi ya biashara, lakini unaunganishwa na mikataba-erevu mingine ("mikataba ya setilaiti") ili kutekeleza chaguo za kukokotoa fulani. Mkataba huu mkuu pia huhifadhi anwani ya kila mkataba wa setilaiti na unaweza kubadili kati ya utekelezaji tofauti wa mkataba wa setilaiti.
+
+Unaweza kujenga mkataba mpya wa setilaiti na kusanidi mkataba mkuu na anwani mpya. Hii hukuruhusu kubadilisha _mikakati_ (yaani, kutekeleza mantiki mpya) kwa mkataba-erevu.
+
+Ingawa inafanana na mfumo wa proksi uliojadiliwa hapo awali, mfumo wa mkakati ni tofauti kwa sababu mkataba mkuu, ambao watumiaji huingiliana nao, unashikilia mantiki ya biashara. Kutumia mfumo huu kunakupa fursa ya kuleta mabadiliko machache kwenye mkataba-erevu bila kuathiri miundombinu ya msingi.
+
+Hasara kuu ni kwamba mfumo huu unafaa zaidi kwa kutoa masasisho madogo. Pia, ikiwa mkataba mkuu utadukuliwa (k.m., kupitia udukuzi), huwezi kutumia njia hii ya usasishaji.
+
+### Utaratibu wa usasishaji #5: Mfumo wa almasi {#diamond-pattern}
+
+Mfumo wa almasi unaweza kuchukuliwa kama uboreshaji wa mfumo wa proksi. Mifumo ya almasi hutofautiana na mifumo ya proksi kwa sababu mkataba wa proksi wa almasi unaweza kukasimu miito ya chaguo za kukokotoa kwa zaidi ya mkataba mmoja wa kimantiki.
+
+Mikataba ya kimantiki katika mfumo wa almasi inajulikana kama _facets_. Ili kufanya mfumo wa almasi ufanye kazi, unahitaji kuunda ramani katika mkataba wa proksi ambayo inaunganisha [viteuzi vya chaguo za kukokotoa](https://docs.soliditylang.org/en/latest/abi-spec.html#function-selector) kwenye anwani tofauti za facet.
+
+Mtumiaji anapofanya wito wa chaguo za kukokotoa, mkataba wa proksi hukagua ramani ili kupata facet inayohusika na kutekeleza chaguo hilo la kukokotoa. Kisha inaomba `delegatecall` (kwa kutumia chaguo za kukokotoa mbadala) na kuelekeza wito kwa mkataba wa kimantiki unaofaa.
+
+Mfumo wa usasishaji wa almasi una faida fulani kuliko mifumo ya jadi ya usasishaji wa proksi:
+
+1. Inakuruhusu kusasisha sehemu ndogo ya mkataba bila kubadilisha msimbo wote. Kutumia mfumo wa proksi kwa masasisho kunahitaji kuunda mkataba mpya kabisa wa kimantiki, hata kwa masasisho madogo.
+
+2. Mikataba yote erevu (ikiwa ni pamoja na mikataba ya kimantiki inayotumika katika mifumo ya proksi) ina kikomo cha ukubwa wa KB 24, ambacho kinaweza kuwa kikwazo—hasa kwa mikataba tata inayohitaji chaguo za kukokotoa zaidi. Mfumo wa almasi hurahisisha kutatua tatizo hili kwa kugawanya chaguo za kukokotoa katika mikataba mingi ya kimantiki.
+
+3. Mifumo ya proksi huchukua mbinu ya kujumlisha kwa udhibiti wa ufikiaji. Huluki yenye ufikiaji wa chaguo za kukokotoa za kusasisha inaweza kubadilisha mkataba _mzima_. Lakini mfumo wa almasi huwezesha mbinu ya ruhusa za mifumo, ambapo unaweza kuzuia huluki kusasisha chaguo za kukokotoa fulani ndani ya mkataba-erevu.
+
+[Zaidi kuhusu mfumo wa almasi](https://eip2535diamonds.substack.com/p/introduction-to-the-diamond-standard?s=w).
+
+## Faida na hasara za kusasisha mikataba-erevu {#pros-and-cons-of-upgrading-smart-contracts}
+
+| Faida | Hasara |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Usasishaji wa mkataba-erevu unaweza kurahisisha kurekebisha udhaifu uliogunduliwa katika awamu ya baada ya kupelekwa. | Kusasisha mikataba-erevu kunapingana na wazo la kutobadilika kwa msimbo, jambo ambalo lina athari kwa ugatuzi na usalama. |
+| Wasanidi programu wanaweza kutumia masasisho ya kimantiki kuongeza vipengele vipya kwenye mifumo iliyotawanywa. | Watumiaji lazima wawaamini wasanidi programu wasibadilishe mikataba-erevu kiholela. |
+| Masasisho ya mikataba-erevu yanaweza kuboresha usalama kwa watumiaji wa mwisho kwani hitilafu zinaweza kurekebishwa haraka. | Kupanga programu ya utendaji wa usasishaji katika mikataba-erevu huongeza safu nyingine ya utata na huongeza uwezekano wa dosari kubwa. |
+| Masasisho ya mkataba huwapa wasanidi programu nafasi zaidi ya kujaribu vipengele tofauti na kuboresha mifumo mtawanyo ya kimamlaka kadri muda unavyopita. | Fursa ya kusasisha mikataba-erevu inaweza kuwahimiza wasanidi programu kuzindua miradi haraka bila kufanya uchunguzi wa kina wakati wa awamu ya usanidi. |
+| | Udhibiti wa ufikiaji usio salama au uwekaji kati katika mikataba-erevu unaweza kurahisisha wahusika dhalimu kufanya masasisho yasiyoidhinishwa. |
+
+## Mambo ya kuzingatia katika kusasisha mikataba-erevu {#considerations-for-upgrading-smart-contracts}
+
+1. Tumia mifumo salama ya udhibiti wa ufikiaji/uidhinishaji ili kuzuia masasisho yasiyoidhinishwa ya mikataba-erevu, hasa ikiwa unatumia mifumo ya proksi, mifumo ya mikakati, au utengano wa data. Mfano ni kuzuia ufikiaji wa chaguo za kukokotoa la usasishaji, ili mmiliki wa mkataba pekee ndiye anayeweza kuiita.
+
+2. Kusasisha mikataba-erevu ni shughuli tata na inahitaji kiwango cha juu cha bidii ili kuzuia kuanzishwa kwa udhaifu.
+
+3. Punguza dhana za uaminifu kwa kugatua mchakato wa kutekeleza masasisho. Mikakati inayowezekana ni pamoja na kutumia [mkataba wa mkoba wa saini-nyingi](/developers/docs/smart-contracts/#multisig) kudhibiti masasisho, au kuwataka [wanachama wa DAO](/dao/) kupiga kura kuidhinisha usasishaji.
+
+4. Jihadharini na gharama zinazohusika katika kusasisha mikataba. Kwa mfano, kunakili hali (k.m., salio za mtumiaji) kutoka kwa mkataba wa zamani hadi mkataba mpya wakati wa uhamishaji wa mkataba kunaweza kuhitaji zaidi ya muamala mmoja, ikimaanisha ada zaidi za gesi.
+
+5. Fikiria kutekeleza **kufuli za muda** ili kuwalinda watumiaji. Kufuli ya muda hurejelea ucheleweshaji unaotekelezwa kwenye mabadiliko ya mfumo. Kufuli za muda zinaweza kuunganishwa na mfumo wa utawala wa saini-nyingi ili kudhibiti masasisho: ikiwa hatua iliyopendekezwa itafikia kizingiti cha idhini kinachohitajika, haitekelezwi hadi kipindi cha ucheleweshaji kilichobainishwa awali kiishe.
+
+Kufuli za muda huwapa watumiaji muda wa kujiondoa kwenye mfumo ikiwa hawakubaliani na mabadiliko yaliyopendekezwa (k.m., usasishaji wa kimantiki au mifumo mipya ya ada). Bila kufuli za muda, watumiaji wanahitaji kuwaamini wasanidi programu wasitekeleze mabadiliko ya kiholela katika mkataba-erevu bila taarifa ya awali. Hasara hapa ni kwamba kufuli za muda huzuia uwezo wa kurekebisha udhaifu haraka.
+
+## Rasilimali {#resources}
+
+**Vidirisha vya Masasisho vya OpenZeppelin - _Mkusanyiko wa zana za kupeleka na kulinda mikataba-erevu inayoweza kusasishwa._**
+
+- [GitHub](https://github.com/OpenZeppelin/openzeppelin-upgrades)
+- [Nyaraka](https://docs.openzeppelin.com/upgrades)
+
+## Mafunzo {#tutorials}
+
+- [Kusasisha Mikataba-erevu Yako | Mafunzo ya YouTube](https://www.youtube.com/watch?v=bdXJmWajZRY) na Patrick Collins
+- [Mafunzo ya Uhamishaji wa Mkataba-erevu wa Ethereum](https://medium.com/coinmonks/ethereum-smart-contract-migration-13f6f12539bd) na Austin Griffith
+- [Kutumia mfumo wa proksi wa UUPS kusasisha mikataba-erevu](https://blog.logrocket.com/author/praneshas/) na Pranesh A.S
+- [Mafunzo ya Web3: Andika mkataba-erevu unaoweza kusasishwa (proksi) kwa kutumia OpenZeppelin](https://dev.to/yakult/tutorial-write-upgradeable-smart-contract-proxy-contract-with-openzeppelin-1916) na fangjun.eth
+
+## Masomo zaidi {#further-reading}
+
+- [Hali ya Masasisho ya Mikataba-erevu](https://blog.openzeppelin.com/the-state-of-smart-contract-upgrades/) na Santiago Palladino
+- [Njia nyingi za kusasisha mkataba-erevu wa Solidity](https://cryptomarketpool.com/multiple-ways-to-upgrade-a-solidity-smart-contract/) - Blogu ya Crypto Market Pool
+- [Jifunze: Kusasisha Mikataba-erevu](https://docs.openzeppelin.com/learn/upgrading-smart-contracts) - Nyaraka za OpenZeppelin
+- [Mifumo ya Proksi kwa Uwezo wa Kusasishwa wa Mikataba ya Solidity: Proksi za Wazi dhidi ya Proksi za UUPS](https://mirror.xyz/0xB38709B8198d147cc9Ff9C133838a044d78B064B/M7oTptQkBGXxox-tk9VJjL66E1V8BUF0GF79MMK4YG0) na Naveen Sahu
+- [Jinsi Masasisho ya Almasi Yanavyofanya Kazi](https://dev.to/mudgen/how-diamond-upgrades-work-417j) na Nick Mudge
diff --git a/public/content/translations/sw/developers/docs/smart-contracts/verifying/index.md b/public/content/translations/sw/developers/docs/smart-contracts/verifying/index.md
new file mode 100644
index 00000000000..16d3f2209af
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/smart-contracts/verifying/index.md
@@ -0,0 +1,113 @@
+---
+title: Kuhakiki mikataba erevu
+description: Muhtasari wa uthibitishaji wa msimbo chanzo kwa mikataba-erevu ya Ethereum
+lang: sw
+---
+
+[Mikataba-erevu](/developers/docs/smart-contracts/) imeundwa kuwa ya "bila kuaminiana", kumaanisha watumiaji hawapaswi kuamini washirika wengine (k.m., wasanidi programu na kampuni) kabla ya kuingiliana na mkataba. Kama sharti la kutokuwa na haja ya kuaminiana, watumiaji na wasanidi programu wengine lazima waweze kuthibitisha msimbo chanzo wa mkataba-erevu. Uthibitishaji wa msimbo chanzo huwahakikishia watumiaji na wasanidi programu kwamba msimbo wa mkataba uliochapishwa ni msimbo uleule unaoendeshwa kwenye anwani ya mkataba kwenye mnyororo wa bloku wa Ethereum.
+
+Ni muhimu kutofautisha kati ya "uthibitishaji wa msimbo chanzo" na "[uthibitishaji rasmi](/developers/docs/smart-contracts/formal-verification/)". Uthibitishaji wa msimbo chanzo, ambao utaelezwa kwa undani hapa chini, unarejelea kuthibitisha kwamba msimbo chanzo uliotolewa wa mkataba-erevu katika lugha ya kiwango cha juu (k.m., Solidity) huandaliwa kuwa msimbo wa baiti uleule utakaotekelezwa kwenye anwani ya mkataba. Hata hivyo, uthibitishaji rasmi unaelezea kuthibitisha usahihi wa mkataba-erevu, ikimaanisha kuwa mkataba unafanya kazi kama inavyotarajiwa. Ingawa inategemea muktadha, uthibitishaji wa mkataba kwa kawaida hurejelea uthibitishaji wa msimbo chanzo.
+
+## Uthibitishaji wa msimbo chanzo ni nini? {#what-is-source-code-verification}
+
+Kabla ya kupeleka mkataba-erevu katika [Mashine ya mtandaoni ya Ethereum (EVM)](/developers/docs/evm/), wasanidi programu [huandaa](/developers/docs/smart-contracts/compiling/) msimbo chanzo wa mkataba—maagizo [yaliyoandikwa katika Solidity](/developers/docs/smart-contracts/languages/) au lugha nyingine ya programu ya kiwango cha juu— kuwa msimbo wa baiti. Kwa kuwa EVM haiwezi kutafsiri maagizo ya kiwango cha juu, kuandaa msimbo chanzo kuwa msimbo wa baiti (yaani, maagizo ya kiwango cha chini, ya mashine) ni muhimu kwa ajili ya kutekeleza mantiki ya mkataba katika EVM.
+
+Uthibitishaji wa msimbo chanzo ni kulinganisha msimbo chanzo wa mkataba-erevu na msimbo wa baiti ulioandaliwa uliotumika wakati wa uundaji wa mkataba ili kugundua tofauti zozote. Kuthibitisha mikataba-erevu ni muhimu kwa sababu msimbo wa mkataba uliotangazwa unaweza kuwa tofauti na ule unaoendeshwa kwenye mnyororo wa bloku.
+
+Uthibitishaji wa mkataba-erevu huwezesha kuchunguza kile mkataba hufanya kupitia lugha ya kiwango cha juu iliyoandikwa, bila kulazimika kusoma msimbo wa mashine. Majukumu, thamani, na kwa kawaida majina ya vigezo na maoni hubaki sawa na msimbo chanzo asilia ambao umeandaliwa na kupelekwa. Hii hurahisisha kusoma msimbo. Uthibitishaji wa chanzo pia hutoa nafasi ya nyaraka za msimbo, ili watumiaji wa mwisho wajue kile ambacho mkataba-erevu umeundwa kufanya.
+
+### Uthibitishaji kamili ni nini? {#full-verification}
+
+Kuna baadhi ya sehemu za msimbo chanzo ambazo haziathiri msimbo wa baiti ulioandaliwa kama vile maoni au majina ya vigezo. Hiyo inamaanisha misimbo miwili chanzo yenye majina tofauti ya vigezo na maoni tofauti yote yangeweza kuthibitisha mkataba mmoja. Kwa hiyo, mhusika mwenye nia mbaya anaweza kuongeza maoni ya udanganyifu au kutoa majina ya vigezo yanayopotosha ndani ya msimbo chanzo na kufanya mkataba uthibitishwe na msimbo chanzo tofauti na msimbo chanzo asilia.
+
+Inawezekana kuepuka hili kwa kuongeza data ya ziada kwenye msimbo wa baiti ili kutumika kama _dhamana ya kriptografia_ ya usahihi wa msimbo chanzo, na kama _alama ya vidole_ ya taarifa za uandaaji. Taarifa muhimu hupatikana katika [metadata ya mkataba wa Solidity](https://docs.soliditylang.org/en/v0.8.15/metadata.html), na hashi ya faili hili huongezwa kwenye msimbo wa baiti wa mkataba. Unaweza kuiona ikifanya kazi katika [uwanja wa michezo wa metadata](https://playground.sourcify.dev)
+
+Faili la metadata lina taarifa kuhusu uandaaji wa mkataba ikiwa ni pamoja na faili chanzo na hashi zao. Ikimaanisha, ikiwa mipangilio yoyote ya uandaaji au hata baiti moja katika faili chanzo itabadilika, faili la metadata hubadilika. Kwa hivyo, hashi ya faili la metadata, ambayo huongezwa kwenye msimbo wa baiti, pia hubadilika. Hiyo inamaanisha ikiwa msimbo wa baiti wa mkataba + hashi ya metadata iliyoongezwa vinalingana na msimbo chanzo uliotolewa na mipangilio ya uandaaji, tunaweza kuwa na uhakika huu ndio msimbo chanzo uleule uliotumika katika uandaaji asilia, hakuna hata baiti moja tofauti.
+
+Aina hii ya uthibitishaji inayotumia hashi ya metadata inajulikana kama **"[uthibitishaji kamili](https://docs.sourcify.dev/docs/full-vs-partial-match/)"** (pia "uthibitishaji kamilifu"). Ikiwa hashi za metadata hazilingani au hazizingatiwi katika uthibitishaji itakuwa "ulinganifu wa sehemu", ambayo kwa sasa ndiyo njia ya kawaida zaidi ya kuthibitisha mikataba. Inawezekana [kuingiza msimbo wenye nia mbaya](https://samczsun.com/hiding-in-plain-sight/) ambao hauonekani katika msimbo chanzo uliothibitishwa bila uthibitishaji kamili. Wasanidi programu wengi hawafahamu kuhusu uthibitishaji kamili na hawatunzi faili la metadata la uandaaji wao, kwa hivyo uthibitishaji wa sehemu umekuwa ndiyo njia halisi ya kuthibitisha mikataba hadi sasa.
+
+## Kwa nini uthibitishaji wa msimbo chanzo ni muhimu? {#importance-of-source-code-verification}
+
+### Hali ya Kutohitaji Uaminifu {#trustlessness}
+
+Hali ya kutohitaji uaminifu bila shaka ndiyo msingi mkuu wa mikataba-erevu na [mfumo uliotawanywa (dapps)](/developers/docs/dapps/). Mikataba-erevu "haibadiliki" na haiwezi kubadilishwa; mkataba utatekeleza tu mantiki ya biashara iliyofafanuliwa katika msimbo wakati wa kupelekwa. Hii inamaanisha wasanidi programu na makampuni hawawezi kuchezea msimbo wa mkataba baada ya kuupeleka kwenye Ethereum.
+
+Ili mkataba-erevu usiwe wa kuhitaji uaminifu, msimbo wa mkataba unapaswa kupatikana kwa ajili ya uthibitishaji huru. Ingawa msimbo wa baiti ulioandaliwa kwa kila mkataba-erevu unapatikana hadharani kwenye mnyororo wa bloku, lugha ya kiwango cha chini ni ngumu kuelewa—kwa wasanidi programu na watumiaji.
+
+Miradi hupunguza dhana za uaminifu kwa kuchapisha msimbo chanzo wa mikataba yao. Lakini hii inasababisha tatizo lingine: ni vigumu kuthibitisha kwamba msimbo chanzo uliochapishwa unalingana na msimbo wa baiti wa mkataba. Katika hali hii, thamani ya kutokuwa na haja ya kuaminiana inapotea kwa sababu watumiaji wanapaswa kuwaamini wasanidi programu wasibadili mantiki ya biashara ya mkataba (yaani, kwa kubadilisha msimbo wa baiti) kabla ya kuupeleka kwenye mnyororo wa bloku.
+
+Zana za uthibitishaji wa msimbo chanzo hutoa dhamana kwamba faili za msimbo chanzo za mkataba-erevu zinalingana na msimbo wa kusanyiko. Matokeo yake ni mfumo ikolojia usiohitaji uaminifu, ambapo watumiaji hawaamini wahusika wengine bila kufikiria na badala yake huthibitisha msimbo kabla ya kuweka fedha kwenye mkataba.
+
+### Usalama wa Mtumiaji {#user-safety}
+
+Kwa mikataba-erevu, kwa kawaida kuna pesa nyingi hatarini. Hii inahitaji dhamana ya juu ya usalama na uthibitishaji wa mantiki ya mkataba-erevu kabla ya kuutumia. Tatizo ni kwamba wasanidi programu wasio waaminifu wanaweza kuwadanganya watumiaji kwa kuingiza msimbo wenye nia mbaya katika mkataba-erevu. Bila uthibitishaji, mikataba-erevu yenye nia mbaya inaweza kuwa na [milango ya nyuma](https://www.trustnodes.com/2018/11/10/concerns-rise-over-backdoored-smart-contracts), mifumo yenye utata ya udhibiti wa ufikiaji, udhaifu unaoweza kutumiwa, na mambo mengine yanayohatarisha usalama wa mtumiaji ambayo yangebaki bila kugunduliwa.
+
+Kuchapisha faili za msimbo chanzo za mkataba-erevu hurahisisha wale wanaopendezwa, kama vile wakaguzi, kutathmini mkataba kwa ajili ya mianya inayoweza kushambuliwa. Pamoja na pande nyingi kuthibitisha mkataba-erevu kwa uhuru, watumiaji wanapata dhamana imara zaidi ya usalama wake.
+
+## Jinsi ya kuthibitisha msimbo chanzo kwa mikataba-erevu ya Ethereum {#source-code-verification-for-ethereum-smart-contracts}
+
+[Kupeleka mkataba-erevu kwenye Ethereum](/developers/docs/smart-contracts/deploying/) kunahitaji kutuma muamala wenye shehena ya data (msimbo wa baiti ulioandaliwa) kwenye anwani maalum. Shehena ya data inatengenezwa kwa kuandaa msimbo chanzo, pamoja na [hoja za kiunda](https://docs.soliditylang.org/en/v0.8.14/contracts.html#constructor) za mfano wa mkataba zilizoongezwa kwenye shehena ya data katika muamala. Uandaaji ni wa kubainika, ikimaanisha daima hutoa matokeo sawa (yaani, msimbo wa baiti wa mkataba) ikiwa faili chanzo zilezile, na mipangilio ya uandaaji (k.m., toleo la kiandaaji, kiboreshaji) inatumiwa.
+
+
+
+Kuthibitisha mkataba-erevu kimsingi kunahusisha hatua zifuatazo:
+
+1. Weka faili chanzo na mipangilio ya uandaaji kwenye kiandaaji.
+
+2. Kiandaaji hutoa msimbo wa baiti wa mkataba
+
+3. Pata msimbo wa baiti wa mkataba uliopelekwa katika anwani fulani
+
+4. Linganisha msimbo wa baiti uliopelekwa na msimbo wa baiti ulioandaliwa upya. Ikiwa misimbo inalingana, mkataba unathibitishwa na msimbo chanzo uliotolewa na mipangilio ya uandaaji.
+
+5. Zaidi ya hayo, ikiwa hashi za metadata mwishoni mwa msimbo wa baiti zinalingana, itakuwa ulinganifu kamili.
+
+Kumbuka kwamba hili ni maelezo rahisi ya uthibitishaji na kuna vighairi vingi ambavyo havifanyi kazi na hili kama vile kuwa na [vigezo visivyobadilika](https://docs.sourcify.dev/docs/immutables/).
+
+## Zana za uthibitishaji wa msimbo chanzo {#source-code-verification-tools}
+
+Mchakato wa jadi wa kuthibitisha mikataba unaweza kuwa mgumu. Hii ndiyo sababu tuna zana za kuthibitisha msimbo chanzo kwa mikataba-erevu iliyopelekwa kwenye Ethereum. Zana hizi hubinafsisha sehemu kubwa za uthibitishaji wa msimbo chanzo na pia huratibu mikataba iliyothibitishwa kwa manufaa ya watumiaji.
+
+### Etherscan {#etherscan}
+
+Ingawa inajulikana zaidi kama [kichunguzi cha mnyororo wa bloku wa Ethereum](/developers/docs/data-and-analytics/block-explorers/), Etherscan pia inatoa [huduma ya uthibitishaji wa msimbo chanzo](https://etherscan.io/verifyContract) kwa wasanidi programu wa mikataba-erevu na watumiaji.
+
+Etherscan hukuruhusu kuandaa upya msimbo wa baiti wa mkataba kutoka kwa shehena ya data asilia (msimbo chanzo, anwani ya maktaba, mipangilio ya kiandaaji, anwani ya mkataba, n.k.) Ikiwa msimbo wa baiti ulioandaliwa upya unahusishwa na msimbo wa baiti (na vigezo vya kiunda) vya mkataba ulio kwenye mnyororo, basi [mkataba unathibitishwa](https://info.etherscan.com/types-of-contract-verification/).
+
+Baada ya kuthibitishwa, msimbo chanzo wa mkataba wako hupokea lebo ya "Imethibitishwa" na huchapishwa kwenye Etherscan ili wengine wakague. Pia huongezwa kwenye sehemu ya [Mikataba Iliyothibitishwa](https://etherscan.io/contractsVerified/)—hifadhi ya mikataba-erevu yenye misimbo chanzo iliyothibitishwa.
+
+Etherscan ndiyo zana inayotumika zaidi kwa kuthibitisha mikataba. Hata hivyo, uthibitishaji wa mkataba wa Etherscan una dosari: unashindwa kulinganisha **hashi ya metadata** ya msimbo wa baiti ulio kwenye mnyororo na msimbo wa baiti ulioandaliwa upya. Kwa hivyo, ulinganifu katika Etherscan ni ulinganifu wa sehemu.
+
+[Zaidi kuhusu kuthibitisha mikataba kwenye Etherscan](https://medium.com/etherscan-blog/verifying-contracts-on-etherscan-f995ab772327).
+
+### Blockscout {#blockscout}
+
+[Blockscout](https://blockscout.com/) ni kichunguzi huria cha mnyororo wa bloku ambacho pia hutoa [huduma ya uthibitishaji wa mkataba](https://eth.blockscout.com/contract-verification) kwa wasanidi programu na watumiaji wa mikataba-erevu. Kama njia mbadala ya chanzo huria, Blockscout inatoa uwazi katika jinsi uthibitishaji unavyofanywa na huwezesha michango ya jamii kuboresha mchakato wa uthibitishaji.
+
+Sawa na huduma zingine za uthibitishaji, Blockscout hukuruhusu kuthibitisha msimbo chanzo wa mkataba wako kwa kuandaa upya msimbo wa baiti na kuulinganisha na mkataba uliopelekwa. Baada ya kuthibitishwa, mkataba wako hupokea hali ya uthibitishaji na msimbo chanzo unakuwa wazi kwa umma kwa ajili ya ukaguzi na mwingiliano. Mikataba iliyothibitishwa pia imeorodheshwa katika [hifadhi ya mikataba iliyothibitishwa](https://eth.blockscout.com/verified-contracts) ya Blockscout kwa kuvinjari na ugunduzi rahisi.
+
+### Sourcify {#sourcify}
+
+[Sourcify](https://sourcify.dev/#/verifier) ni zana nyingine ya kuthibitisha mikataba ambayo ni ya chanzo-wazi na iliyogatuliwa. Siyo kichunguzi cha bloku na inathibitisha tu mikataba kwenye [mitandao tofauti inayotumia EVM](https://docs.sourcify.dev/docs/chains). Inafanya kazi kama miundombinu ya umma kwa zana zingine kujenga juu yake, na inalenga kuwezesha mwingiliano wa mikataba unaoeleweka zaidi na binadamu kwa kutumia maoni ya [ABI](/developers/docs/smart-contracts/compiling/#web-applications) na [NatSpec](https://docs.soliditylang.org/en/v0.8.15/natspec-format.html) yanayopatikana kwenye faili la metadata.
+
+Tofauti na Etherscan, Sourcify inasaidia ulinganifu kamili na hashi ya metadata. Mikataba iliyothibitishwa hutolewa katika [hifadhi yake ya umma](https://docs.sourcify.dev/docs/repository/) kwenye HTTP na [IPFS](https://docs.ipfs.io/concepts/what-is-ipfs/#what-is-ipfs), ambayo ni ghala iliyogatuliwa, ya [kushughulikiwa na maudhui](https://docs.storacha.network/concepts/content-addressing/). Hii inaruhusu kupata faili la metadata la mkataba kupitia IPFS kwa kuwa hashi ya metadata iliyoongezwa ni hashi ya IPFS.
+
+Zaidi ya hayo, mtu anaweza pia kupata faili za msimbo chanzo kupitia IPFS, kwa kuwa hashi za IPFS za faili hizi pia hupatikana kwenye metadata. Mkataba unaweza kuthibitishwa kwa kutoa faili la metadata na faili chanzo kupitia API yake au [UI](https://sourcify.dev/#/verifier), au kwa kutumia programu-jalizi. Zana ya ufuatiliaji ya Sourcify pia husikiliza uundaji wa mikataba kwenye bloku mpya na hujaribu kuthibitisha mikataba ikiwa metadata na faili zao chanzo zimechapishwa kwenye IPFS.
+
+[Zaidi kuhusu kuthibitisha mikataba kwenye Sourcify](https://soliditylang.org/blog/2020/06/25/sourcify-faq/).
+
+### Tenderly {#tenderly}
+
+[Jukwaa la Tenderly](https://tenderly.co/) huwawezesha wasanidi programu wa Web3 kujenga, kupima, kufuatilia, na kuendesha mikataba-erevu. Kwa kuchanganya zana za utatuzi na uonekanaji na vizuizi vya ujenzi wa miundombinu, Tenderly husaidia wasanidi programu kuharakisha uundaji wa mkataba-erevu. Ili kuwezesha kikamilifu vipengele vya Tenderly, wasanidi programu wanahitaji [kufanya uthibitishaji wa msimbo chanzo](https://docs.tenderly.co/monitoring/contract-verification) kwa kutumia mbinu kadhaa.
+
+Inawezekana kuthibitisha mkataba kwa faragha au hadharani. Ikithibitishwa kwa faragha, mkataba-erevu unaonekana kwako pekee (na wanachama wengine katika mradi wako). Kuthibitisha mkataba hadharani kunaufanya uonekane kwa kila mtu anayetumia jukwaa la Tenderly.
+
+Unaweza kuthibitisha mikataba yako kwa kutumia [Dashibodi](https://docs.tenderly.co/contract-verification), [programu-jalizi ya Tenderly Hardhat](https://docs.tenderly.co/contract-verification/hardhat), au [CLI](https://docs.tenderly.co/monitoring/smart-contract-verification/verifying-contracts-using-cli).
+
+Wakati wa kuthibitisha mikataba kupitia Dashibodi, unahitaji kuingiza faili chanzo au faili la metadata lililotengenezwa na kiandaaji cha Solidity, anwani/mtandao, na mipangilio ya kiandaaji.
+
+Kutumia programu-jalizi ya Tenderly Hardhat kunaruhusu udhibiti zaidi juu ya mchakato wa uthibitishaji kwa juhudi kidogo, kukuwezesha kuchagua kati ya uthibitishaji wa kiotomatiki (bila-msimbo) na wa mwongozo (unaotegemea-msimbo).
+
+## Masomo zaidi {#further-reading}
+
+- [Kuthibitisha msimbo chanzo wa mkataba](https://programtheblockchain.com/posts/2018/01/16/verifying-contract-source-code/)
diff --git a/public/content/translations/sw/developers/docs/standards/index.md b/public/content/translations/sw/developers/docs/standards/index.md
new file mode 100644
index 00000000000..ab8f35b6e17
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/index.md
@@ -0,0 +1,59 @@
+---
+title: Viwango vya Maendeleo ya Ethereum
+description: Kujifunza kuhusu viwango vya Ethereum ikiwa ni pamoja na EIPs, viwango vya ishara kama ERC-20 na ERC-721, na mikataba ya maendeleo.
+lang: sw
+incomplete: true
+---
+
+## Muhtasari wa viwango {#standards-overview}
+
+Jumuiya ya Ethereum imepitisha viwango vingi vinavyosaidia miradi (kama vile [wateja wa Ethereum](/developers/docs/nodes-and-clients/) na mikoba) iweze kuingiliana katika utekelezaji mbalimbali, na kuhakikisha kuwa mikataba mahiri na mfumo mtawanyo wa kimamlaka unabaki kuwa na utungo.
+
+Kwa kawaida viwango huletwa kama [Mapendekezo ya Uboreshaji ya Ethereum](/eips/) (EIPs), ambazo hujadiliwa na wanajumuiya kupitia [mchakato wa kawaida](https://eips.ethereum.org/EIPS/eip-1).
+
+- [Utangulizi wa EIPs](/eips/)
+- [Orodha ya EIPs](https://eips.ethereum.org/)
+- [Hazina ya GitHub ya EIP](https://github.com/ethereum/EIPs)
+- [Jukwaa la majadiliano la EIP](https://ethereum-magicians.org/c/eips)
+- [Utangulizi wa Utawala wa Ethereum](/governance/)
+- [Muhtasari wa Utawala wa Ethereum](https://web.archive.org/web/20201107234050/https://blog.bmannconsulting.com/ethereum-governance/) _Machi 31, 2019 - Boris Mann_
+- [Utawala wa Maendeleo ya Itifaki ya Ethereum na Uratibu wa Uboreshaji wa Mtandao](https://hudsonjameson.com/posts/2020-03-23-ethereum-protocol-development-governance-and-network-upgrade-coordination/) _Machi 23, 2020 - Hudson Jameson_
+- [Orodha ya kucheza ya Mikutano yote ya Wasanidi Wakuu wa Ethereum](https://www.youtube.com/@EthereumProtocol) _(Orodha ya kucheza ya YouTube)_
+
+## Aina za viwango {#types-of-standards}
+
+Kuna aina 3 za EIPs:
+
+- Viwango nyayo: kueleza mabadiliko yoyote ambayo kuathiri zaidi au utekelezaji wote Ethereum
+- [Njia ya Meta](https://eips.ethereum.org/meta): inaelezea mchakato unaohusu Ethereum au inapendekeza mabadiliko kwenye mchakato
+- [Njia ya Habari](https://eips.ethereum.org/informational): inaelezea suala la usanifu wa Ethereum au inatoa miongozo ya jumla au taarifa kwa jumuiya ya Ethereum
+
+Zaidi ya hayo, kiwango nyayo kugawa katika makundi 4:
+
+- [Msingi](https://eips.ethereum.org/core): maboresho yanayohitaji uma wa makubaliano
+- [Mtandao](https://eips.ethereum.org/networking): maboresho yanayohusu devp2p na Itifaki Ndogo ya Light Ethereum, pamoja na maboresho yaliyopendekezwa kwa vipimo vya itifaki ya mtandao ya whisper na swarm.
+- [Kiolesura](https://eips.ethereum.org/interface): maboresho kuhusu vipimo na viwango vya API/RPC vya mteja, na viwango fulani vya lugha kama vile majina ya mbinu na ABI za mkataba.
+- [ERC](https://eips.ethereum.org/erc): viwango na kanuni za kiwango cha programu
+
+Maelezo zaidi kuhusu aina na kategoria hizi tofauti yanaweza kupatikana katika [EIP-1](https://eips.ethereum.org/EIPS/eip-1#eip-types)
+
+### Viwango vya tokeni {#token-standards}
+
+- [ERC-20](/developers/docs/standards/tokens/erc-20/) - Kiolesura cha kawaida cha tokeni zinazoweza kubadilishwa (interchangeable), kama vile tokeni za kupiga kura, tokeni za kuweka hisa au sarafu pepe.
+ - [ERC-223](/developers/docs/standards/tokens/erc-223/) - Kiwango cha tokeni zinazoweza kubadilishwa ambacho hufanya tokeni kuwa na tabia sawa na ether na inasaidia ushughulikiaji wa uhamisho wa tokeni kwa upande wa mpokeaji.
+ - [ERC-1363](/developers/docs/standards/tokens/erc-1363/) - Kiolesura cha kiendelezi cha tokeni za ERC-20 kinachosaidia utekelezaji wa simurejeshi kwenye mikataba ya mpokeaji katika muamala mmoja.
+- [ERC-721](/developers/docs/standards/tokens/erc-721/) - Kiolesura cha kawaida cha tokeni zisizoweza kubadilishwa, kama hati miliki ya mchoro au wimbo.
+ - [ERC-2309](https://eips.ethereum.org/EIPS/eip-2309) - Tukio la kawaida linalotolewa wakati wa kuunda/kuhamisha tokeni moja, au nyingi zisizoweza kubadilishwa kwa kutumia vitambulisho vya tokeni vinavyofuatana.
+ - [ERC-4400](https://eips.ethereum.org/EIPS/eip-4400) - Kiendelezi cha kiolesura cha jukumu la mtumiaji wa EIP-721.
+ - [ERC-4907](https://eips.ethereum.org/EIPS/eip-4907) - Huongeza jukumu la muda mfupi na ruhusa zilizozuiliwa kwa tokeni za ERC-721.
+- [ERC-777](/developers/docs/standards/tokens/erc-777/) - **(HAIPENDEKEZWI)** Kiwango cha tokeni kinachoboresha ERC-20.
+- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - Kiwango cha tokeni ambacho kinaweza kuwa na mali zinazoweza kubadilishwa na zisizoweza kubadilishwa.
+- [ERC-4626](/developers/docs/standards/tokens/erc-4626/) - Kiwango cha kuba la tokeni iliyoundwa ili kuboresha na kuunganisha vigezo vya kiufundi vya kuba zinazotoa mavuno.
+
+Jifunze zaidi kuhusu [viwango vya tokeni](/developers/docs/standards/tokens/).
+
+## Masomo zaidi {#further-reading}
+
+- [Mapendekezo ya Uboreshaji ya Ethereum (EIPs)](/eips/)
+
+_Unajua rasilimali ya jamii iliyokusaidia?_ Hariri ukurasa huu na uiongeze!_
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-1155/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-1155/index.md
new file mode 100644
index 00000000000..d371221b996
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-1155/index.md
@@ -0,0 +1,146 @@
+---
+title: ERC-1155 Mengi-ishara Kiwango
+description: Jifunze kuhusu ERC-1155, kiwango cha tokeni-nyingi ambacho kinachanganya tokeni zinazoweza kubadilishana na zisizoweza kubadilishana katika mkataba mmoja.
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+Kiwango Mtandao kwa ajili ya mikataba ambayo kusimamia aina nyingi ishara. Mkataba mmoja uliotumwa unaweza kuwa na mchanganyiko wowote wa tokeni zinazoweza kubadilishana, tokeni zisizoweza kubadilishana au usanidi mwingine (k.m., tokeni nusu-badilishani).
+
+**Nini maana ya mengi-ishara kiwango?**
+
+Wazo ni rahisi na inataka kujenga erevu mkataba ni Mtandao ambayo inaweza kuwakilisha na kudhibiti idadi yoyote ya badilishwa na zisizo badilishwa aina ishara. Kwa njia hii, tokeni ya ERC-1155 inaweza kufanya kazi sawa na tokeni ya [ERC-20](/developers/docs/standards/tokens/erc-20/) na [ERC-721](/developers/docs/standards/tokens/erc-721/), na hata zote mbili kwa wakati mmoja. Wezesha utendaji wa viwango vya ERC-20 na ERC-721, na kuifanya iwe na ufanisi zaidi na kurekebisha makosa dhahiri ya utekelezaji.
+
+Tokeni ya ERC-1155 imeelezewa kikamilifu katika [EIP-1155](https://eips.ethereum.org/EIPS/eip-1155).
+
+## Mahitaji ya awali {#prerequisites}
+
+Ili kuelewa ukurasa huu vizuri, tunapendekeza kwanza usome kuhusu [viwango vya tokeni](/developers/docs/standards/tokens/), [ERC-20](/developers/docs/standards/tokens/erc-20/), na [ERC-721](/developers/docs/standards/tokens/erc-721/).
+
+## Kazi na Vipengele vya ERC-1155: {#body}
+
+- [Uhamisho wa Kundi](#batch_transfers): Hamisha rasilimali nyingi kwa wito mmoja.
+- [Salio la Kundi](#batch_balance): Pata salio za rasilimali nyingi kwa wito mmoja.
+- [Idhini ya Kundi](#batch_approval): Idhinisha tokeni zote kwa anwani.
+- [Hook](#receive_hook): Hook ya kupokea tokeni.
+- [Usaidizi wa NFT](#nft_support): Ikiwa usambazaji ni 1 pekee, ichukulie kama NFT.
+- [Kanuni za Uhamisho Salama](#safe_transfer_rule): Seti ya kanuni za uhamisho salama.
+
+### Uhamisho wa Kundi {#batch-transfers}
+
+Uhamisho wa kundi hufanya kazi sawa na uhamisho wa kawaida wa ERC-20. Hebu tuangalie kazi ya kawaida ya `transferFrom` ya ERC-20:
+
+```solidity
+// ERC-20
+function transferFrom(address from, address to, uint256 value) external returns (bool);
+
+// ERC-1155
+function safeBatchTransferFrom(
+ address _from,
+ address _to,
+ uint256[] calldata _ids,
+ uint256[] calldata _values,
+ bytes calldata _data
+) external;
+```
+
+Tofauti tu katika ERC-1155 ni kwamba sisi kupita maadili kama safu na sisi pia kupita safu ya kitambulisho. Kwa mfano, ukipewa `ids=[3, 6, 13]` na `values=[100, 200, 5]`, uhamisho utakaotokea utakuwa
+
+1. Hamisha tokeni 100 zenye id 3 kutoka `_from` kwenda `_to`.
+2. Hamisha tokeni 200 zenye id 6 kutoka `_from` kwenda `_to`.
+3. Hamisha tokeni 5 zenye id 13 kutoka `_from` kwenda `_to`.
+
+Katika ERC-1155 tuna `transferFrom` pekee, hakuna `transfer`. Ili kuitumia kama `transfer` ya kawaida, weka tu anwani ya kutoka iwe anwani inayoita kazi.
+
+### Salio la Kundi {#batch-balance}
+
+Wito husika wa `balanceOf` wa ERC-20 kadhalika una kazi yake mshirika yenye usaidizi wa kundi. Kama ukumbusho, hii ni ERC-20 toleo:
+
+```solidity
+// ERC-20
+function balanceOf(address owner) external view returns (uint256);
+
+// ERC-1155
+function balanceOfBatch(
+ address[] calldata _owners,
+ uint256[] calldata _ids
+) external view returns (uint256[] memory);
+```
+
+Hata rahisi kwa usawa wito, tunaweza kupata mizani nyingi katika wito moja. Sisi kupita safu ya wenyeji, kufuatia na safu ya kitambulisho ishara.
+
+Kwa mfano ukipewa `_ids=[3, 6, 13]` na `_owners=[0xbeef..., 0x1337..., 0x1111...]`, thamani ya kurudi itakuwa
+
+```solidity
+[
+ balanceOf(0xbeef...),
+ balanceOf(0x1337...),
+ balanceOf(0x1111...)
+]
+```
+
+### Idhini ya Kundi {#batch-approval}
+
+```solidity
+// ERC-1155
+function setApprovalForAll(
+ address _operator,
+ bool _approved
+) external;
+
+function isApprovedForAll(
+ address _owner,
+ address _operator
+) external view returns (bool);
+```
+
+Idhini ni tofauti kidogo kuliko ERC-20. Badala ya kuidhinisha kiasi maalum, unaweka opereta kuwa ameidhinishwa au hajaidhinishwa kupitia `setApprovalForAll`.
+
+Kusoma hali ya sasa kunaweza kufanywa kupitia `isApprovedForAll`. Kama una tazama, ni operesheni ya yote au hakuna. Huwezi kufafanua jinsi ishara nyingi kupitisha au hata ambayo ishara ya darasa.
+
+Hii ni makusudi iliyoundwa na unyenyekevu katika akili. Unaweza tu kupitisha kila kitu kwa anwani moja.
+
+### Hook ya Kupokea {#receive-hook}
+
+```solidity
+function onERC1155BatchReceived(
+ address _operator,
+ address _from,
+ uint256[] calldata _ids,
+ uint256[] calldata _values,
+ bytes calldata _data
+) external returns(bytes4);
+```
+
+Kwa usaidizi wa [EIP-165](https://eips.ethereum.org/EIPS/eip-165), ERC-1155 inasaidia hook za kupokea kwa mikataba-erevu pekee. Kulabu kazi lazima kurudi uchawi kabla ya faini baiti4 thamani ambayo ni kutokana na:
+
+```solidity
+bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))
+```
+
+Wakati mkataba kupokea anarudi thamani hii, kuchukuliwa mkataba anakubali uhamisho na anajua jinsi ya kushughulikia ERC-1155 ishara. Kubwa, hakuna zaidi kukwama ishara katika mkataba!
+
+### Usaidizi wa NFT {#nft-support}
+
+Wakati ugavi ni moja tu, ishara ni kimsingi ishara zisizo badilishwa (NFT). Na kama ni kiwango kwa ERC-721, unaweza kufafanua URL habari. URL inaweza kusomwa na kubadilishwa na wateja, angalia [hapa](https://eips.ethereum.org/EIPS/eip-1155#metadata).
+
+### Kanuni ya Uhamisho Salama {#safe-transfer-rule}
+
+Tumekuwa kuguswa juu ya utawala chache salama uhamisho tayari katika maelezo ya awali. Lakini hebu tazama utawala muhimu zaidi:
+
+1. Mtoa wito lazima aidhinishwe kutumia tokeni za anwani ya `_from` au mtoa wito lazima awe sawa na `_from`.
+2. Wito uhamisho lazima kurudi kama
+ 1. Anwani ya `_to` ni 0.
+ 2. urefu wa `_ids` si sawa na urefu wa `_values`.
+ 3. salio lolote la mmiliki kwa ajili ya tokeni katika `_ids` ni dogo kuliko kiasi husika katika `_values` kilichotumwa kwa mpokeaji.
+ 4. kosa lolote lingine hutokea.
+
+_Kumbuka_: Kazi zote za kundi, ikiwemo hook, pia zinapatikana kama matoleo yasiyo na kundi. Hii ni kufanyika kwa ajili ya ufanisi wa gesi, kuzingatia kuhamisha tu mali moja pengine bado kuwa njia ya kawaida kutumika. Wacha nje kwa uwazi katika maelezo, ikiwa ni pamoja na utawala za uhamisho salama. Majina ni sawa, tu kuondoa 'Kikundi'.
+
+## Masomo zaidi {#further-reading}
+
+- [EIP-1155: Kiwango cha Tokeni Nyingi](https://eips.ethereum.org/EIPS/eip-1155)
+- [ERC-1155: Nyaraka za OpenZeppelin](https://docs.openzeppelin.com/contracts/5.x/erc1155)
+- [ERC-1155: Repo ya GitHub](https://github.com/enjin/erc-1155)
+- [API ya NFT ya Alchemy](https://www.alchemy.com/docs/reference/nft-api-quickstart)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-1363/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-1363/index.md
new file mode 100644
index 00000000000..47415453ecc
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-1363/index.md
@@ -0,0 +1,213 @@
+---
+title: Kiwango cha Tokeni ya Kulipwa cha ERC-1363
+description: ERC-1363 ni kiolesura cha upanuzi kwa tokeni za ERC-20 ambacho kinawezesha utekelezaji wa mantiki maalum kwenye mkataba wa mpokeaji baada ya uhamisho, au kwenye mkataba wa mtumiaji baada ya idhini, yote ndani ya muamala mmoja.
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+### ERC-1363 ni nini? {#what-is-erc1363}
+
+ERC-1363 ni kiolesura cha upanuzi kwa tokeni za ERC-20 ambacho kinawezesha utekelezaji wa mantiki maalum kwenye mkataba wa mpokeaji baada ya uhamisho, au kwenye mkataba wa mtumiaji baada ya idhini, yote ndani ya muamala mmoja.
+
+### Tofauti kutoka ERC-20 {#erc20-differences}
+
+Operesheni za kawaida za ERC-20 kama `transfer`, `transferFrom` na `approve`, haziruhusu utekelezaji wa msimbo kwenye mkataba wa mpokeaji au mtumiaji bila muamala tofauti.
+Hii inaleta ugumu katika uundaji wa UI na kikwazo katika utumiaji kwa sababu watumiaji lazima wasubiri muamala wa kwanza utekelezwe na kisha wawasilishe wa pili.
+Lazima pia walipe GAS mara mbili.
+
+ERC-1363 inafanya tokeni zinazoweza kubadilishwa kuwa na uwezo wa kutekeleza vitendo kwa urahisi zaidi na kufanya kazi bila kutumia msikilizaji yeyote wa nje ya mnyororo.
+Inaruhusu kufanya mwitikio kwenye mkataba wa mpokeaji au mtumiaji, baada ya uhamisho au idhini, katika muamala mmoja.
+
+## Mahitaji ya awali {#prerequisites}
+
+Ili kuelewa ukurasa huu vizuri zaidi, tunapendekeza usome kwanza kuhusu:
+
+- [Viwango vya tokeni](/developers/docs/standards/tokens/)
+- [ERC-20](/developers/docs/standards/tokens/erc-20/)
+
+## Mwili {#body}
+
+ERC-1363 inaleta API ya kawaida kwa tokeni za ERC-20 ili kuingiliana na mikataba-erevu baada ya `transfer`, `transferFrom` au `approve`.
+
+Kiwango hiki kinatoa utendaji wa msingi wa kuhamisha tokeni, pamoja na kuruhusu tokeni kuidhinishwa ili ziweze kutumiwa na mhusika mwingine wa tatu kwenye mnyororo, na kisha kufanya mwitikio kwenye mkataba wa mpokeaji au mtumiaji.
+
+Kuna matumizi mengi yaliyopendekezwa ya mikataba-erevu ambayo inaweza kukubali mwitikio wa ERC-20.
+
+Mifano inaweza kuwa:
+
+- **Crowdsales**: tokeni zilizotumwa huchochea ugawaji wa zawadi papo hapo.
+- **Huduma**: malipo huwasha ufikiaji wa huduma kwa hatua moja.
+- **Ankara**: tokeni hulipa ankara kiotomatiki.
+- **Usajili**: kuidhinisha kiwango cha mwaka huwasha usajili ndani ya malipo ya mwezi wa kwanza.
+
+Kwa sababu hizi hapo awali iliitwa **"Tokeni ya Kulipwa"**.
+
+Tabia ya mwitikio hupanua zaidi manufaa yake, na kuwezesha mwingiliano usio na mshono kama vile:
+
+- **Kusimamisha**: tokeni zilizohamishwa huchochea kufungwa kiotomatiki katika mkataba wa kusimamisha.
+- **Kupiga kura**: tokeni zilizopokewa husajili kura katika mfumo wa utawala.
+- **Kubadilisha**: idhini za tokeni huwasha mantiki ya kubadilisha kwa hatua moja.
+
+Tokeni za ERC-1363 zinaweza kutumika kwa manufaa maalum katika visa vyote vinavyohitaji mwitikio kutekelezwa baada ya uhamisho au idhini kupokewa.
+ERC-1363 pia ni muhimu kwa kuepuka upotevu wa tokeni au kufungiwa kwa tokeni katika mikataba-erevu kwa kuthibitisha uwezo wa mpokeaji kushughulikia tokeni.
+
+Tofauti na mapendekezo mengine ya upanuzi wa ERC-20, ERC-1363 haibatilishi mbinu za ERC-20 `transfer` na `transferFrom` na inafafanua Vitambulisho vya violesura vitakavyotekelezwa huku ikidumisha uoanifu nyuma na ERC-20.
+
+Kutoka [EIP-1363](https://eips.ethereum.org/EIPS/eip-1363):
+
+### Mbinu {#methods}
+
+Mikataba-erevu inayotekeleza kiwango cha ERC-1363 **LAZIMA** itekeleze kazi zote katika kiolesura cha `ERC1363`, pamoja na violesura vya `ERC20` na `ERC165`.
+
+```solidity
+pragma solidity ^0.8.0;
+
+/**
+ * @title ERC1363
+ * @dev Kiolesura cha upanuzi kwa tokeni za ERC-20 ambacho kinawezesha utekelezaji wa msimbo kwenye mkataba wa mpokeaji
+ * baada ya `transfer` au `transferFrom`, au msimbo kwenye mkataba wa mtumiaji baada ya `approve`, katika muamala mmoja.
+ */
+interface ERC1363 is ERC20, ERC165 {
+ /*
+ * KUMBUKA: kitambulisho cha ERC-165 kwa kiolesura hiki ni 0xb0202a11.
+ * 0xb0202a11 ===
+ * bytes4(keccak256('transferAndCall(address,uint256)')) ^
+ * bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
+ * bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
+ * bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
+ * bytes4(keccak256('approveAndCall(address,uint256)')) ^
+ * bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
+ */
+
+ /**
+ * @dev Huhamisha kiasi cha `value` cha tokeni kutoka kwa akaunti ya mwitaji hadi `to`
+ * kisha huita `ERC1363Receiver::onTransferReceived` kwenye `to`.
+ * @param to Anwani ambayo tokeni zinahamishiwa.
+ * @param value Kiasi cha tokeni kitakachohamishwa.
+ * @return Thamani ya boolean inayoonyesha operesheni ilifanikiwa isipokuwa kama kuna hitilafu.
+ */
+ function transferAndCall(address to, uint256 value) external returns (bool);
+
+ /**
+ * @dev Huhamisha kiasi cha `value` cha tokeni kutoka kwa akaunti ya mwitaji hadi `to`
+ * kisha huita `ERC1363Receiver::onTransferReceived` kwenye `to`.
+ * @param to Anwani ambayo tokeni zinahamishiwa.
+ * @param value Kiasi cha tokeni kitakachohamishwa.
+ * @param data Data ya ziada isiyo na umbizo maalum, iliyotumwa katika wito kwa `to`.
+ * @return Thamani ya boolean inayoonyesha operesheni ilifanikiwa isipokuwa kama kuna hitilafu.
+ */
+ function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
+
+ /**
+ * @dev Huhamisha kiasi cha `value` cha tokeni kutoka `from` kwenda `to` kwa kutumia utaratibu wa posho
+ * kisha huita `ERC1363Receiver::onTransferReceived` kwenye `to`.
+ * @param from Anwani ambayo tokeni zinatumwa kutoka.
+ * @param to Anwani ambayo tokeni zinahamishiwa.
+ * @param value Kiasi cha tokeni kitakachohamishwa.
+ * @return Thamani ya boolean inayoonyesha operesheni ilifanikiwa isipokuwa kama kuna hitilafu.
+ */
+ function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
+
+ /**
+ * @dev Huhamisha kiasi cha `value` cha tokeni kutoka `from` kwenda `to` kwa kutumia utaratibu wa posho
+ * kisha huita `ERC1363Receiver::onTransferReceived` kwenye `to`.
+ * @param from Anwani ambayo tokeni zinatumwa kutoka.
+ * @param to Anwani ambayo tokeni zinahamishiwa.
+ * @param value Kiasi cha tokeni kitakachohamishwa.
+ * @param data Data ya ziada isiyo na umbizo maalum, iliyotumwa katika wito kwa `to`.
+ * @return Thamani ya boolean inayoonyesha operesheni ilifanikiwa isipokuwa kama kuna hitilafu.
+ */
+ function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
+
+ /**
+ * @dev Huweka kiasi cha `value` cha tokeni kama posho ya `spender` juu ya tokeni za mwitaji
+ * kisha huita `ERC1363Spender::onApprovalReceived` kwenye `spender`.
+ * @param spender Anwani itakayotumia fedha.
+ * @param value Kiasi cha tokeni kitakachotumiwa.
+ * @return Thamani ya boolean inayoonyesha operesheni ilifanikiwa isipokuwa kama kuna hitilafu.
+ */
+ function approveAndCall(address spender, uint256 value) external returns (bool);
+
+ /**
+ * @dev Huweka kiasi cha `value` cha tokeni kama posho ya `spender` juu ya tokeni za mwitaji
+ * kisha huita `ERC1363Spender::onApprovalReceived` kwenye `spender`.
+ * @param spender Anwani itakayotumia fedha.
+ * @param value Kiasi cha tokeni kitakachotumiwa.
+ * @param data Data ya ziada isiyo na umbizo maalum, iliyotumwa katika wito kwa `spender`.
+ * @return Thamani ya boolean inayoonyesha operesheni ilifanikiwa isipokuwa kama kuna hitilafu.
+ */
+ function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
+}
+
+interface ERC20 {
+ event Transfer(address indexed from, address indexed to, uint256 value);
+ event Approval(address indexed owner, address indexed spender, uint256 value);
+ function transfer(address to, uint256 value) external returns (bool);
+ function transferFrom(address from, address to, uint256 value) external returns (bool);
+ function approve(address spender, uint256 value) external returns (bool);
+ function totalSupply() external view returns (uint256);
+ function balanceOf(address account) external view returns (uint256);
+ function allowance(address owner, address spender) external view returns (uint256);
+}
+
+interface ERC165 {
+ function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+```
+
+Mkataba-erevu unaotaka kukubali tokeni za ERC-1363 kupitia `transferAndCall` au `transferFromAndCall` **LAZIMA** utekeleze kiolesura cha `ERC1363Receiver`:
+
+```solidity
+/**
+ * @title ERC1363Receiver
+ * @dev Kiolesura cha mkataba wowote unaotaka kusaidia `transferAndCall` au `transferFromAndCall` kutoka kwa mikataba ya tokeni ya ERC-1363.
+ */
+interface ERC1363Receiver {
+ /**
+ * @dev Wakati wowote tokeni za ERC-1363 zinapohamishiwa kwenye mkataba huu kupitia `ERC1363::transferAndCall` au `ERC1363::transferFromAndCall`
+ * na `operator` kutoka `from`, kazi hii inaitwa.
+ *
+ * KUMBUKA: Ili kukubali uhamisho, ni lazima hii irudishe
+ * `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))`
+ * (yaani 0x88a7ca5c, au kiteuzi chake cha kazi).
+ *
+ * @param operator Anwani iliyoita kazi ya `transferAndCall` au `transferFromAndCall`.
+ * @param from Anwani ambayo tokeni zinahamishwa kutoka.
+ * @param value Kiasi cha tokeni zilizohamishwa.
+ * @param data Data ya ziada isiyo na umbizo maalum.
+ * @return `bytes4(keccak256("onTransferReceived(address,address,uint256,bytes)"))` ikiwa uhamisho unaruhusiwa isipokuwa kama kuna hitilafu.
+ */
+ function onTransferReceived(address operator, address from, uint256 value, bytes calldata data) external returns (bytes4);
+}
+```
+
+Mkataba-erevu unaotaka kukubali tokeni za ERC-1363 kupitia `approveAndCall` **LAZIMA** utekeleze kiolesura cha `ERC1363Spender`:
+
+```solidity
+/**
+ * @title ERC1363Spender
+ * @dev Kiolesura cha mkataba wowote unaotaka kusaidia `approveAndCall` kutoka kwa mikataba ya tokeni ya ERC-1363.
+ */
+interface ERC1363Spender {
+ /**
+ * @dev Wakati wowote `mmiliki` wa tokeni za ERC-1363 anapoidhinisha mkataba huu kupitia `ERC1363::approveAndCall`
+ * kutumia tokeni zao, kazi hii inaitwa.
+ *
+ * KUMBUKA: Ili kukubali idhini, hii lazima irudishe
+ * `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))`
+ * (yaani 0x7b04a2d0, au kiteuzi chake cha kazi).
+ *
+ * @param owner Anwani iliyoita kazi ya `approveAndCall` na iliyomiliki tokeni hapo awali.
+ * @param value Kiasi cha tokeni kitakachotumiwa.
+ * @param data Data ya ziada isiyo na umbizo maalum.
+ * @return `bytes4(keccak256("onApprovalReceived(address,uint256,bytes)"))` ikiwa idhini inaruhusiwa isipokuwa kama kuna hitilafu.
+ */
+ function onApprovalReceived(address owner, uint256 value, bytes calldata data) external returns (bytes4);
+}
+```
+
+## Masomo zaidi {#further-reading}
+
+- [ERC-1363: Kiwango cha Tokeni ya Kulipwa](https://eips.ethereum.org/EIPS/eip-1363)
+- [ERC-1363: Repo ya GitHub](https://github.com/vittominacori/erc1363-payable-token)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-20/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-20/index.md
new file mode 100644
index 00000000000..b7144e5ac27
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-20/index.md
@@ -0,0 +1,192 @@
+---
+title: ERC-20 ishara kiwango
+description: Kujifunza kuhusu ERC-20, kiwango kwa ishara kubadilisha juu ya Ethereum kwamba kuwezesha maombi ishara kuingiliana.
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+**Ishara Ni Nini?**
+
+Ishara inaweza kuwakilisha kitu chochote katika Ethereum:
+
+- sifa hatua katika jukwaa Mtandao
+- ujuzi wa tabia katika mchezo
+- mali ya kifedha kama sehemu katika kampuni
+- sarafu ya fedha kama USD
+- pauni moja ya dhahabu
+- na zaidi...
+
+Kama kipengele nguvu ya Ethereum lazima kuangaliwa na kiwango imara, haki? Hiyo ni hasa
+ambapo ERC-20 ina jukumu yake! Kiwango hiki kuruhusu watengenezaji kujenga maombi ishara kwamba ni kulingana na bidhaa nyingine na huduma. Kiwango cha ERC-20 pia hutumiwa kutoa utendaji zaidi kwa [ether](/glossary/#ether).
+
+**ERC-20 ni nini?**
+
+Ya ERC-20 utangulizi kiwango kwa badilishwa ishara, kwa maneno mengine, wana mali ambayo kueneza kila ishara kuwa hasa
+sawa (katika aina na thamani) kama ishara nyingine. Kwa mfano, ERC-20 ishara vitendo tu kama ETH, maana yake ni kwamba 1 ishara
+ni na siku zote itakuwa sawa na ishara nyingine zote.
+
+## Mahitaji ya awali {#prerequisites}
+
+- Hifadhi ya fedha (/developers/docs/accounts)
+- [Mkataba erevu](/developers/docs/smart-contracts/)
+- [Viwango vya tokeni](/developers/docs/standards/tokens/)
+
+## Mwili {#body}
+
+ERC-20 (Ethereum Ombi la Maoni 20), kupendekeza na Fabian Vogelsteller mnamo Novemba 2015, ni Kiwango cha ishara ambacho
+kutekeleza API kwa ishara ndani ya Mikataba erevu.
+
+Mfano utendaji ERC-20 hutoa:
+
+- kuhamisha ishara kutoka hifadhi ya fedha moja hadi nyingine
+- kupata usawa wa sasa ishara ya hifadhi ya fedha
+- kupata ugavi jumla ya ishara inapatikana kwenye Mtandao
+- kupitisha kama kiasi cha ishara kutoka hifadhi ya fedha inaweza kutumika kwa hifadhi ya mtu wa tatu
+
+Kama erevu mkataba kutekeleza mbinu kufuatia na matukio inaweza kuitwa ERC-20 ishara ya mkataba na, mara moja kupelekwa, ni
+itakuwa na jukumu la kufuatilia ishara iliyoundwa kwenye Ethereum.
+
+Kutoka [EIP-20](https://eips.ethereum.org/EIPS/eip-20):
+
+### Mbinu {#methods}
+
+```solidity
+function name() public view returns (string)
+function symbol() public view returns (string)
+function decimals() public view returns (uint8)
+function totalSupply() public view returns (uint256)
+function balanceOf(address _owner) public view returns (uint256 balance)
+function transfer(address _to, uint256 _value) public returns (bool success)
+function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
+function approve(address _spender, uint256 _value) public returns (bool success)
+function allowance(address _owner, address _spender) public view returns (uint256 remaining)
+```
+
+### Matukio {#events}
+
+```solidity
+event Transfer(address indexed _from, address indexed _to, uint256 _value)
+event Approval(address indexed _owner, address indexed _spender, uint256 _value)
+```
+
+### Mifano {#web3py-example}
+
+Hebu angalia jinsi kiwango ni muhimu sana kufanya jambo rahisi kwa ajili yetu ya kukagua yoyote ERC-20 ishara ya mkataba juu ya Ethereum.
+Sisi tu haja ya Mkataba wa Maombi jozi Mtandao (ABI) kujenga Mtandao kwa yoyote ERC-20 ishara. Ama unaweza
+Tazama chini kutumia ABI rahisi, kuifanya mfano wa msuguano mdogo.
+
+#### Mfano wa Web3.py {#web3py-example}
+
+Kwanza, hakikisha umesakinisha maktaba ya Python ya [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation):
+
+```
+pip install web3
+```
+
+```python
+from web3 import Web3
+
+
+w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))
+
+dai_token_addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F" # DAI
+weth_token_addr = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" # Ether iliyofungwa (WETH)
+
+acc_address = "0xA478c2975Ab1Ea89e8196811F51A7B7Ade33eB11" # Uniswap V2: DAI 2
+
+# Huu ni Kiolesura Kilichorahisishwa cha Programu ya Mkataba (ABI) ya Mkataba wa Tokeni wa ERC-20.
+# Itaonyesha tu mbinu: balanceOf(address), decimals(), symbol() na totalSupply()
+simplified_abi = [
+ {
+ 'inputs': [{'internalType': 'address', 'name': 'account', 'type': 'address'}],
+ 'name': 'balanceOf',
+ 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [],
+ 'name': 'decimals',
+ 'outputs': [{'internalType': 'uint8', 'name': '', 'type': 'uint8'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [],
+ 'name': 'symbol',
+ 'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [],
+ 'name': 'totalSupply',
+ 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ }
+]
+
+dai_contract = w3.eth.contract(address=w3.to_checksum_address(dai_token_addr), abi=simplified_abi)
+symbol = dai_contract.functions.symbol().call()
+decimals = dai_contract.functions.decimals().call()
+totalSupply = dai_contract.functions.totalSupply().call() / 10**decimals
+addr_balance = dai_contract.functions.balanceOf(acc_address).call() / 10**decimals
+
+# DAI
+print("===== %s =====" % symbol)
+print("Total Supply:", totalSupply)
+print("Addr Balance:", addr_balance)
+
+weth_contract = w3.eth.contract(address=w3.to_checksum_address(weth_token_addr), abi=simplified_abi)
+symbol = weth_contract.functions.symbol().call()
+decimals = weth_contract.functions.decimals().call()
+totalSupply = weth_contract.functions.totalSupply().call() / 10**decimals
+addr_balance = weth_contract.functions.balanceOf(acc_address).call() / 10**decimals
+
+# WETH
+print("===== %s =====" % symbol)
+print("Total Supply:", totalSupply)
+print("Addr Balance:", addr_balance)
+```
+
+## Masuala yanayojulikana {#erc20-issues}
+
+### Suala la upokeaji wa tokeni ya ERC-20 {#reception-issue}
+
+**Kufikia 06/20/2024, angalau tokeni za ERC-20 zenye thamani ya $83,656,418 zilipotea kutokana na suala hili. Kumbuka kwamba utekelezaji halisi wa ERC-20 unakabiliwa na tatizo hili isipokuwa utekeleze seti ya vikwazo vya ziada juu ya kiwango kama ilivyoorodheshwa hapa chini.**
+
+Wakati ishara za ERC-20 kutumwa kwa mkataba mzuri ambao hakuna iliyoundwa kushughulikia ishara za ERC-20, ishara hizo zinaweza kupotea kabisa. Hii hutokea kwa sababu ya kupokea mkataba hana utendaji wa kutambua au kujibu ishara inayoingia, na hakuna utaratibu katika ERC-20 kiwango kuwajulisha kupokea mkataba kuhusu ishara inayoingia. Njia kuu suala hili inachukua sura ni kupitia:
+
+1. Ishara uhamisho utaratibu
+
+- ERC-20 ishara ni kuhamisha kwa kutumia uhamisho au uhamisho kutoka kazi
+ - Wakati mtumiaji tuma ishara kwa anwani ya mkataba kwa kutumia kazi hizi, ishara ni kuhamisha bila kujali kama mkataba kupokea ni iliyoundwa kushughulikia yao
+
+2. Ukosefu wa taarifa
+ - Mkataba kupokea haina kupokea taarifa au wito nyuma kwamba ishara wamekuwa alituma yake
+ - Kama mkataba kupokea haina utaratibu wa kushughulikia ishara (kwa mfano, kazi ya kurudi au kazi ya kujitolea kusimamia mapokezi ishara), ishara ni ufanisi kukwama katika anwani ya mkataba
+3. Hakuna kujengwa katika utunzaji
+ - Kiwango ERC-20 haina ni pamoja na kazi ya lazima kwa ajili ya kupokea mikataba ya kutekeleza, na kusababisha hali ambapo mikataba mengi ni hawawezi kusimamia ishara inayokuja vizuri
+
+**Suluhisho inawezekana**
+
+Wakati haiwezekani kuzuia suala hili na ERC-20 kabisa kuna mbinu ambayo kuruhusu kwa kiasi kikubwa kupunguza uwezekano wa kupoteza ishara kwa mtumiaji wa mwisho:
+
+- Tatizo la kawaida zaidi ni wakati mtumiaji anapotuma tokeni kwenye anwani ya mkataba wa tokeni yenyewe (k.m., USDT imewekwa kwenye anwani ya mkataba wa tokeni ya USDT). Inapendekezwa kuzuia kazi ya `transfer(..)` ili kurudisha majaribio kama hayo ya uhamisho. Fikiria kuongeza uhakiki wa `require(_to != address(this));` ndani ya utekelezaji wa kazi ya `transfer(..)`.
+- Kazi ya `transfer(..)` kwa ujumla haikuundwa kwa ajili ya kuweka tokeni kwenye mikataba. `kukubali(..) Mfumo wa `& transferFrom(..)`hutumika kuweka tokeni za ERC-20 kwenye mikataba badala yake. Inawezekana kuzuia kazi ya uhamisho ili kutoruhusu kuweka tokeni kwenye mikataba yoyote nayo, hata hivyo inaweza kuvunja uoanifu na mikataba ambayo inachukulia kuwa tokeni zinaweza kuwekwa kwenye mikataba kwa kutumia kazi ya`trasnfer(..)` (k.m., mabwawa ya ukwasi ya Uniswap).
+- Njia kudhani kwamba ERC-20 ishara inaweza kumaliza katika mkataba wako hata kama mkataba huo si lazima milele kupokea yoyote. Hakuna njia ya kuzuia au kukataa amana ya bahati mbaya juu ya mwisho wa wapokeaji. Kushauriwa kutekeleza kazi ambayo kuruhusu kuchimba ishara za ERC-20 zilizowekwa kwa bahati mbaya.
+- Fikiria kutumia viwango vya ishara mabadala.
+
+Baadhi ya viwango mbadala vimetokana na suala hili kama vile [ERC-223](/developers/docs/standards/tokens/erc-223) au [ERC-1363](/developers/docs/standards/tokens/erc-1363).
+
+## Masomo zaidi {#further-reading}
+
+- [EIP-20: ERC-20 ishara kiwango](https://eips.ethereum.org/EIPS/eip-20)
+- [OpenZeppelin - Tokeni](https://docs.openzeppelin.com/contracts/3.x/tokens#ERC20)
+- [OpenZeppelin - Utekelezaji wa ERC-20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)
+- [Alchemy - Mwongozo wa Tokeni za Solidity ERC20](https://www.alchemy.com/overviews/erc20-solidity)
+
+## Viwango vingine vya tokeni vinavyoweza kubadilishwa {#fungible-token-standards}
+
+- [ERC-223](/developers/docs/standards/tokens/erc-223)
+- [ERC-1363](/developers/docs/standards/tokens/erc-1363)
+- [ERC-777](/developers/docs/standards/tokens/erc-777)
+- [ERC-4626 - Hifadhi za tokeni](/developers/docs/standards/tokens/erc-4626)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-223/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-223/index.md
new file mode 100644
index 00000000000..447675933a9
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-223/index.md
@@ -0,0 +1,199 @@
+---
+title: ERC-223 ishara kiwango
+description: Maelezo ya jumla ya ERC-223 badilishwa ishara ya kiwango, jinsi kufanya kazi, na linganisha na ERC-20.
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+### ERC-223 ni nini? {#what-is-erc223}
+
+ERC-223 ni kiwango kwa ishara badilisha, sawa na kiwango ERC-20. Tofauti kuu ni kwamba ERC-223 hufafanua si tu ishara API lakini pia hoja kwa ajili ya kuhamisha ishara kutoka wa tuma kwa mpokeaji. Anzisha mfano wa mawasiliano ambayo kuruhusu uhamisho wa ishara shughulika kwa upande wa mpokeaji.
+
+### Tofauti kutoka ERC-20 {#erc20-differences}
+
+ERC-223 shughulika baadhi ya mapungufu ya ERC-20 na kuanzisha njia mpya ya mwingiliano kati ya mkataba ishara na mkataba ambayo inaweza kupokea ishara. Kuna jambo machache ambayo inawezekana na ERC-223 lakini si na ERC-20:
+
+- Usimamizi wa uhamisho wa ishara kwa upande wa mpokeaji: Wapokeaji wanaweza kugundua kuwa ishara ya ERC-223 imewekwa.
+- Kukataliwa kwa ishara vibaya walio tuma: Ikiwa mtumiaji tuma ishara za ERC-223 kwa mkataba ambao hakuna kupokea ishara, mkataba unaweza kukataa shughuli hiyo, kuzuia kupoteza wa ishara.
+- Metadata katika uhamisho: ERC-223 ishara inaweza ni pamoja na metadata, kuruhusu taarifa arbitrary kuwa masharti ya ishara shughuli.
+
+## Mahitaji ya awali {#prerequisites}
+
+- Hifadhi ya fedha (/developers/docs/accounts)
+- [Mkataba erevu](/developers/docs/smart-contracts/)
+- [Viwango vya tokeni](/developers/docs/standards/tokens/)
+- [ERC-20](/developers/docs/standards/tokens/erc-20/)
+
+## Mwili {#body}
+
+ERC-223 ni ishara ya kiwango ambacho kutekeleza API kwa ishara ndani ya mikataba erevu. Pia kutangaza API kwa ajili ya mikataba ambayo kuhitaji kupokea ERC-223 ishara. Mikataba ambayo haina msaada ERC-223 mpokeaji API haiwezi kupokea ERC-223 ishara, kuzuia makosa ya mtumiaji.
+
+Kama mkataba erevu kutekeleza mbinu kufuatia na matukio inaweza kuitwa ERC-223 sambamba ishara mkataba. Mara kupelekwa, ni
+itakuwa na jukumu la kufuatilia ishara iliyoundwa kwenye Ethereum.
+
+Mkataba si wajibu wa kuwa na kazi hizi tu na muumba unaweza kuongeza kipengele kingine chochote kutoka viwango vya ishara tofauti na mkataba huu. Kwa mfano, `kubali ` na `kuhamisha Kutoka ` kazi si sehemu ya kiwango ERC-223 lakini kazi hizi inaweza kutekelezwa kama ni lazima.
+
+Kutoka [EIP-223](https://eips.ethereum.org/EIPS/eip-223):
+
+### Mbinu {#methods}
+
+ERC-223 ishara lazima kutekeleza mbinu kufuatia:
+
+```solidity
+function name() public view returns (string)
+function symbol() public view returns (string)
+function decimals() public view returns (uint8)
+function totalSupply() public view returns (uint256)
+function balanceOf(address _owner) public view returns (uint256 balance)
+function transfer(address _to, uint256 _value) public returns (bool success)
+function transfer(address _to, uint256 _value, bytes calldata _data) public returns (bool success)
+```
+
+Mkataba ambayo inadhaniwa kupokea ERC-223 ishara lazima kutekeleza mbinu kufuatia:
+
+```solidity
+function tokenReceived(address _from, uint _value, bytes calldata _data)
+```
+
+Kama ERC-223 ishara ni alimtuma kwa mkataba kwamba haina kutekeleza `ishara pokewa(..) ` kazi basi uhamisho lazima kushindwa na ishara lazima si kuhamisha kutoka usawa wa alio tuma.
+
+### Matukio {#events}
+
+```solidity
+event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes calldata _data)
+```
+
+### Mfano {#examples}
+
+API ya ERC-223 ishara ni sawa na ile ya ERC-20, hivyo kutoka UI maendeleo mtazamo hakuna tofauti. Tofauti pekee hapa ni kwamba ERC-223 ishara haiwezi kuwa na 'kubali' + 'uhamisho kutoka' kazi kama haya ni hiari kwa ajili ya kiwango hiki.
+
+#### Mifano ya Solidity {#solidity-example}
+
+Mfano ufuatao unaonyesha jinsi ya msingi ERC-223 ishara mkataba kazi:
+
+```solidity
+pragma solidity ^0.8.19;
+abstract contract IERC223Recipient {
+ function tokenReceived(address _from, uint _value, bytes memory _data) public virtual;
+}
+contract VeryBasicERC223Token {
+ event Transfer(address indexed from, address indexed to, uint value, bytes data);
+ string private _name;
+ string private _symbol;
+ uint8 private _decimals;
+ uint256 private _totalSupply;
+ mapping(address => uint256) private balances;
+ function name() public view returns (string memory) { return _name; }
+ function symbol() public view returns (string memory) {return _symbol; }
+ function decimals() public view returns (uint8) { return _decimals; }
+ function totalSupply() public view returns (uint256) { return _totalSupply; }
+ function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; }
+ function isContract(address account) internal view returns (bool) {
+ uint256 size;
+ assembly { size := extcodesize(account) }
+ return size > 0;
+ }
+ function transfer(address _to, uint _value, bytes calldata _data) public returns (bool success){
+ balances[msg.sender] = balances[msg.sender] - _value;
+ balances[_to] = balances[_to] + _value;
+ if(isContract(_to)) {
+ IERC223Recipient(_to).tokenReceived(msg.sender, _value, _data);
+ }
+ emit Transfer(msg.sender, _to, _value, _data);
+ return true;
+ }
+ function transfer(address _to, uint _value) public returns (bool success){
+ bytes memory _empty = hex"00000000";
+ balances[msg.sender] = balances[msg.sender] - _value;
+ balances[_to] = balances[_to] + _value;
+ if(isContract(_to)) {
+ IERC223Recipient(_to).tokenReceived(msg.sender, _value, _empty);
+ }
+ emit Transfer(msg.sender, _to, _value, _empty);
+ return true;
+ }
+}
+```
+
+Sasa tunataka mkataba mwingine kukubali amana ya ishara ya A kwa kudhani kwamba ishara ya A ni ishara ya ERC-223. Mkataba lazima kukubali tu ishara A na kukataa ishara nyingine yoyote. Wakati mkataba anapata ishara A ni lazima kutoa tukio la 'amana()' na kuongeza thamani ya ndani 'amana' kutofautiana.
+
+Hapa ni nambari:
+
+```solidity
+contract RecipientContract is IERC223Recipient {
+ event Deposit(address whoSentTheTokens);
+ uint256 deposits = 0;
+ address tokenA; // Tokeni pekee tunayotaka kukubali.
+ function tokenReceived(address _from, uint _value, bytes memory _data) public override
+ {
+ // Ni muhimu kuelewa kwamba ndani ya utendakazi huu
+ // msg.sender ni anwani ya tokeni inayopokewa,
+ // msg.value daima ni 0 kwa vile mkataba wa tokeni haumiliki wala kutuma ether katika hali nyingi,
+ // _from ni mtumaji wa uhamishaji wa tokeni,
+ // _value ni kiasi cha tokeni kilichowekwa.
+ require(msg.sender == tokenA);
+ deposits += _value;
+ emit Deposit(_from);
+ }
+}
+```
+
+## Maswali yanayoulizwa mara kwa mara {#faq}
+
+### Nini kutokea kama sisi tuma baadhi ya ishara B kwa mkataba? {#sending-tokens}
+
+Mkataba utashindwa, na uhamisho wa ishara hakuna kutokea. Ishara kurudi kwenye anwani ya aliye tuma.
+
+### Tunaweza aje kuweka amana kwa mkataba huu? {#contract-deposits}
+
+Wito `uhamisho (anwani,uint256) ` au `uhamisho (anwani,uint256,bytes) ` kazi ya ERC-223 ishara, kutaja anwani ya `Mpokeaji Mkataba`.
+
+### Nini kutokea kama sisi kuhamisha ERC-20 ishara ya mkataba huu? {#erc-20-transfers}
+
+Kama ishara ERC-20 ni alimtuma kwa `Mpokeaji mkataba`, ishara itakuwa na uhamisho, lakini uhamisho itakuwa si kujulikana (hakuna `amana() ` tukio itakuwa ya kutolewa, na amana thamani hakuna badiliko). Hakuna kwenye ERC-20 amana haiwezi kuchuja au kuzuia.
+
+### Nini kama tunataka kutekeleza baadhi ya kazi baada ya amana ishara ni kukamilika? {#function-execution}
+
+Kuna njia nyingi za kufanya hivyo. Katika mfano huu kufuata njia ambayo kufanya ERC-223 uhamisho sawa na uhamisho Ether:
+
+```solidity
+contract RecipientContract is IERC223Recipient {
+ event Foo();
+ event Bar(uint256 someNumber);
+ address tokenA; // Tokeni pekee tunayotaka kukubali.
+ function tokenReceived(address _from, uint _value, bytes memory _data) public override
+ {
+ require(msg.sender == tokenA);
+ address(this).call(_data); // Shikilia muamala unaoingia na ufanye wito wa utendakazi unaofuata.
+ }
+ function foo() public
+ {
+ emit Foo();
+ }
+ function bar(uint256 _someNumber) public
+ {
+ emit Bar(_someNumber);
+ }
+}
+```
+
+Wakati `Mpokeaji Mkataba` atapokea ERC-223 ishara ya mkataba elekez kazi mwandiko wa fumbo kama `_takwimu`kigezo ya shughuli ishara, sawa na jinsi shughuli Ether kanuni wito kazi kama shughuli `takwimu`. Soma [sehemu ya data](/developers/docs/transactions/#the-data-field) kwa habari zaidi.
+
+Katika mfano hapo juu ERC-223 ishara lazima uhamisho kwa anwani ya `Mpokeaji Mkataba` na `uhamisho(anwani,uin256,bytes wito takwimu _takwimu) ` kazi. Kama takwimu kigezo itakuwa `0xc2985578` (saini ya `foo() ` kazi) basi kazi foo() itaitwa baada ya amana ishara ni kupokea na tukio Foo() itakuwa kuacha.
+
+Vigezo inaweza mwandiko wa fumbo katika `takwimu ` ya uhamisho ishara kama, kwa mfano tunaweza wito bar () kazi na 12345 thamani kwa `_baadhi Idadi `. Katika kesi hii `takwimu` lazima
+`0x0423a13200000000000000000000000000000000000000000000000000000000000004d2' ambapo '0x0423a132` ni saini ya kazi ya `bar(uint256) ` na `00000000000000000000000000000000000000000000000000000000000004d2` ni 12345 kama uint256.
+
+## Vizuizi {#limitations}
+
+Wakati ERC-223 kushughulikia suala kadhaa kupatikana katika kiwango ERC-20, ni si bila mapungufu yake mwenyewe:
+
+- Kupitishwa na tangamano: ERC-223 bado haijatumiwa sana, ambayo inaweza kupunguza tangamano wao na zana na majukwaa yaliyomo.
+- Nyuma tangamano: ERC-223 si nyuma sambamba na ERC-20, maana yake ni kwamba kuwa ERC-20 mikataba na zana si kazi na ERC-223 ishara bila marekebisho.
+- Gharama za gesi: ukaguzi wa ziada na utendaji katika uhamisho wa ERC-223 unaweza kusababisha gharama za juu za gesi ikilinganishwa na shughuli za ERC-20.
+
+## Masomo zaidi {#further-reading}
+
+- [EIP-223: ERC-223 ishara kiwango](https://eips.ethereum.org/EIPS/eip-223)
+- [Pendekezo la awali ERC-223](https://github.com/ethereum/eips/issues/223)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-4626/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-4626/index.md
new file mode 100644
index 00000000000..aa4b8b0ec78
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-4626/index.md
@@ -0,0 +1,227 @@
+---
+title: Kiwango cha Vault ya Tokeni cha ERC-4626
+description: Kiwango cha vault zinazozalisha faida.
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+ERC-4626 ni kiwango cha kuboresha na kuunganisha vigezo vya kiufundi vya vault zinazozalisha faida. Inatoa API ya kawaida kwa vault za tokeni zinazozalisha faida ambazo zinawakilisha hisa za tokeni moja ya msingi ya ERC-20. ERC-4626 pia inaelezea kiendelezi cha hiari kwa vault za tokeni zinazotumia ERC-20, ikitoa utendakazi wa msingi wa kuweka, kutoa tokeni na kusoma salio.
+
+**Jukumu la ERC-4626 katika vault zinazozalisha faida**
+
+Masoko ya kukopesha, vikusanyaji, na tokeni zenye riba asilia husaidia watumiaji kupata faida bora kwenye tokeni zao za crypto kwa kutekeleza mikakati tofauti. Mikakati hii inafanywa kwa tofauti kidogo, ambayo inaweza kuwa rahisi kukosea au kupoteza rasilimali za maendeleo.
+
+ERC-4626 katika vault zinazozalisha faida itapunguza juhudi za ujumuishaji na kufungua ufikiaji wa faida katika programu mbalimbali kwa juhudi ndogo maalum kutoka kwa wasanidi programu kwa kuunda mifumo ya utekelezaji thabiti na imara zaidi.
+
+Tokeni ya ERC-4626 imeelezewa kikamilifu katika [EIP-4626](https://eips.ethereum.org/EIPS/eip-4626).
+
+**Kiendelezi cha vault kisichosawazishwa (ERC-7540)**
+
+ERC-4626 imeboreshwa kwa uwekaji na ukombozi wa atomiki hadi kufikia kikomo. Ikiwa kikomo kimefikiwa, hakuna uwekaji au ukombozi mpya unaoweza kuwasilishwa. Kikomo hiki hakifanyi kazi vizuri kwa mfumo wowote wa mkataba-erevu wenye vitendo visivyosawazishwa au ucheleweshaji kama sharti la awali la kuingiliana na Vault (k.m., itifaki za mali za ulimwengu halisi, itifaki za ukopeshaji zisizo na dhamana ya kutosha, itifaki za ukopeshaji za mnyororo-tofauti, tokeni za liquid staking, au moduli za usalama wa bima).
+
+ERC-7540 hupanua matumizi ya Vault za ERC-4626 kwa matumizi yasiyosawazishwa. Kiolesura kilichopo cha Vault (`deposit`/`withdraw`/`mint`/`redeem`) kinatumika kikamilifu kudai Maombi yasiyosawazishwa.
+
+Kiendelezi cha ERC-7540 kimeelezewa kikamilifu katika [ERC-7540](https://eips.ethereum.org/EIPS/eip-7540).
+
+**Kiendelezi cha vault ya mali nyingi (ERC-7575)**
+
+Kisa kimoja cha matumizi kinachokosekana ambacho hakitumiki na ERC-4626 ni Vault ambazo zina mali nyingi au sehemu za kuingilia kama vile Tokeni za mtoaji ukwasi (LP). Hizi kwa ujumla ni ngumu kutumia au hazikidhi matakwa kwa sababu ya hitaji la ERC-4626 lenyewe kuwa ERC-20.
+
+ERC-7575 inaongeza usaidizi kwa Vault zenye mali nyingi kwa kutoa nje utekelezaji wa tokeni ya ERC-20 kutoka kwa utekelezaji wa ERC-4626.
+
+Kiendelezi cha ERC-7575 kimeelezewa kikamilifu katika [ERC-7575](https://eips.ethereum.org/EIPS/eip-7575).
+
+## Mahitaji ya awali {#prerequisites}
+
+Ili kuelewa ukurasa huu vizuri zaidi, tunapendekeza usome kwanza kuhusu [viwango vya tokeni](/developers/docs/standards/tokens/) na [ERC-20](/developers/docs/standards/tokens/erc-20/).
+
+## Kazi na Vipengele vya ERC-4626: {#body}
+
+### Mbinu {#methods}
+
+#### mali {#asset}
+
+```solidity
+function asset() public view returns (address assetTokenAddress)
+```
+
+Kazi hii inarudisha anwani ya tokeni ya msingi inayotumika kwa vault kwa uhasibu, kuweka na kutoa.
+
+#### totalAssets {#totalassets}
+
+```solidity
+function totalAssets() public view returns (uint256)
+```
+
+Kazi hii inarudisha jumla ya mali ya msingi inayoshikiliwa na vault.
+
+#### convertToShares {#convertoshares}
+
+```solidity
+function convertToShares(uint256 assets) public view returns (uint256 shares)
+```
+
+Kazi hii inarudisha kiasi cha `hisa` kitakachobadilishwa na vault kwa kiasi cha `mali` kilichotolewa.
+
+#### convertToAssets {#convertoassets}
+
+```solidity
+function convertToAssets(uint256 shares) public view returns (uint256 assets)
+```
+
+Kazi hii inarudisha kiasi cha `mali` kitakachobadilishwa na vault kwa kiasi cha `hisa` kilichotolewa.
+
+#### maxDeposit {#maxdeposit}
+
+```solidity
+function maxDeposit(address receiver) public view returns (uint256 maxAssets)
+```
+
+Kazi hii inarudisha kiasi cha juu zaidi cha mali ya msingi kinachoweza kuwekwa katika wito mmoja wa [`deposit`](#deposit), pamoja na hisa zilizotengenezwa kwa ajili ya `mpokeaji`.
+
+#### previewDeposit {#previewdeposit}
+
+```solidity
+function previewDeposit(uint256 assets) public view returns (uint256 shares)
+```
+
+Kazi hii inaruhusu watumiaji kuiga athari za uwekaji wao katika bloku ya sasa.
+
+#### deposit {#deposit}
+
+```solidity
+function deposit(uint256 assets, address receiver) public returns (uint256 shares)
+```
+
+Kazi hii huweka `mali` ya tokeni za msingi ndani ya vault na inatoa umiliki wa `hisa` kwa `mpokeaji`.
+
+#### maxMint {#maxmint}
+
+```solidity
+function maxMint(address receiver) public view returns (uint256 maxShares)
+```
+
+Kazi hii inarudisha kiasi cha juu zaidi cha hisa kinachoweza kutengenezwa katika wito mmoja wa [`mint`](#mint), pamoja na hisa zilizotengenezwa kwa ajili ya `mpokeaji`.
+
+#### previewMint {#previewmint}
+
+```solidity
+function previewMint(uint256 shares) public view returns (uint256 assets)
+```
+
+Kazi hii inaruhusu watumiaji kuiga athari za utengenezaji wao katika bloku ya sasa.
+
+#### mint {#mint}
+
+```solidity
+function mint(uint256 shares, address receiver) public returns (uint256 assets)
+```
+
+Kazi hii hutengeneza hasa hisa `hisa` za vault kwa `mpokeaji` kwa kuweka `mali` ya tokeni za msingi.
+
+#### maxWithdraw {#maxwithdraw}
+
+```solidity
+function maxWithdraw(address owner) public view returns (uint256 maxAssets)
+```
+
+Kazi hii inarudisha kiasi cha juu zaidi cha mali ya msingi kinachoweza kutolewa kutoka kwa salio la `mmiliki` kwa wito mmoja wa [`withdraw`](#withdraw).
+
+#### previewWithdraw {#previewwithdraw}
+
+```solidity
+function previewWithdraw(uint256 assets) public view returns (uint256 shares)
+```
+
+Kazi hii inaruhusu watumiaji kuiga athari za utoaji wao katika bloku ya sasa.
+
+#### withdraw {#withdraw}
+
+```solidity
+function withdraw(uint256 assets, address receiver, address owner) public returns (uint256 shares)
+```
+
+Kazi hii huchoma `hisa` kutoka kwa `mmiliki` na kutuma hasa tokeni za `mali` kutoka kwa vault kwenda kwa `mpokeaji`.
+
+#### maxRedeem {#maxredeem}
+
+```solidity
+function maxRedeem(address owner) public view returns (uint256 maxShares)
+```
+
+Kazi hii inarudisha kiasi cha juu zaidi cha hisa zinazoweza kukombolewa kutoka kwa salio la `mmiliki` kupitia wito wa [`redeem`](#redeem).
+
+#### previewRedeem {#previewredeem}
+
+```solidity
+function previewRedeem(uint256 shares) public view returns (uint256 assets)
+```
+
+Kazi hii inaruhusu watumiaji kuiga athari za ukombozi wao katika bloku ya sasa.
+
+#### redeem {#redeem}
+
+```solidity
+function redeem(uint256 shares, address receiver, address owner) public returns (uint256 assets)
+```
+
+Kazi hii hukomboa idadi maalum ya `hisa` kutoka kwa `mmiliki` na kutuma `mali` ya tokeni ya msingi kutoka kwa vault kwenda kwa `mpokeaji`.
+
+#### totalSupply {#totalsupply}
+
+```solidity
+function totalSupply() public view returns (uint256)
+```
+
+Inarudisha jumla ya idadi ya hisa za vault ambazo hazijakombolewa katika mzunguko.
+
+#### balanceOf {#balanceof}
+
+```solidity
+function balanceOf(address owner) public view returns (uint256)
+```
+
+Inarudisha jumla ya hisa za vault ambazo `mmiliki` anazo kwa sasa.
+
+### Ramani ya kiolesura {#mapOfTheInterface}
+
+
+
+### Matukio {#events}
+
+#### Tukio la Kuweka
+
+**LAZIMA** itolewe wakati tokeni zinawekwa ndani ya vault kupitia njia za [`mint`](#mint) na [`deposit`](#deposit).
+
+```solidity
+event Deposit(
+ address indexed sender,
+ address indexed owner,
+ uint256 assets,
+ uint256 shares
+)
+```
+
+Ambapo `mtumaji` ni mtumiaji ambaye alibadilisha `mali` kwa `hisa`, na akahamisha `hisa` hizo kwa `mmiliki`.
+
+#### Tukio la Kutoa
+
+**LAZIMA** itolewe wakati hisa zinatolewa kutoka kwa vault na mwekaji katika njia za [`redeem`](#redeem) au [`withdraw`](#withdraw).
+
+```solidity
+event Withdraw(
+ address indexed sender,
+ address indexed receiver,
+ address indexed owner,
+ uint256 assets,
+ uint256 shares
+)
+```
+
+Ambapo `mtumaji` ni mtumiaji aliyeanzisha utoaji na akabadilisha `hisa`, zinazomilikiwa na `mmiliki`, kwa `mali`. `mpokeaji` ni mtumiaji aliyepokea `mali` zilizotolewa.
+
+## Masomo zaidi {#further-reading}
+
+- [EIP-4626: Kiwango cha Vault ya Tokeni](https://eips.ethereum.org/EIPS/eip-4626)
+- [ERC-4626: Repo ya GitHub](https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC4626.sol)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-721/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-721/index.md
new file mode 100644
index 00000000000..84249cea452
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-721/index.md
@@ -0,0 +1,248 @@
+---
+title: Kiwango cha Tokeni isiyoweza kubadilishwa cha ERC-721
+description: Jifunze kuhusu ERC-721, kiwango cha tokeni zisizoweza kubadilishwa (NFTs) zinazowakilisha mali za kipekee za kidijitali kwenye Ethereum.
+lang: sw
+---
+
+## Utangulizi {#introduction}
+
+**Tokeni isiyoweza kubadilishwa ni nini?**
+
+Tokeni isiyoweza kubadilishwa (NFT) hutumika kutambua kitu au mtu kwa njia ya kipekee. Aina hii ya Tokeni inafaa sana kutumika kwenye majukwaa yanayotoa vitu vya kukusanywa, funguo za ufikiaji, tiketi za bahati nasibu, viti vilivyo na nambari kwa ajili ya matamasha na mechi za michezo, n.k. Aina hii maalum ya Tokeni ina uwezekano wa ajabu kwa hivyo inastahili Kiwango kinachofaa, ERC-721 ilikuja kutatua hilo!
+
+**ERC-721 ni nini?**
+
+ERC-721 inaleta kiwango cha NFT, kwa maneno mengine, aina hii ya Tokeni ni ya kipekee na inaweza kuwa na thamani tofauti kuliko Tokeni nyingine kutoka kwa Mkataba-erevu uleule, labda kutokana na umri wake, uhaba wake au hata kitu kingine kama mwonekano wake.
+Subiri, mwonekano?
+
+Ndiyo! NFT zote zina kigezo cha `uint256` kinachoitwa `tokenId`, kwa hivyo kwa Mkataba wowote wa ERC-721, jozi ya `anwani ya mkataba, uint256 tokenId` lazima iwe ya kipekee duniani kote. Kwa kusema hivyo, mfumo mtawanyo wa kimamlaka unaweza kuwa na "kigeuzi" kinachotumia `tokenId` kama ingizo na kutoa picha ya kitu kizuri, kama mazombi, silaha, ujuzi au paka wa ajabu!
+
+## Mahitaji ya awali {#prerequisites}
+
+- Hifadhi ya fedha (/developers/docs/accounts/)
+- [Mkataba erevu](/developers/docs/smart-contracts/)
+- [Viwango vya tokeni](/developers/docs/standards/tokens/)
+
+## Mwili {#body}
+
+ERC-721 (Ombi la Maoni la Ethereum 721), iliyopendekezwa na William Entriken, Dieter Shirley, Jacob Evans, Nastassia Sachs mnamo Januari 2018, ni Kiwango cha Tokeni isiyoweza kubadilishwa kinachotekeleza API ya tokeni ndani ya Mikataba-erevu.
+
+Hutoa utendaji kama vile kuhamisha tokeni kutoka akaunti moja hadi nyingine, kupata salio la sasa la tokeni la akaunti, kupata mmiliki wa tokeni maalum na pia jumla ya usambazaji wa tokeni inayopatikana kwenye mtandao.
+Kando na hizi, pia ina utendaji mwingine kama kuidhinisha kwamba kiasi cha tokeni kutoka kwa akaunti kinaweza kuhamishwa na akaunti ya wahusika wengine.
+
+Ikiwa Mkataba-erevu unatekeleza mbinu na matukio yafuatayo unaweza kuitwa Mkataba wa Tokeni isiyoweza kubadilishwa wa ERC-721 na, mara tu utakapowekwa, utakuwa na jukumu la kufuatilia tokeni zilizoundwa kwenye Ethereum.
+
+Kutoka [EIP-721](https://eips.ethereum.org/EIPS/eip-721):
+
+### Mbinu {#methods}
+
+```solidity
+ function balanceOf(address _owner) external view returns (uint256);
+ function ownerOf(uint256 _tokenId) external view returns (address);
+ function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external payable;
+ function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
+ function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
+ function approve(address _approved, uint256 _tokenId) external payable;
+ function setApprovalForAll(address _operator, bool _approved) external;
+ function getApproved(uint256 _tokenId) external view returns (address);
+ function isApprovedForAll(address _owner, address _operator) external view returns (bool);
+```
+
+### Matukio {#events}
+
+```solidity
+ event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
+ event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
+ event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
+```
+
+### Mifano {#web3py-example}
+
+Hebu tuone jinsi Kiwango kilivyo muhimu sana kurahisisha mambo kwetu kukagua Mkataba wowote wa Tokeni wa ERC-721 kwenye Ethereum.
+Tunahitaji tu Kiolesura cha Binary cha Programu ya Mkataba (ABI) ili kuunda kiolesura cha Tokeni yoyote ya ERC-721. Ama unaweza
+Tazama chini kutumia ABI rahisi, kuifanya mfano wa msuguano mdogo.
+
+#### Mfano wa Web3.py {#web3py-example}
+
+Kwanza, hakikisha umesakinisha maktaba ya Python ya [Web3.py](https://web3py.readthedocs.io/en/stable/quickstart.html#installation):
+
+```
+pip install web3
+```
+
+```python
+from web3 import Web3
+from web3._utils.events import get_event_data
+
+
+w3 = Web3(Web3.HTTPProvider("https://cloudflare-eth.com"))
+
+ck_token_addr = "0x06012c8cf97BEaD5deAe237070F9587f8E7A266d" # Mkataba wa CryptoKitties
+
+acc_address = "0xb1690C08E213a35Ed9bAb7B318DE14420FB57d8C" # Mnada wa Mauzo wa CryptoKitties
+
+# Hiki ni Kiolesura cha Binary cha Programu ya Mkataba (ABI) kilichorahisishwa cha Mkataba wa NFT wa ERC-721.
+# Kitaonyesha tu mbinu: balanceOf(address), name(), ownerOf(tokenId), symbol(), totalSupply()
+simplified_abi = [
+ {
+ 'inputs': [{'internalType': 'address', 'name': 'owner', 'type': 'address'}],
+ 'name': 'balanceOf',
+ 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
+ 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [],
+ 'name': 'name',
+ 'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [{'internalType': 'uint256', 'name': 'tokenId', 'type': 'uint256'}],
+ 'name': 'ownerOf',
+ 'outputs': [{'internalType': 'address', 'name': '', 'type': 'address'}],
+ 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [],
+ 'name': 'symbol',
+ 'outputs': [{'internalType': 'string', 'name': '', 'type': 'string'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [],
+ 'name': 'totalSupply',
+ 'outputs': [{'internalType': 'uint256', 'name': '', 'type': 'uint256'}],
+ 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+]
+
+ck_extra_abi = [
+ {
+ 'inputs': [],
+ 'name': 'pregnantKitties',
+ 'outputs': [{'name': '', 'type': 'uint256'}],
+ 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True
+ },
+ {
+ 'inputs': [{'name': '_kittyId', 'type': 'uint256'}],
+ 'name': 'isPregnant',
+ 'outputs': [{'name': '', 'type': 'bool'}],
+ 'payable': False, 'stateMutability': 'view', 'type': 'function', 'constant': True
+ }
+]
+
+ck_contract = w3.eth.contract(address=w3.to_checksum_address(ck_token_addr), abi=simplified_abi+ck_extra_abi)
+name = ck_contract.functions.name().call()
+symbol = ck_contract.functions.symbol().call()
+kitties_auctions = ck_contract.functions.balanceOf(acc_address).call()
+print(f"{name} [{symbol}] NFTs in Auctions: {kitties_auctions}")
+
+pregnant_kitties = ck_contract.functions.pregnantKitties().call()
+print(f"{name} [{symbol}] NFTs Pregnants: {pregnant_kitties}")
+
+# Kutumia ABI ya Tukio la Uhamisho kupata maelezo kuhusu Paka waliohamishwa.
+tx_event_abi = {
+ 'anonymous': False,
+ 'inputs': [
+ {'indexed': False, 'name': 'from', 'type': 'address'},
+ {'indexed': False, 'name': 'to', 'type': 'address'},
+ {'indexed': False, 'name': 'tokenId', 'type': 'uint256'}],
+ 'name': 'Transfer',
+ 'type': 'event'
+}
+
+# Tunahitaji saini ya tukio ili kuchuja kumbukumbu
+event_signature = w3.keccak(text="Transfer(address,address,uint256)").hex()
+
+logs = w3.eth.get_logs({
+ "fromBlock": w3.eth.block_number - 120,
+ "address": w3.to_checksum_address(ck_token_addr),
+ "topics": [event_signature]
+})
+
+# Kumbuka:
+# - Ongeza idadi ya bloku kutoka 120 ikiwa hakuna tukio la Uhamisho linalorejeshwa.
+# - Ikiwa haukupata tukio lolote la Uhamisho unaweza pia kujaribu kupata tokenId kwenye:
+# https://etherscan.io/address/0x06012c8cf97BEaD5deAe237070F9587f8E7A266d#events
+# Bofya ili kupanua kumbukumbu za tukio na kunakili hoja yake ya "tokenId"
+recent_tx = [get_event_data(w3.codec, tx_event_abi, log)["args"] for log in logs]
+
+if recent_tx:
+ kitty_id = recent_tx[0]['tokenId'] # Bandika "tokenId" hapa kutoka kwa kiungo hapo juu
+ is_pregnant = ck_contract.functions.isPregnant(kitty_id).call()
+ print(f"{name} [{symbol}] NFTs {kitty_id} is pregnant: {is_pregnant}")
+```
+
+Mkataba wa CryptoKitties una Matukio kadhaa ya kuvutia zaidi ya yale ya Kiwango.
+
+Hebu tuangalie mawili kati yao, `Pregnant` na `Birth`.
+
+```python
+# Kutumia ABI ya Matukio ya Pregnant na Birth kupata maelezo kuhusu Paka wapya.
+ck_extra_events_abi = [
+ {
+ 'anonymous': False,
+ 'inputs': [
+ {'indexed': False, 'name': 'owner', 'type': 'address'},
+ {'indexed': False, 'name': 'matronId', 'type': 'uint256'},
+ {'indexed': False, 'name': 'sireId', 'type': 'uint256'},
+ {'indexed': False, 'name': 'cooldownEndBlock', 'type': 'uint256'}],
+ 'name': 'Pregnant',
+ 'type': 'event'
+ },
+ {
+ 'anonymous': False,
+ 'inputs': [
+ {'indexed': False, 'name': 'owner', 'type': 'address'},
+ {'indexed': False, 'name': 'kittyId', 'type': 'uint256'},
+ {'indexed': False, 'name': 'matronId', 'type': 'uint256'},
+ {'indexed': False, 'name': 'sireId', 'type': 'uint256'},
+ {'indexed': False, 'name': 'genes', 'type': 'uint256'}],
+ 'name': 'Birth',
+ 'type': 'event'
+ }]
+
+# Tunahitaji saini ya tukio ili kuchuja kumbukumbu
+ck_event_signatures = [
+ w3.keccak(text="Pregnant(address,uint256,uint256,uint256)").hex(),
+ w3.keccak(text="Birth(address,uint256,uint256,uint256,uint256)").hex(),
+]
+
+# Hili ni Tukio la Pregnant:
+# - https://etherscan.io/tx/0xc97eb514a41004acc447ac9d0d6a27ea6da305ac8b877dff37e49db42e1f8cef#eventlog
+pregnant_logs = w3.eth.get_logs({
+ "fromBlock": w3.eth.block_number - 120,
+ "address": w3.to_checksum_address(ck_token_addr),
+ "topics": [ck_event_signatures[0]]
+})
+
+recent_pregnants = [get_event_data(w3.codec, ck_extra_events_abi[0], log)["args"] for log in pregnant_logs]
+
+# Hili ni Tukio la Birth:
+# - https://etherscan.io/tx/0x3978028e08a25bb4c44f7877eb3573b9644309c044bf087e335397f16356340a
+birth_logs = w3.eth.get_logs({
+ "fromBlock": w3.eth.block_number - 120,
+ "address": w3.to_checksum_address(ck_token_addr),
+ "topics": [ck_event_signatures[1]]
+})
+
+recent_births = [get_event_data(w3.codec, ck_extra_events_abi[1], log)["args"] for log in birth_logs]
+```
+
+## NFT maarufu {#popular-nfts}
+
+- [Kifuatiliaji cha NFT cha Etherscan](https://etherscan.io/nft-top-contracts) huorodhesha NFT maarufu kwenye Ethereum kwa ujazo wa uhamisho.
+- [CryptoKitties](https://www.cryptokitties.co/) ni mchezo unaohusu viumbe wanaoweza kuzalishwa, kukusanywa, na wa kupendeza sana tunaowaita CryptoKitties.
+- [Sorare](https://sorare.com/) ni mchezo wa kimataifa wa soka ya njozi ambapo unaweza kukusanya vitu vya toleo pungufu vya kukusanya, kusimamia timu zako na kushindana ili kujishindia zawadi.
+- [Huduma ya Majina ya Ethereum (ENS)](https://ens.domains/) hutoa njia salama na iliyogatuliwa ya kuweka anwani kwa rasilimali ndani na nje ya mnyororo wa bloku kwa kutumia majina rahisi, yanayosomeka na binadamu.
+- [POAP](https://poap.xyz) huwasilisha NFT za bure kwa watu wanaohudhuria matukio au kukamilisha vitendo maalum. POAP ni za bure kuunda na kusambaza.
+- [Unstoppable Domains](https://unstoppabledomains.com/) ni kampuni iliyoko San Francisco inayounda vikoa kwenye minyororo wa bloku. Vikoa vya mnyororo wa bloku hubadilisha anwani za sarafu ya kidigitali na majina yanayosomeka na binadamu na vinaweza kutumika kuwezesha tovuti zinazostahimili udhibiti.
+- [Gods Unchained Cards](https://godsunchained.com/) ni TCG kwenye mnyororo wa bloku wa Ethereum inayotumia NFT kuleta umiliki halisi kwa mali za ndani ya mchezo.
+- [Bored Ape Yacht Club](https://boredapeyachtclub.com) ni mkusanyiko wa NFT 10,000 za kipekee, ambazo, pamoja na kuwa kazi ya sanaa adimu inayoweza kuthibitishwa, hufanya kazi kama tokeni ya uanachama wa klabu, ikitoa marupurupu na manufaa kwa wanachama yanayoongezeka kadri muda unavyopita kutokana na juhudi za jumuiya.
+
+## Masomo zaidi {#further-reading}
+
+- [EIP-721: Kiwango cha Tokeni isiyoweza kubadilishwa cha ERC-721](https://eips.ethereum.org/EIPS/eip-721)
+- [OpenZeppelin - Hati za ERC-721](https://docs.openzeppelin.com/contracts/3.x/erc721)
+- [OpenZeppelin - Utekelezaji wa ERC-721](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC721/ERC721.sol)
+- [API ya NFT ya Alchemy](https://www.alchemy.com/docs/reference/nft-api-quickstart)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/erc-777/index.md b/public/content/translations/sw/developers/docs/standards/tokens/erc-777/index.md
new file mode 100644
index 00000000000..bbb88d4400f
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/erc-777/index.md
@@ -0,0 +1,45 @@
+---
+title: ERC-777 Ishara kiwango
+description: Kujifunza kuhusu ERC-777, kueneza badilishwa ishara kiwango na ndoano, ingawa ERC-20 ni kupendekeza kwa ajili ya usalama.
+lang: sw
+---
+
+## Onyo {#warning}
+
+**ERC-777 ni vigumu kutekeleza vizuri, kutokana na yake [usumbufu kwa aina mbalimbali za mashambulizi](https://github.com/OpenZeppelin/openzeppelin-contracts/issues/2620). Kushauriwa kutumia [ERC-20](/developers/docs/standards/tokens/erc-20/) badala yake.** Ukurasa huu kubaki kuwa hifadhi ya kihistoria.
+
+## Utangulizi? {#introduction}
+
+ERC-777 ni badilishwa ishara kiwango kueneza zipo [ERC-20](/developers/docs/standards/tokens/erc-20/) kiwango.
+
+## Mahitaji ya awali {#prerequisites}
+
+Ili kuelewa vizuri ukurasa huu, kupendekeza wewe kwanza kusoma kuhusu [ERC-20](/developers/docs/standards/tokens/erc-20/).
+
+## Ni uenezaji gani ERC-777 kupendekeza juu ya ERC-20? {#-erc-777-vs-erc-20}
+
+ERC-777 hutoa uenezaji yafuatayo juu ya ERC-20.
+
+### Vidokezo {#hooks}
+
+Vidokezo ni kazi ilivyoelezwa katika kanuni ya mkataba erevu. Vidokezo kupata kuitwa wakati ishara ni kutumwa au kupokea kwa njia ya mkataba. Hii kuruhusu mkataba erevu kuguswa kwa ishara kuingia au zinazotoka.
+
+Vidokezo ni rekodi na gunduliwa kutumia [ERC-1820](https://eips.ethereum.org/EIPS/eip-1820)kiwango.
+
+#### Kwa nini ndoano ni nzuri? {#why-are-hooks-great}
+
+1. Hooki huruhusu kutuma tokeni kwa mkataba na kuuarifu mkataba huo katika muamala mmoja, tofauti na [ERC-20](https://eips.ethereum.org/EIPS/eip-20), ambayo inahitaji simu mbili (`idhinisha`/`hamishaKutoka`) ili kufanikisha hili.
+2. Mikataba ambayo haijasajili hooki haiendani na ERC-777. Mkataba unaotuma utaghairi muamala wakati mkataba unaopokea haujasajili hooki. Hii inazuia uhamishaji wa bahati mbaya kwa mikataba-erevu isiyo ya ERC-777.
+3. Hooki zinaweza kukataa miamala.
+
+### Nukta desimali {#decimals}
+
+Kiwango hiki pia kinatatua mkanganyiko kuhusu `decimals` uliosababishwa katika ERC-20. Uwazi huu unaboresha uzoefu wa msanidi programu.
+
+### Upatanifu wa nyuma na ERC-20 {#backwards-compatibility-with-erc-20}
+
+Mikataba ya ERC-777 inaweza kuingiliana nayo kana kwamba ni mikataba ya ERC-20.
+
+## Masomo zaidi {#further-reading}
+
+[EIP-777: Kiwango cha Tokeni](https://eips.ethereum.org/EIPS/eip-777)
diff --git a/public/content/translations/sw/developers/docs/standards/tokens/index.md b/public/content/translations/sw/developers/docs/standards/tokens/index.md
new file mode 100644
index 00000000000..b89ec6c48fd
--- /dev/null
+++ b/public/content/translations/sw/developers/docs/standards/tokens/index.md
@@ -0,0 +1,41 @@
+---
+title: Ishara kiwango
+description: Kuchunguza Ethereum ishara viwango ikiwa ni pamoja na ERC-20, ERC-721, na ERC-1155 kwa ishara badilishwa na yasiyo ya badilishwa.
+lang: sw
+incomplete: true
+---
+
+## Utangulizi {#introduction}
+
+Viwango vingi vya maendeleo ya Ethereum kuzingatia kunganishi vya ishara. Viwango hivi husaidia kuhakikisha mikataba-erevu inasalia na uwezo wa kuunganishwa, kwa hivyo mradi mpya unapotoa tokeni, inasalia kuwa sambamba na exchange na programu zilizopo zilizogatuliwa.
+
+Viwango vya tokeni hufafanua jinsi tokeni hutenda na kuingiliana katika mfumo-ikolojia wote wa Ethereum. Hurahisisha wasanidi programu kujenga bila kugundua upya gurudumu, na kuhakikisha kuwa tokeni zinafanya kazi bila matatizo na mikoba, exchange, na mifumo ya DeFi. Iwe katika michezo, utawala, au matumizi mengine, viwango hivi hutoa uthabiti na kuifanya Ethereum iunganishwe zaidi.
+
+## Mahitaji ya awali {#prerequisites}
+
+- [Viwango vya usanidi vya Ethereum](/developers/docs/standards/)
+- [Mikataba-erevu](/developers/docs/smart-contracts/)
+
+## Viwango vya tokeni {#token-standards}
+
+Hapa ni baadhi ya viwango vya ishara maarufu zaidi juu ya Ethereum:
+
+- [ERC-20](/developers/docs/standards/tokens/erc-20/) - Kiolesura cha kawaida cha tokeni zinazoweza kubadilishwa (interchangeable), kama vile tokeni za kupiga kura, tokeni za kuweka hisa au sarafu pepe.
+
+### Viwango vya NFT {#nft-standards}
+
+- [ERC-721](/developers/docs/standards/tokens/erc-721/) - Kiolesura cha kawaida cha tokeni zisizoweza kubadilishwa, kama hati miliki ya mchoro au wimbo.
+- [ERC-1155](/developers/docs/standards/tokens/erc-1155/) - ERC-1155 huruhusu biashara zenye ufanisi zaidi na kuunganisha miamala – hivyo basi huokoa gharama. Hii ishara ya kiwango kuruhusu kwa ajili ya kujenga wote ishara ya huduma (kama $BNB ama $BAT) na hakuna badilishwa kama kriptopunks.
+
+Orodha kamili ya mapendekezo ya [ERC](https://eips.ethereum.org/erc).
+
+## Masomo zaidi {#further-reading}
+
+_Unajua rasilimali ya jamii iliyokusaidia?_ Hariri ukurasa huu na uiongeze!_
+
+## Mafunzo yanayohusiana {#related-tutorials}
+
+- [Orodha hakiki ya muunganisho wa tokeni](/developers/tutorials/token-integration-checklist/) _– Orodha ya mambo ya kuzingatia unapoingiliana na tokeni._
+- [Elewa mkataba-erevu wa tokeni ya ERC20](/developers/tutorials/understand-the-erc-20-token-smart-contract/) _– Utangulizi wa kupeleka mkataba-erevu wako wa kwanza kwenye testnet ya Ethereum._
+- [Uhamisho na uidhinishaji wa tokeni za ERC20 kutoka kwa mkataba-erevu wa Solidity](/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/) _– Jinsi ya kutumia mkataba-erevu kuingiliana na tokeni kwa kutumia lugha ya Solidity._
+- [Kutekeleza soko la ERC721 [mwongozo wa jinsi ya]](/developers/tutorials/how-to-implement-an-erc721-market/) _– Jinsi ya kuweka bidhaa zilizofanywa tokeni kwa ajili ya kuuza kwenye ubao wa matangazo uliogatuliwa._