From c639e7a9dab0fddc469d4766e9c25c8039a153c4 Mon Sep 17 00:00:00 2001
From: Joshua <62268199+minimalsm@users.noreply.github.com>
Date: Sat, 14 Feb 2026 00:12:35 +0000
Subject: [PATCH] i18n(te): translation import part 09 of 13 (23 files)

---
 .../index.md                                  |   91 +
 .../tutorials/stealth-addr/index.md           |  443 ++++
 .../index.md                                  |  314 +++
 .../token-integration-checklist/index.md      |   86 +
 .../index.md                                  |  320 +++
 .../index.md                                  |  183 ++
 .../uniswap-v2-annotated-code/index.md        | 1968 +++++++++++++++++
 .../tutorials/using-websockets/index.md       |  251 +++
 .../index.md                                  |  300 +++
 .../index.md                                  |  204 ++
 .../index.md                                  |  205 ++
 .../tutorials/yellow-paper-evm/index.md       |  278 +++
 public/content/translations/te/eips/index.md  |   78 +
 .../te/energy-consumption/index.md            |   86 +
 .../translations/te/eth/supply/index.md       |   80 +
 .../translations/te/ethereum-forks/index.md   |  663 ++++++
 .../translations/te/foundation/index.md       |   33 +
 .../content/translations/te/gaming/index.md   |   70 +
 .../content/translations/te/glossary/index.md |  505 +++++
 .../translations/te/governance/index.md       |  184 ++
 .../index.md                                  |   75 +
 .../te/guides/how-to-id-scam-tokens/index.md  |   94 +
 .../how-to-revoke-token-access/index.md       |   75 +
 23 files changed, 6586 insertions(+)
 create mode 100644 public/content/translations/te/developers/tutorials/smart-contract-security-guidelines/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/stealth-addr/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/token-integration-checklist/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/uniswap-v2-annotated-code/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/using-websockets/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/waffle-test-simple-smart-contract/index.md
 create mode 100644 public/content/translations/te/developers/tutorials/yellow-paper-evm/index.md
 create mode 100644 public/content/translations/te/eips/index.md
 create mode 100644 public/content/translations/te/energy-consumption/index.md
 create mode 100644 public/content/translations/te/eth/supply/index.md
 create mode 100644 public/content/translations/te/ethereum-forks/index.md
 create mode 100644 public/content/translations/te/foundation/index.md
 create mode 100644 public/content/translations/te/gaming/index.md
 create mode 100644 public/content/translations/te/glossary/index.md
 create mode 100644 public/content/translations/te/governance/index.md
 create mode 100644 public/content/translations/te/guides/how-to-create-an-ethereum-account/index.md
 create mode 100644 public/content/translations/te/guides/how-to-id-scam-tokens/index.md
 create mode 100644 public/content/translations/te/guides/how-to-revoke-token-access/index.md

diff --git a/public/content/translations/te/developers/tutorials/smart-contract-security-guidelines/index.md b/public/content/translations/te/developers/tutorials/smart-contract-security-guidelines/index.md
new file mode 100644
index 00000000000..8c308283546
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/smart-contract-security-guidelines/index.md
@@ -0,0 +1,91 @@
+---
+title: "స్మార్ట్ కాంట్రాక్ట్ భద్రతా మార్గదర్శకాలు"
+description: "మీ డాప్‌ని నిర్మించేటప్పుడు పరిగణించవలసిన భద్రతా మార్గదర్శకాల తనిఖీ జాబితా"
+author: "Trailofbits"
+tags: [ "దృఢత్వం", "స్మార్ట్ కాంట్రాక్టులు", "భద్రత" ]
+skill: intermediate
+lang: te
+published: 2020-09-06
+source: Building secure contracts
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/guidelines.md
+---
+
+మరింత సురక్షితమైన స్మార్ట్ కాంట్రాక్ట్లను నిర్మించడానికి ఈ ఉన్నత-స్థాయి సిఫార్సులను అనుసరించండి.
+
+## డిజైన్ మార్గదర్శకాలు {#design-guidelines}
+
+ఏ ఒక్క లైను కోడ్ రాయడానికి ముందు, కాంట్రాక్ట్ డిజైన్‌ను ముందుగానే చర్చించాలి.
+
+### డాక్యుమెంటేషన్ మరియు స్పెసిఫికేషన్లు {#documentation-and-specifications}
+
+డాక్యుమెంటేషన్‌ను వివిధ స్థాయిలలో వ్రాయవచ్చు మరియు కాంట్రాక్టులను అమలు చేస్తున్నప్పుడు నవీకరించాలి:
+
+- **సిస్టమ్ యొక్క సాదా ఆంగ్ల వివరణ**, కాంట్రాక్టులు ఏమి చేస్తాయో మరియు కోడ్‌బేస్‌పై ఏవైనా అంచనాలను వివరిస్తుంది.
+- **స్కీమా మరియు నిర్మాణ రేఖాచిత్రాలు**, కాంట్రాక్ట్ పరస్పర చర్యలు మరియు సిస్టమ్ యొక్క స్టేట్ మెషీన్‌తో సహా. [Slither ప్రింటర్లు](https://github.com/crytic/slither/wiki/Printer-documentation) ఈ స్కీమాలను రూపొందించడంలో సహాయపడతాయి.
+- **సమగ్రమైన కోడ్ డాక్యుమెంటేషన్**, Solidity కోసం [Natspec ఫార్మాట్](https://docs.soliditylang.org/en/develop/natspec-format.html) ను ఉపయోగించవచ్చు.
+
+### ఆన్‌చైన్ వర్సెస్ ఆఫ్‌చైన్ కంప్యూటేషన్ {#onchain-vs-offchain-computation}
+
+- **మీరు వీలైనంత ఎక్కువ కోడ్‌ను ఆఫ్‌చైన్‌లో ఉంచండి.** ఆన్‌చైన్ లేయర్‌ను చిన్నదిగా ఉంచండి. ఆన్‌చైన్‌లో ధృవీకరణ సరళంగా ఉండే విధంగా ఆఫ్‌చైన్ కోడ్‌తో డేటాను ముందుగా ప్రాసెస్ చేయండి. మీకు క్రమబద్ధమైన జాబితా అవసరమా? జాబితాను ఆఫ్‌చైన్‌లో క్రమబద్ధీకరించండి, తర్వాత దాని క్రమాన్ని ఆన్‌చైన్‌లో మాత్రమే తనిఖీ చేయండి.
+
+### అప్‌గ్రేడబిలిటీ {#upgradeability}
+
+మేము మా [బ్లాగ్‌పోస్ట్‌లో](https://blog.trailofbits.com/2018/09/05/contract-upgrade-anti-patterns/) విభిన్న అప్‌గ్రేడబిలిటీ పరిష్కారాలను చర్చించాము. ఏదైనా కోడ్ రాయడానికి ముందు అప్‌గ్రేడబిలిటీకి మద్దతు ఇవ్వాలా వద్దా అనే దానిపై ఉద్దేశపూర్వక ఎంపిక చేసుకోండి. ఈ నిర్ణయం మీరు మీ కోడ్‌ను ఎలా నిర్మిస్తారనే దానిని ప్రభావితం చేస్తుంది. సాధారణంగా, మేము సిఫార్సు చేస్తున్నాము:
+
+- **అప్‌గ్రేడబిలిటీ కంటే [కాంట్రాక్ట్ మైగ్రేషన్‌కు](https://blog.trailofbits.com/2018/10/29/how-contract-migration-works/) ప్రాధాన్యత ఇవ్వడం.** మైగ్రేషన్ సిస్టమ్‌లు వాటి ప్రతికూలతలు లేకుండా, అప్‌గ్రేడబుల్ వాటికి ఉన్న అనేక ప్రయోజనాలను కలిగి ఉంటాయి.
+- **delegatecallproxy దానిపై డేటా సెపరేషన్ ప్యాట్రన్‌ను ఉపయోగించడం.** మీ ప్రాజెక్ట్‌కు స్పష్టమైన అబ్స్ట్రాక్షన్ సెపరేషన్ ఉన్నట్లయితే, డేటా సెపరేషన్‌ని ఉపయోగించి అప్‌గ్రేడ్ చేయడానికి కొన్ని సర్దుబాట్లు మాత్రమే అవసరం. delegatecallproxyకి EVM నైపుణ్యం అవసరం మరియు ఇది చాలా దోషపూరితమైనది.
+- **విస్తరణకు ముందు మైగ్రేషన్/అప్‌గ్రేడ్ విధానాన్ని డాక్యుమెంట్ చేయండి.** ఎలాంటి మార్గదర్శకాలు లేకుండా ఒత్తిడిలో మీరు స్పందించవలసి వస్తే, మీరు తప్పులు చేస్తారు. అనుసరించాల్సిన విధానాన్ని ముందుగానే వ్రాయండి. అందులో ఇవి ఉండాలి:
+  - కొత్త కాంట్రాక్టులను ప్రారంభించే కాల్స్
+  - కీలు ఎక్కడ నిల్వ చేయబడ్డాయి మరియు వాటిని ఎలా యాక్సెస్ చేయాలి
+  - విస్తరణను ఎలా తనిఖీ చేయాలి! పోస్ట్-డిప్లాయ్‌మెంట్ స్క్రిప్ట్‌ను డెవలప్ చేసి, పరీక్షించండి.
+
+## అమలు మార్గదర్శకాలు {#implementation-guidelines}
+
+**సరళత కోసం ప్రయత్నించండి.** మీ ప్రయోజనానికి సరిపోయే సరళమైన పరిష్కారాన్ని ఎల్లప్పుడూ ఉపయోగించండి. మీ బృందంలోని ఏ సభ్యుడైనా మీ పరిష్కారాన్ని అర్థం చేసుకోగలగాలి.
+
+### ఫంక్షన్ కంపోజిషన్ {#function-composition}
+
+మీ కోడ్‌బేస్ యొక్క నిర్మాణం మీ కోడ్‌ను సమీక్షించడానికి సులభతరం చేయాలి. దాని ఖచ్చితత్వం గురించి వాదించే సామర్థ్యాన్ని తగ్గించే నిర్మాణ ఎంపికలను నివారించండి.
+
+- **మీ సిస్టమ్ యొక్క లాజిక్‌ను విభజించండి**, బహుళ కాంట్రాక్టుల ద్వారా లేదా సారూప్యమైన ఫంక్షన్‌లను (ఉదాహరణకు, ప్రమాణీకరణ, అంకగణితం, ...) సమూహపరచడం ద్వారా.
+- **స్పష్టమైన ప్రయోజనంతో చిన్న ఫంక్షన్‌లను వ్రాయండి.** ఇది సులభమైన సమీక్షను సులభతరం చేస్తుంది మరియు వ్యక్తిగత భాగాలను పరీక్షించడానికి అనుమతిస్తుంది.
+
+### ఇన్హెరిటెన్స్ {#inheritance}
+
+- **వారసత్వాన్ని నిర్వహించదగినదిగా ఉంచండి.** తర్కాన్ని విభజించడానికి వారసత్వాన్ని ఉపయోగించాలి, అయితే, మీ ప్రాజెక్ట్ వారసత్వ వృక్షం యొక్క లోతు మరియు వెడల్పును తగ్గించాలని లక్ష్యంగా పెట్టుకోవాలి.
+- **కాంట్రాక్టుల సోపానక్రమాన్ని తనిఖీ చేయడానికి Slither యొక్క [ఇన్హెరిటెన్స్ ప్రింటర్‌ను](https://github.com/crytic/slither/wiki/Printer-documentation#inheritance-graph) ఉపయోగించండి.** ఇన్హెరిటెన్స్ ప్రింటర్ సోపానక్రమం యొక్క పరిమాణాన్ని సమీక్షించడంలో మీకు సహాయం చేస్తుంది.
+
+### ఈవెంట్‌లు {#events}
+
+- **అన్ని కీలకమైన కార్యకలాపాలను లాగ్ చేయండి.** ఈవెంట్‌లు అభివృద్ధి సమయంలో కాంట్రాక్ట్‌ను డీబగ్ చేయడానికి మరియు విస్తరణ తర్వాత దానిని పర్యవేక్షించడానికి సహాయపడతాయి.
+
+### తెలిసిన ఆపదలను నివారించండి {#avoid-known-pitfalls}
+
+- **అత్యంత సాధారణ భద్రతా సమస్యల గురించి తెలుసుకోండి.** [Ethernaut CTF](https://ethernaut.openzeppelin.com/), [Capture the Ether](https://capturetheether.com/), లేదా [Not so smart contracts](https://github.com/crytic/not-so-smart-contracts/) వంటి సాధారణ సమస్యల గురించి తెలుసుకోవడానికి అనేక ఆన్‌లైన్ వనరులు ఉన్నాయి.
+- **[Solidity డాక్యుమెంటేషన్‌లోని](https://docs.soliditylang.org/en/latest/) హెచ్చరికల విభాగాల గురించి తెలుసుకోండి.** హెచ్చరికల విభాగాలు భాష యొక్క స్పష్టంగా కనిపించని ప్రవర్తన గురించి మీకు తెలియజేస్తాయి.
+
+### డిపెండెన్సీలు {#dependencies}
+
+- **బాగా పరీక్షించబడిన లైబ్రరీలను ఉపయోగించండి.** బాగా పరీక్షించబడిన లైబ్రరీల నుండి కోడ్‌ను దిగుమతి చేసుకోవడం వలన మీరు బగ్గీ కోడ్‌ను వ్రాసే సంభావ్యతను తగ్గిస్తుంది. మీరు ERC20 కాంట్రాక్ట్‌ను వ్రాయాలనుకుంటే, [OpenZeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20) ని ఉపయోగించండి.
+- **డిపెండెన్సీ మేనేజర్‌ను ఉపయోగించండి; కోడ్‌ను కాపీ-పేస్ట్ చేయడాన్ని నివారించండి.** మీరు బాహ్య సోర్స్‌పై ఆధారపడి ఉంటే, మీరు దానిని అసలు సోర్స్‌తో అప్‌డేట్‌గా ఉంచాలి.
+
+### పరీక్ష మరియు ధృవీకరణ {#testing-and-verification}
+
+- **సమగ్రమైన యూనిట్-టెస్టులు వ్రాయండి.** అధిక-నాణ్యత సాఫ్ట్‌వేర్‌ను రూపొందించడానికి విస్తృతమైన టెస్ట్ సూట్ చాలా ముఖ్యం.
+- **[Slither](https://github.com/crytic/slither), [Echidna](https://github.com/crytic/echidna) మరియు [Manticore](https://github.com/trailofbits/manticore) కస్టమ్ చెక్స్ మరియు ప్రాపర్టీలను వ్రాయండి.** ఆటోమేటెడ్ టూల్స్ మీ కాంట్రాక్ట్ సురక్షితంగా ఉందని నిర్ధారించడంలో సహాయపడతాయి. సమర్థవంతమైన తనిఖీలు మరియు లక్షణాలను ఎలా వ్రాయాలో తెలుసుకోవడానికి ఈ గైడ్‌లోని మిగిలిన వాటిని సమీక్షించండి.
+- **[crytic.io](https://crytic.io/)ని ఉపయోగించండి.** Crytic GitHubతో కలిసిపోతుంది, ప్రైవేట్ Slither డిటెక్టర్లకు యాక్సెస్ అందిస్తుంది మరియు Echidna నుండి కస్టమ్ ప్రాపర్టీ తనిఖీలను నడుపుతుంది.
+
+### సాలిడిటీ {#solidity}
+
+- **0.4 మరియు 0.6 కంటే Solidity 0.5కి ప్రాధాన్యత ఇవ్వండి.** మా అభిప్రాయం ప్రకారం, Solidity 0.5 మరింత సురక్షితమైనది మరియు 0.4 కంటే మెరుగైన అంతర్నిర్మిత పద్ధతులను కలిగి ఉంది. Solidity 0.6 ఉత్పత్తికి చాలా అస్థిరంగా ఉందని నిరూపించబడింది మరియు పరిపక్వం చెందడానికి సమయం కావాలి.
+- **కంపైల్ చేయడానికి స్థిరమైన విడుదలను ఉపయోగించండి; హెచ్చరికల కోసం తాజా విడుదలను ఉపయోగించండి.** తాజా కంపైలర్ వెర్షన్‌తో మీ కోడ్‌లో నివేదించబడిన సమస్యలు ఏవీ లేవని తనిఖీ చేయండి. అయినప్పటికీ, Solidity వేగవంతమైన విడుదల చక్రాన్ని కలిగి ఉంది మరియు కంపైలర్ బగ్‌ల చరిత్రను కలిగి ఉంది, కాబట్టి మేము విస్తరణ కోసం తాజా వెర్షన్‌ను సిఫార్సు చేయము (Slither's [solc వెర్షన్ సిఫార్సును](https://github.com/crytic/slither/wiki/Detector-Documentation#recommendation-33) చూడండి).
+- **ఇన్‌లైన్ అసెంబ్లీని ఉపయోగించవద్దు.** అసెంబ్లీకి EVM నైపుణ్యం అవసరం. మీరు యెల్లో పేపర్‌పై _పట్టు_ సాధించకపోతే EVM కోడ్ రాయవద్దు.
+
+## విస్తరణ మార్గదర్శకాలు {#deployment-guidelines}
+
+కాంట్రాక్ట్ అభివృద్ధి చేయబడి, విస్తరించబడిన తర్వాత:
+
+- **మీ కాంట్రాక్టులను పర్యవేక్షించండి.** లాగ్‌లను గమనిస్తూ ఉండండి మరియు కాంట్రాక్ట్ లేదా వాలెట్ రాజీపడినప్పుడు ప్రతిస్పందించడానికి సిద్ధంగా ఉండండి.
+- **[blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts)కి మీ సంప్రదింపు సమాచారాన్ని జోడించండి.** భద్రతా లోపం కనుగొనబడితే మూడవ పక్షాలు మిమ్మల్ని సంప్రదించడానికి ఈ జాబితా సహాయపడుతుంది.
+- **విశేష వినియోగదారుల వాలెట్‌లను భద్రపరచండి.** మీరు హార్డ్‌వేర్ వాలెట్లలో కీలను నిల్వ చేస్తే మా [ఉత్తమ పద్ధతులను](https://blog.trailofbits.com/2018/11/27/10-rules-for-the-secure-use-of-cryptocurrency-hardware-wallets/) అనుసరించండి.
+- **సంఘటన ప్రతిస్పందన ప్రణాళికను కలిగి ఉండండి.** మీ స్మార్ట్ కాంట్రాక్టులు రాజీపడవచ్చని పరిగణించండి. మీ కాంట్రాక్టులు బగ్‌లు లేకుండా ఉన్నప్పటికీ, దాడి చేసేవాడు కాంట్రాక్ట్ యజమాని కీలను నియంత్రణలోకి తీసుకోవచ్చు.
diff --git a/public/content/translations/te/developers/tutorials/stealth-addr/index.md b/public/content/translations/te/developers/tutorials/stealth-addr/index.md
new file mode 100644
index 00000000000..0e406c8c17e
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/stealth-addr/index.md
@@ -0,0 +1,443 @@
+---
+title: "స్టెల్త్ చిరునామాలను ఉపయోగించడం"
+description: "స్టెల్త్ చిరునామాలు వినియోగదారులను అనామకంగా ఆస్తులను బదిలీ చేయడానికి అనుమతిస్తాయి. ఈ కథనాన్ని చదివిన తర్వాత, మీరు వీటిని చేయగలరు: స్టెల్త్ చిరునామాలు అంటే ఏమిటి మరియు అవి ఎలా పనిచేస్తాయో వివరించడం, అనామకతను కాపాడే విధంగా స్టెల్త్ చిరునామాలను ఎలా ఉపయోగించాలో అర్థం చేసుకోవడం, మరియు స్టెల్త్ చిరునామాలను ఉపయోగించే వెబ్-ఆధారిత అప్లికేషన్‌ను వ్రాయడం."
+author: Ori Pomerantz
+tags:
+  [
+    "స్టెల్త్ చిరునామా",
+    "గోప్యత",
+    "క్రిప్టోగ్రఫీ",
+    "రస్ట్",
+    "wasm"
+  ]
+skill: intermediate
+published: 2025-11-30
+lang: te
+sidebarDepth: 3
+---
+
+మీరు బిల్. మేము వివరించని కొన్ని కారణాల వల్ల, మీరు "అలీస్ ఫర్ క్వీన్ ఆఫ్ ది వరల్డ్" ప్రచారానికి విరాళం ఇవ్వాలనుకుంటున్నారు మరియు మీరు విరాళం ఇచ్చారని అలీస్‌కు తెలియజేయాలనుకుంటున్నారు, తద్వారా ఆమె గెలిస్తే మీకు బహుమతి ఇస్తుంది. దురదృష్టవశాత్తు, ఆమె విజయం హామీ ఇవ్వబడదు. పోటీగా ఒక ప్రచారం ఉంది, "కరోల్ ఫర్ ఎంప్రెస్ ఆఫ్ ది సోలార్ సిస్టం". ఒకవేళ కరోల్ గెలిచి, మీరు అలీస్‌కు విరాళం ఇచ్చారని ఆమెకు తెలిస్తే, మీరు చిక్కుల్లో పడతారు. కాబట్టి మీరు మీ ఖాతా నుండి అలీస్ ఖాతాకు 200 ETH బదిలీ చేయలేరు.
+
+[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564)కి పరిష్కారం ఉంది. అనామక బదిలీల కోసం [స్టెల్త్ చిరునామాలను](https://nerolation.github.io/stealth-utils) ఎలా ఉపయోగించాలో ఈ ERC వివరిస్తుంది.
+
+**హెచ్చరిక**: మాకు తెలిసినంతవరకు, స్టెల్త్ చిరునామాల వెనుక ఉన్న క్రిప్టోగ్రఫీ సురక్షితమైనది. అయితే, సైడ్-ఛానల్ దాడులకు అవకాశం ఉంది. ఈ ప్రమాదాన్ని తగ్గించడానికి మీరు ఏమి చేయగలరో [క్రింద](#go-wrong) మీరు చూస్తారు.
+
+## స్టెల్త్ చిరునామాలు ఎలా పనిచేస్తాయి {#how}
+
+ఈ వ్యాసం రెండు విధాలుగా స్టెల్త్ చిరునామాలను వివరించడానికి ప్రయత్నిస్తుంది. మొదటిది [వాటిని ఎలా ఉపయోగించాలి](#how-use). ఈ భాగం వ్యాసంలోని మిగిలిన భాగాన్ని అర్థం చేసుకోవడానికి సరిపోతుంది. ఆ తర్వాత, దాని వెనుక ఉన్న గణితం యొక్క [వివరణ](#how-math) ఉంది. మీకు క్రిప్టోగ్రఫీపై ఆసక్తి ఉంటే, ఈ భాగాన్ని కూడా చదవండి.
+
+### సాధారణ వెర్షన్ (స్టెల్త్ చిరునామాలను ఎలా ఉపయోగించాలి) {#how-use}
+
+అలీస్ రెండు ప్రైవేట్ కీలను సృష్టిస్తుంది మరియు దానికి సంబంధించిన పబ్లిక్ కీలను ప్రచురిస్తుంది (వీటిని ఒకే డబుల్-లెంగ్త్ మెటా-చిరునామాలో కలపవచ్చు). బిల్ కూడా ఒక ప్రైవేట్ కీని సృష్టించి, దానికి సంబంధించిన పబ్లిక్ కీని ప్రచురిస్తాడు.
+
+ఒకరి పబ్లిక్ కీని మరియు మరొకరి ప్రైవేట్ కీని ఉపయోగించి, మీరు అలీస్ మరియు బిల్‌కు మాత్రమే తెలిసిన భాగస్వామ్య రహస్యాన్ని పొందవచ్చు (దీనిని కేవలం పబ్లిక్ కీల నుండి మాత్రమే పొందలేరు). ఈ భాగస్వామ్య రహస్యాన్ని ఉపయోగించి, బిల్ స్టెల్త్ చిరునామాను పొందుతాడు మరియు దానికి ఆస్తులను పంపగలడు.
+
+అలీస్ కూడా భాగస్వామ్య రహస్యం నుండి చిరునామాను పొందుతుంది, కానీ ఆమె ప్రచురించిన పబ్లిక్ కీలకు సంబంధించిన ప్రైవేట్ కీలు ఆమెకు తెలుసు కాబట్టి, ఆ చిరునామా నుండి విత్‌డ్రా చేయడానికి వీలు కల్పించే ప్రైవేట్ కీని కూడా ఆమె పొందగలదు.
+
+### గణితం (స్టెల్త్ చిరునామాలు ఇలా ఎందుకు పని చేస్తాయి) {#how-math}
+
+ప్రామాణిక స్టెల్త్ చిరునామాలు [ఎలిప్టిక్-కర్వ్ క్రిప్టోగ్రఫీ (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor)ని ఉపయోగించి తక్కువ కీ బిట్‌లతో మెరుగైన పనితీరును పొందుతాయి, అదే సమయంలో భద్రతా స్థాయిని అలాగే ఉంచుతాయి. కానీ చాలా వరకు మనం దానిని పట్టించుకోకుండా, సాధారణ అంకగణితాన్ని ఉపయోగిస్తున్నామని నటించవచ్చు.
+
+అందరికీ తెలిసిన ఒక సంఖ్య ఉంది, _G_. మీరు _G_తో గుణించవచ్చు. కానీ ECC స్వభావం కారణంగా, _G_తో భాగించడం ఆచరణాత్మకంగా అసాధ్యం. సాధారణంగా ఇతీరియములో పబ్లిక్ కీ క్రిప్టోగ్రఫీ పనిచేసే విధానం ఏమిటంటే, మీరు ఒక ప్రైవేట్ కీ, \*P<sub>priv</sub>\*ని ఉపయోగించి లావాదేవీలపై సంతకం చేయవచ్చు, అవి తర్వాత ఒక పబ్లిక్ కీ, _P<sub>pub</sub> = GP<sub>priv</sub>_ ద్వారా ధృవీకరించబడతాయి.
+
+అలీస్ రెండు ప్రైవేట్ కీలను సృష్టిస్తుంది, _K<sub>priv</sub>_ మరియు _V<sub>priv</sub>_. _K<sub>priv</sub>_ స్టెల్త్ చిరునామా నుండి డబ్బు ఖర్చు చేయడానికి ఉపయోగించబడుతుంది, మరియు _V<sub>priv</sub>_ అలీస్‌కు చెందిన చిరునామాలను వీక్షించడానికి ఉపయోగించబడుతుంది. ఆ తర్వాత అలీస్ పబ్లిక్ కీలను ప్రచురిస్తుంది: _K<sub>pub</sub> = GK<sub>priv</sub>_ మరియు _V<sub>pub</sub> = GV<sub>priv</sub>_
+
+బిల్ మూడవ ప్రైవేట్ కీ, \*R<sub>priv</sub>\*ని సృష్టిస్తాడు మరియు \*R<sub>pub</sub> = GR<sub>priv</sub>\*ని ఒక కేంద్ర రిజిస్ట్రీకి ప్రచురిస్తాడు (బిల్ దానిని అలీస్‌కు కూడా పంపించి ఉండవచ్చు, కానీ కరోల్ వింటున్నదని మేము ఊహించుకుంటాము).
+
+బిల్ \*R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>\*ను లెక్కిస్తాడు, ఇది అలీస్‌కు కూడా తెలుస్తుందని అతను ఆశిస్తాడు (క్రింద వివరించబడింది). ఈ విలువను _S_, భాగస్వామ్య రహస్యం అని పిలుస్తారు. ఇది బిల్‌కు ఒక పబ్లిక్ కీ, \*P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)\*ను ఇస్తుంది. ఈ పబ్లిక్ కీ నుండి, అతను ఒక చిరునామాను లెక్కించగలడు మరియు అతనికి కావలసిన వనరులను దానికి పంపగలడు. భవిష్యత్తులో, ఒకవేళ అలీస్ గెలిస్తే, ఆ వనరులు తన నుండే వచ్చాయని నిరూపించడానికి బిల్ ఆమెకు \*R<sub>priv</sub>\*ను చెప్పగలడు.
+
+అలీస్ \*R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>\*ను లెక్కిస్తుంది. ఇది ఆమెకు అదే భాగస్వామ్య రహస్యం, _S_ని ఇస్తుంది. ఆమెకు ప్రైవేట్ కీ, _K<sub>priv</sub>_ తెలుసు కాబట్టి, ఆమె \*P<sub>priv</sub> = K<sub>priv</sub>+hash(S)\*ను లెక్కించగలదు. ఈ కీ ఆమెకు _P<sub>pub</sub> = GP<sub>priv</sub> = GK<sub>priv</sub>+G\*hash(S) = K<sub>pub</sub>+G\*hash(S)_ నుండి వచ్చే చిరునామాలో ఉన్న ఆస్తులను యాక్సెస్ చేయడానికి అనుమతిస్తుంది.
+
+అలీస్ డేవ్ ప్రపంచ ఆధిపత్య ప్రచార సేవలకు సబ్‌కాంట్రాక్ట్ ఇవ్వడానికి వీలుగా మేము ఒక ప్రత్యేక వీక్షణ కీని కలిగి ఉన్నాము. అలీస్ పబ్లిక్ చిరునామాలను డేవ్‌కు తెలియజేయడానికి మరియు మరింత డబ్బు అందుబాటులోకి వచ్చినప్పుడు తనకు తెలియజేయడానికి సిద్ధంగా ఉంది, కానీ అతను తన ప్రచార డబ్బును ఖర్చు చేయకూడదని ఆమె కోరుకుంటుంది.
+
+వీక్షించడం మరియు ఖర్చు చేయడం వేర్వేరు కీలను ఉపయోగిస్తాయి కాబట్టి, అలీస్ డేవ్‌కు _V<sub>priv</sub>_ ఇవ్వగలదు. అప్పుడు డేవ్ \*S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>\*ను లెక్కించగలడు మరియు ఆ విధంగా పబ్లిక్ కీలను (_P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)_) పొందగలడు. కానీ _K<sub>priv</sub>_ లేకుండా డేవ్ ప్రైవేట్ కీని పొందలేడు.
+
+సారాంశంలో, ఇవి వివిధ పాల్గొనేవారికి తెలిసిన విలువలు.
+
+| అలీస్                                                                     | ప్రచురించబడింది   | బిల్                                                                      | డేవ్                                                                        |                                                  |
+| ------------------------------------------------------------------------- | ----------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------------------------------------------------ |
+| G                                                                         | G                 | G                                                                         | G                                                                           |                                                  |
+| _K<sub>priv</sub>_                                                        | —                 | —                                                                         | —                                                                           |                                                  |
+| _V<sub>priv</sub>_                                                        | —                 | —                                                                         | _V<sub>priv</sub>_                                                          |                                                  |
+| _K<sub>pub</sub> = GK<sub>priv</sub>_                                     | _K<sub>pub</sub>_ | _K<sub>pub</sub>_                                                         | _K<sub>pub</sub>_                                                           |                                                  |
+| _V<sub>pub</sub> = GV<sub>priv</sub>_                                     | _V<sub>pub</sub>_ | _V<sub>pub</sub>_                                                         | _V<sub>pub</sub>_                                                           |                                                  |
+| —                                                                         | —                 | _R<sub>priv</sub>_                                                        | —                                                                           |                                                  |
+| _R<sub>pub</sub>_                                                         | _R<sub>pub</sub>_ | _R<sub>pub</sub> = GR<sub>priv</sub>_                                     | _R<sub>pub</sub>_                                                           |                                                  |
+| _S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ | —                 | _S = R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>_ | _S = _R<sub>pub</sub>V<sub>priv</sub>_ = GR<sub>priv</sub>V<sub>priv</sub>_ |                                                  |
+| _P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)_         | —                 | _P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)_         | _P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)_           |                                                  |
+| _చిరునామా=f(P<sub>pub</sub>)_                          | —                 | _చిరునామా=f(P<sub>pub</sub>)_                          | _చిరునామా=f(P<sub>pub</sub>)_                            | _చిరునామా=f(P<sub>pub</sub>)_ |
+| _P<sub>priv</sub> = K<sub>priv</sub>+hash(S)_          | —                 | —                                                                         | —                                                                           |                                                  |
+
+## స్టెల్త్ చిరునామాలు తప్పుగా వెళ్ళినప్పుడు {#go-wrong}
+
+_బ్లాక్ చైనులో రహస్యాలు ఉండవు_. స్టెల్త్ చిరునామాలు మీకు గోప్యతను అందించగలిగినప్పటికీ, ఆ గోప్యత ట్రాఫిక్ విశ్లేషణకు లోబడి ఉంటుంది. ఒక చిన్న ఉదాహరణ చెప్పాలంటే, బిల్ ఒక చిరునామాకు నిధులు సమకూర్చి, వెంటనే _R<sub>pub</sub>_ విలువను ప్రచురించడానికి ఒక లావాదేవీని పంపుతాడని ఊహించుకోండి. అలీస్ యొక్క _V<sub>priv</sub>_ లేకుండా, ఇది ఒక స్టెల్త్ చిరునామా అని మనం ఖచ్చితంగా చెప్పలేము, కానీ ఆ విధంగా పందెం వేయవచ్చు. ఆ తర్వాత, ఆ చిరునామా నుండి మొత్తం ETHని అలీస్ ప్రచార నిధి చిరునామాకు బదిలీ చేసే మరో లావాదేవీని మనం చూస్తాము. మనం దానిని నిరూపించలేకపోవచ్చు, కానీ బిల్ అలీస్ ప్రచారానికి విరాళం ఇచ్చి ఉండవచ్చు. కరోల్ ఖచ్చితంగా అలాగే అనుకుంటుంది.
+
+బిల్ _R<sub>pub</sub>_ ప్రచురణను స్టెల్త్ చిరునామాకు నిధులు సమకూర్చడం నుండి వేరు చేయడం సులభం (వివిధ సమయాల్లో, వివిధ చిరునామాల నుండి వాటిని చేయండి). అయితే, అది సరిపోదు. కరోల్ వెతికే నమూనా ఏమిటంటే, బిల్ ఒక చిరునామాకు నిధులు సమకూర్చడం, ఆ తర్వాత అలీస్ ప్రచార నిధి దాని నుండి విత్‌డ్రా చేసుకోవడం.
+
+ఒక పరిష్కారం ఏమిటంటే, అలీస్ ప్రచారం డబ్బును నేరుగా విత్‌డ్రా చేసుకోకుండా, దానిని మూడవ పక్షానికి చెల్లించడానికి ఉపయోగించడం. ఒకవేళ అలీస్ ప్రచారం 10 ETHని డేవ్ ప్రపంచ ఆధిపత్య ప్రచార సేవలకు పంపితే, బిల్ డేవ్ కస్టమర్లలో ఒకరికి విరాళం ఇచ్చాడని కరోల్‌కు మాత్రమే తెలుస్తుంది. డేవ్‌కు తగినంత కస్టమర్లు ఉంటే, బిల్ తనతో పోటీపడే అలీస్‌కు విరాళం ఇచ్చాడా, లేదా కరోల్ పట్టించుకోని ఆడం, ఆల్బర్ట్, లేదా అబిగైల్‌కు ఇచ్చాడా అని కరోల్ తెలుసుకోలేదు. అలీస్ చెల్లింపుతో ఒక హాష్ విలువను చేర్చవచ్చు, ఆ తర్వాత డేవ్‌కు ప్రిఇమేజ్ అందించవచ్చు, అది తన విరాళం అని నిరూపించడానికి. ప్రత్యామ్నాయంగా, పైన పేర్కొన్నట్లుగా, అలీస్ డేవ్‌కు తన \*V<sub>priv</sub>\*ని ఇస్తే, ఆ చెల్లింపు ఎవరి నుండి వచ్చిందో అతనికి ఇప్పటికే తెలుసు.
+
+ఈ పరిష్కారంతో ప్రధాన సమస్య ఏమిటంటే, ఆ రహస్యం బిల్‌కు ప్రయోజనం చేకూర్చినప్పుడు అలీస్ దాని గురించి పట్టించుకోవాలి. బిల్ స్నేహితుడు బాబ్ కూడా తనకు విరాళం ఇస్తాడని అలీస్ తన ప్రతిష్టను కాపాడుకోవాలనుకోవచ్చు. కానీ ఆమె బిల్‌ను బయటపెట్టడానికి కూడా వెనుకాడకపోవచ్చు, ఎందుకంటే అప్పుడు అతను కరోల్ గెలిస్తే ఏమి జరుగుతుందో అని భయపడతాడు. బిల్ చివరికి అలీస్‌కు మరింత మద్దతు అందించవచ్చు.
+
+### బహుళ స్టెల్త్ లేయర్‌లను ఉపయోగించడం {#multi-layer}
+
+బిల్ గోప్యతను కాపాడటానికి అలీస్‌పై ఆధారపడటానికి బదులుగా, బిల్ దానిని స్వయంగా చేయగలడు. అతను కల్పిత వ్యక్తులు, బాబ్ మరియు బెల్లా కోసం బహుళ మెటా-చిరునామాలను సృష్టించగలడు. బిల్ అప్పుడు బాబ్‌కు ETH పంపుతాడు, మరియు "బాబ్" (వాస్తవానికి బిల్) దానిని బెల్లాకు పంపుతాడు. "బెల్లా" (కూడా బిల్) దానిని అలీస్‌కు పంపుతుంది.
+
+కరోల్ ఇప్పటికీ ట్రాఫిక్ విశ్లేషణ చేసి బిల్-టు-బాబ్-టు-బెల్లా-టు-అలీస్ పైప్‌లైన్‌ను చూడగలదు. అయితే, "బాబ్" మరియు "బెల్లా" కూడా ఇతర ప్రయోజనాల కోసం ETHని ఉపయోగిస్తే, బిల్ అలీస్‌కు ఏమీ బదిలీ చేసినట్లు కనిపించదు, అలీస్ వెంటనే స్టెల్త్ చిరునామా నుండి తన తెలిసిన ప్రచార చిరునామాకు విత్‌డ్రా చేసుకున్నప్పటికీ.
+
+## స్టెల్త్-చిరునామా అప్లికేషన్‌ను వ్రాయడం {#write-app}
+
+ఈ వ్యాసం [GitHubలో అందుబాటులో ఉన్న](https://github.com/qbzzt/251022-stealth-addresses.git) ఒక స్టెల్త్-చిరునామా అప్లికేషన్‌ను వివరిస్తుంది.
+
+### ఉపకరణాలు {#tools}
+
+మనం ఉపయోగించగల [ఒక టైప్‌స్క్రిప్ట్ స్టెల్త్ చిరునామా లైబ్రరీ](https://github.com/ScopeLift/stealth-address-sdk) ఉంది. అయితే, క్రిప్టోగ్రాఫిక్ కార్యకలాపాలు CPU-ఇంటెన్సివ్ కావచ్చు. నేను వాటిని [రస్ట్](https://rust-lang.org/) వంటి సంకలనం చేయబడిన భాషలో అమలు చేయడానికి ఇష్టపడతాను, మరియు బ్రౌజర్‌లో సంకేత భాషను అమలు చేయడానికి [WASM](https://webassembly.org/)ని ఉపయోగిస్తాను.
+
+మేము [Vite](https://vite.dev/) మరియు [React](https://react.dev/)ని ఉపయోగించబోతున్నాము. ఇవి పరిశ్రమ-ప్రామాణిక ఉపకరణాలు; మీకు వాటితో పరిచయం లేకపోతే, మీరు [ఈ ట్యుటోరియల్](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/)ను ఉపయోగించవచ్చు. Viteని ఉపయోగించడానికి, మాకు Node అవసరం.
+
+### కార్యకలాపంలో స్టెల్త్ చిరునామాలను చూడండి {#in-action}
+
+1. అవసరమైన ఉపకరణాలను ఇన్‌స్టాల్ చేయండి: [రస్ట్](https://rust-lang.org/tools/install/) మరియు [Node](https://nodejs.org/en/download).
+
+2. GitHub రిపోజిటరీని క్లోన్ చేయండి.
+
+   ```sh
+   git clone https://github.com/qbzzt/251022-stealth-addresses.git
+   cd 251022-stealth-addresses
+   ```
+
+3. అవసరమైన వాటిని ఇన్‌స్టాల్ చేయండి మరియు రస్ట్ సంకేత భాషను సంకలనం చేయండి.
+
+   ```sh
+   cd src/rust-wasm
+   rustup target add wasm32-unknown-unknown   
+   cargo install wasm-pack   
+   wasm-pack build --target web
+   ```
+
+4. వెబ్ సర్వర్‌ను ప్రారంభించండి.
+
+   ```sh
+   cd ../..
+   npm install
+   npm run dev
+   ```
+
+5. [అప్లికేషన్‌కు](http://localhost:5173/) బ్రౌజ్ చేయండి. ఈ అప్లికేషన్ పేజీకి రెండు ఫ్రేమ్‌లు ఉన్నాయి: ఒకటి అలీస్ వినియోగదారు ఇంటర్‌ఫేస్ కోసం మరియు మరొకటి బిల్ కోసం. రెండు ఫ్రేమ్‌లు కమ్యూనికేట్ చేయవు; అవి సౌలభ్యం కోసం మాత్రమే ఒకే పేజీలో ఉన్నాయి.
+
+6. అలీస్‌గా, **ఒక స్టెల్త్ మెటా-చిరునామాను సృష్టించు** క్లిక్ చేయండి. ఇది కొత్త స్టెల్త్ చిరునామాను మరియు దానికి సంబంధించిన ప్రైవేట్ కీలను ప్రదర్శిస్తుంది. స్టెల్త్ మెటా-చిరునామాను క్లిప్‌బోర్డ్‌కు కాపీ చేయండి.
+
+7. బిల్‌గా, కొత్త స్టెల్త్ మెటా-చిరునామాను పేస్ట్ చేసి, **ఒక చిరునామాను సృష్టించు** క్లిక్ చేయండి. ఇది మీకు అలీస్ కోసం నిధులు సమకూర్చడానికి చిరునామాను ఇస్తుంది.
+
+8. చిరునామా మరియు బిల్ పబ్లిక్ కీని కాపీ చేసి, వాటిని అలీస్ వినియోగదారు ఇంటర్‌ఫేస్‌లోని "బిల్ ద్వారా సృష్టించబడిన చిరునామా కోసం ప్రైవేట్ కీ" ప్రాంతంలో పేస్ట్ చేయండి. ఆ ఫీల్డ్‌లను పూరించిన తర్వాత, మీరు ఆ చిరునామాలోని ఆస్తులను యాక్సెస్ చేయడానికి ప్రైవేట్ కీని చూస్తారు.
+
+9. ప్రైవేట్ కీ చిరునామాకు అనుగుణంగా ఉందని నిర్ధారించుకోవడానికి మీరు [ఒక ఆన్‌లైన్ కాలిక్యులేటర్‌ను](https://iancoleman.net/ethereum-private-key-to-address/) ఉపయోగించవచ్చు.
+
+### ప్రోగ్రామ్ ఎలా పని చేస్తుంది {#how-the-program-works}
+
+#### WASM కాంపోనెంట్ {#wasm}
+
+WASMలోకి సంకలనం చేయబడిన మూల సంకేత భాష [రస్ట్](https://rust-lang.org/)లో వ్రాయబడింది. మీరు దానిని [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs)లో చూడవచ్చు. ఈ సంకేత భాష ప్రాథమికంగా జావాస్క్రిప్ట్ సంకేత భాష మరియు [`eth-stealth-addresses` లైబ్రరీ](https://github.com/kassandraoftroy/eth-stealth-addresses) మధ్య ఒక ఇంటర్‌ఫేస్.
+
+**`Cargo.toml`**
+
+రస్ట్‌లో [`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) జావాస్క్రిప్ట్‌లో [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json)కి సమానమైనది. ఇది ప్యాకేజీ సమాచారం, ఆధారపడటం ప్రకటనలు మొదలైనవాటిని కలిగి ఉంటుంది.
+
+```toml
+[package]
+name = "rust-wasm"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+eth-stealth-addresses = "0.1.0"
+hex = "0.4.3"
+wasm-bindgen = "0.2.104"
+getrandom = { version = "0.2", features = ["js"] }
+```
+
+[`getrandom`](https://docs.rs/getrandom/latest/getrandom/) ప్యాకేజీ యాదృచ్ఛిక విలువలను ఉత్పత్తి చేయాలి. అది కేవలం అల్గారిథమిక్ పద్ధతుల ద్వారా చేయబడదు; దీనికి ఎంట్రోపీ యొక్క మూలంగా భౌతిక ప్రక్రియకు యాక్సెస్ అవసరం. ఈ నిర్వచనం మనం నడుపుతున్న బ్రౌజర్‌ను అడగడం ద్వారా ఆ ఎంట్రోపీని పొందుతామని నిర్దేశిస్తుంది.
+
+```toml
+console_error_panic_hook = "0.1.7"
+```
+
+[ఈ లైబ్రరీ](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) WASM సంకేత భాష పానిక్ అయినప్పుడు మరియు కొనసాగించలేనప్పుడు మనకు మరింత అర్థవంతమైన దోష సందేశాలను ఇస్తుంది.
+
+```toml
+[lib]
+crate-type = ["cdylib", "rlib"]
+```
+
+WASM సంకేత భాషను ఉత్పత్తి చేయడానికి అవసరమైన అవుట్‌పుట్ రకం.
+
+**`lib.rs`**
+
+ఇది అసలు రస్ట్ సంకేత భాష.
+
+```rust
+use wasm_bindgen::prelude::*;
+```
+
+రస్ట్ నుండి WASM ప్యాకేజీని సృష్టించడానికి నిర్వచనాలు. అవి [ఇక్కడ](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html) డాక్యుమెంట్ చేయబడ్డాయి.
+
+```rust
+use eth_stealth_addresses::{
+    generate_stealth_meta_address,
+    generate_stealth_address,
+    compute_stealth_key
+};
+```
+
+మాకు [`eth-stealth-addresses` లైబ్రరీ](https://github.com/kassandraoftroy/eth-stealth-addresses) నుండి అవసరమైన ఫంక్షన్లు.
+
+```rust
+use hex::{decode,encode};
+```
+
+రస్ట్ సాధారణంగా విలువల కోసం బైట్ [అరేలను](https://doc.rust-lang.org/std/primitive.array.html) (`[u8; <size>]`) ఉపయోగిస్తుంది. కానీ జావాస్క్రిప్ట్‌లో, మనం సాధారణంగా హెక్సాడెసిమల్ స్ట్రింగ్‌లను ఉపయోగిస్తాము. [`hex` లైబ్రరీ](https://docs.rs/hex/latest/hex/) ఒక ప్రాతినిధ్యం నుండి మరొక దానికి మన కోసం అనువదిస్తుంది.
+
+```rust
+#[wasm_bindgen]
+```
+
+ఈ ఫంక్షన్‌ను జావాస్క్రిప్ట్ నుండి పిలవడానికి WASM బైండింగ్‌లను సృష్టించండి.
+
+```rust
+pub fn wasm_generate_stealth_meta_address() -> String {
+```
+
+బహుళ ఫీల్డ్‌లతో ఒక ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వడానికి సులభమైన మార్గం JSON స్ట్రింగ్‌ను తిరిగి ఇవ్వడం.
+
+```rust
+    let (address, spend_private_key, view_private_key) = 
+        generate_stealth_meta_address();
+```
+
+[`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) మూడు ఫీల్డ్‌లను తిరిగి ఇస్తుంది:
+
+- మెటా-చిరునామా (_K<sub>pub</sub>_ మరియు _V<sub>pub</sub>_)
+- వీక్షణ ప్రైవేట్ కీ (_V<sub>priv</sub>_)
+- ఖర్చు ప్రైవేట్ కీ (_K<sub>priv</sub>_)
+
+[టపుల్](https://doc.rust-lang.org/std/primitive.tuple.html) వాక్యనిర్మాణం ఆ విలువలను మళ్లీ వేరు చేయడానికి అనుమతిస్తుంది.
+
+```rust
+    format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}",
+        encode(address),
+        encode(view_private_key),
+        encode(spend_private_key)
+    )
+}
+```
+
+JSON-ఎన్‌కోడ్ చేయబడిన స్ట్రింగ్‌ను సృష్టించడానికి [`format!`](https://doc.rust-lang.org/std/fmt/index.html) మాక్రోని ఉపయోగించండి. అరేలను హెక్స్ స్ట్రింగ్‌లకు మార్చడానికి [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html)ని ఉపయోగించండి.
+
+```rust
+fn str_to_array<const N: usize>(s: &str) -> Option<[u8; N]> {
+```
+
+ఈ ఫంక్షన్ (జావాస్క్రిప్ట్ ద్వారా అందించబడిన) హెక్స్ స్ట్రింగ్‌ను బైట్ అర్రేగా మారుస్తుంది. జావాస్క్రిప్ట్ సంకేత భాష ద్వారా అందించబడిన విలువలను పార్స్ చేయడానికి మనం దానిని ఉపయోగిస్తాము. రస్ట్ అరేలు మరియు వెక్టర్లను ఎలా నిర్వహిస్తుందో దాని కారణంగా ఈ ఫంక్షన్ సంక్లిష్టంగా ఉంటుంది.
+
+`<const N: usize>` వ్యక్తీకరణను [జెనరిక్](https://doc.rust-lang.org/book/ch10-01-syntax.html) అంటారు. `N` అనేది తిరిగి ఇవ్వబడిన అరే యొక్క పొడవును నియంత్రించే ఒక పారామీటర్. ఈ ఫంక్షన్‌ను వాస్తవానికి `str_to_array::<n>` అని పిలుస్తారు, ఇక్కడ `n` అనేది అరే పొడవు.
+
+తిరిగి ఇవ్వబడిన విలువ `Option<[u8; N]>`, అంటే తిరిగి ఇవ్వబడిన అరే [ఆప్షనల్](https://doc.rust-lang.org/std/option/) అని అర్థం. ఇది విఫలం కాగల ఫంక్షన్ల కోసం రస్ట్‌లో ఒక సాధారణ నమూనా.
+
+ఉదాహరణకు, మనం `str_to_array::10("bad060a7")` అని పిలిస్తే, ఫంక్షన్ పది-విలువల అరేను తిరిగి ఇవ్వాలి, కానీ ఇన్‌పుట్ కేవలం నాలుగు బైట్లు మాత్రమే. ఫంక్షన్ విఫలం కావాలి, మరియు అది `None`ను తిరిగి ఇవ్వడం ద్వారా అలా చేస్తుంది. `str_to_array::4("bad060a7")` కోసం తిరిగి ఇవ్వబడిన విలువ `Some<[0xba, 0xd0, 0x60, 0xa7]>` అవుతుంది.
+
+```rust
+    // డీకోడ్ Result<Vec<u8>, _>ను తిరిగి ఇస్తుంది
+    let vec = decode(s).ok()?;
+```
+
+[`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html) ఫంక్షన్ `Result<Vec<u8>, FromHexError>`ను తిరిగి ఇస్తుంది. [`Result`](https://doc.rust-lang.org/std/result/) రకం విజయవంతమైన ఫలితం (`Ok(value)`) లేదా దోషం (`Err(error)`) కలిగి ఉండవచ్చు.
+
+`.ok()` పద్ధతి `Result`ను `Option`గా మారుస్తుంది, దీని విలువ విజయవంతమైతే `Ok()` విలువ లేదా కాకపోతే `None` అవుతుంది. చివరగా, [ప్రశ్నార్థక గుర్తు ఆపరేటర్](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) ప్రస్తుత ఫంక్షన్లను రద్దు చేసి, `Option` ఖాళీగా ఉంటే `None`ను తిరిగి ఇస్తుంది. లేకపోతే, ఇది విలువను అన్‌వ్రాప్ చేసి, దానిని తిరిగి ఇస్తుంది (ఈ సందర్భంలో, `vec`కు ఒక విలువను కేటాయించడానికి).
+
+ఇది దోషాలను నిర్వహించడానికి ఒక వింత సంక్లిష్టమైన పద్ధతిలా కనిపిస్తుంది, కానీ `Result` మరియు `Option` అన్ని దోషాలు ఒక విధంగా లేదా మరొక విధంగా నిర్వహించబడుతున్నాయని నిర్ధారిస్తాయి.
+
+```rust
+    if vec.len() != N { return None; }
+```
+
+బైట్ల సంఖ్య తప్పుగా ఉంటే, అది ఒక వైఫల్యం, మరియు మనం `None`ను తిరిగి ఇస్తాము.
+
+```rust
+    // try_into vecను వినియోగించి [u8; N] చేయడానికి ప్రయత్నిస్తుంది
+    let array: [u8; N] = vec.try_into().ok()?;
+```
+
+రస్ట్‌లో రెండు అరే రకాలు ఉన్నాయి. [అరేలకు](https://doc.rust-lang.org/std/primitive.array.html) ఒక స్థిర పరిమాణం ఉంటుంది. [వెక్టర్లు](https://doc.rust-lang.org/std/vec/index.html) పెరగవచ్చు మరియు తగ్గవచ్చు. `hex::decode` ఒక వెక్టర్‌ను తిరిగి ఇస్తుంది, కానీ `eth_stealth_addresses` లైబ్రరీ అరేలను స్వీకరించాలనుకుంటుంది. [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) ఒక విలువను మరొక రకంలోకి మారుస్తుంది, ఉదాహరణకు, ఒక వెక్టర్‌ను ఒక అరేలోకి.
+
+```rust
+    Some(array)
+}
+```
+
+రస్ట్ ఫంక్షన్ చివరిలో ఒక విలువను తిరిగి ఇచ్చేటప్పుడు [`return`](https://doc.rust-lang.org/std/keyword.return.html) కీవర్డ్‌ను ఉపయోగించమని అవసరం లేదు.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option<String> {
+```
+
+ఈ ఫంక్షన్ ఒక పబ్లిక్ మెటా-చిరునామాను స్వీకరిస్తుంది, ఇందులో _V<sub>pub</sub>_ మరియు _K<sub>pub</sub>_ రెండూ ఉంటాయి. ఇది స్టెల్త్ చిరునామా, ప్రచురించడానికి పబ్లిక్ కీ (_R<sub>pub</sub>_), మరియు అలీస్‌కు చెందిన ప్రచురిత చిరునామాలను గుర్తించడాన్ని వేగవంతం చేసే ఒక-బైట్ స్కాన్ విలువను తిరిగి ఇస్తుంది.
+
+స్కాన్ విలువ భాగస్వామ్య రహస్యం (_S = GR<sub>priv</sub>V<sub>priv</sub>_)లో ఒక భాగం. ఈ విలువ అలీస్‌కు అందుబాటులో ఉంటుంది, మరియు _f(K<sub>pub</sub>+G\*hash(S))_ ప్రచురిత చిరునామాకు సమానమా కాదా అని తనిఖీ చేయడం కంటే దీనిని తనిఖీ చేయడం చాలా వేగవంతమైనది.
+
+```rust
+    let (address, r_pub, scan) = 
+        generate_stealth_address(&str_to_array::<66>(stealth_address)?);
+```
+
+మేము లైబ్రరీ యొక్క [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html)ని ఉపయోగిస్తాము.
+
+```rust
+    format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}",
+        encode(address),
+        encode(r_pub),
+        encode(&[scan])
+    ).into()
+}
+```
+
+JSON-ఎన్‌కోడ్ చేయబడిన అవుట్‌పుట్ స్ట్రింగ్‌ను సిద్ధం చేయండి.
+
+```rust
+#[wasm_bindgen]
+pub fn wasm_compute_stealth_key(
+    address: &str, 
+    bill_pub_key: &str, 
+    view_private_key: &str,
+    spend_private_key: &str    
+) -> Option<String> {
+    .
+    .
+    .
+}
+```
+
+ఈ ఫంక్షన్ లైబ్రరీ యొక్క [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html)ని ఉపయోగించి చిరునామా (_R<sub>priv</sub>_) నుండి విత్‌డ్రా చేయడానికి ప్రైవేట్ కీని లెక్కిస్తుంది. ఈ గణనకు ఈ విలువలు అవసరం:
+
+- చిరునామా (_చిరునామా=f(P<sub>pub</sub>)_)
+- బిల్ ద్వారా సృష్టించబడిన పబ్లిక్ కీ (_R<sub>pub</sub>_)
+- వీక్షణ ప్రైవేట్ కీ (_V<sub>priv</sub>_)
+- ఖర్చు ప్రైవేట్ కీ (_K<sub>priv</sub>_)
+
+```rust
+#[wasm_bindgen(start)]
+```
+
+[`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) WASM సంకేత భాష ప్రారంభించబడినప్పుడు ఫంక్షన్ అమలు చేయబడుతుందని నిర్దేశిస్తుంది.
+
+```rust
+pub fn main() {
+    console_error_panic_hook::set_once();
+}
+```
+
+ఈ సంకేత భాష పానిక్ అవుట్‌పుట్‌ను జావాస్క్రిప్ట్ కన్సోల్‌కు పంపమని నిర్దేశిస్తుంది. దీనిని ఆచరణలో చూడటానికి, అప్లికేషన్‌ను ఉపయోగించి బిల్‌కు చెల్లని మెటా-చిరునామా ఇవ్వండి (కేవలం ఒక హెక్సాడెసిమల్ అంకెను మార్చండి). మీరు జావాస్క్రిప్ట్ కన్సోల్‌లో ఈ దోషాన్ని చూస్తారు:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9:
+assertion `left == right` failed
+  left: 0
+ right: 1
+```
+
+ఆ తర్వాత స్టాక్ ట్రేస్ ఉంటుంది. అప్పుడు బిల్‌కు చెల్లుబాటు అయ్యే మెటా-చిరునామా ఇవ్వండి, మరియు అలీస్‌కు చెల్లని చిరునామా లేదా చెల్లని పబ్లిక్ కీ ఇవ్వండి. మీరు ఈ దోషాన్ని చూస్తారు:
+
+```
+rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9:
+keys do not generate stealth address
+```
+
+మళ్లీ, ఆ తర్వాత స్టాక్ ట్రేస్ ఉంటుంది.
+
+#### వినియోగదారు ఇంటర్‌ఫేస్ {#ui}
+
+వినియోగదారు ఇంటర్‌ఫేస్ [React](https://react.dev/) ఉపయోగించి వ్రాయబడింది మరియు [Vite](https://vite.dev/) ద్వారా అందించబడుతుంది. మీరు [ఈ ట్యుటోరియల్](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) ఉపయోగించి వాటి గురించి తెలుసుకోవచ్చు. ఇక్కడ [WAGMI](https://wagmi.sh/) అవసరం లేదు ఎందుకంటే మనం బ్లాక్ చైను లేదా వాలెట్‌తో నేరుగా సంభాషించము.
+
+వినియోగదారు ఇంటర్‌ఫేస్‌లో స్పష్టంగా లేని ఏకైక భాగం WASM కనెక్టివిటీ. ఇది ఎలా పనిచేస్తుందో ఇక్కడ ఉంది.
+
+**`vite.config.js`**
+
+ఈ ఫైల్ [Vite కాన్ఫిగరేషన్‌ను](https://vite.dev/config/) కలిగి ఉంది.
+
+```js
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import wasm from "vite-plugin-wasm";
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), wasm()],
+})
+```
+
+మాకు రెండు Vite ప్లగిన్‌లు అవసరం: [react](https://www.npmjs.com/package/@vitejs/plugin-react) మరియు [wasm](https://github.com/Menci/vite-plugin-wasm#readme).
+
+**`App.jsx`**
+
+ఈ ఫైల్ అప్లికేషన్ యొక్క ప్రధాన భాగం. ఇది రెండు భాగాలను కలిగి ఉన్న ఒక కంటైనర్: `Alice` మరియు `Bill`, ఆ వినియోగదారుల కోసం వినియోగదారు ఇంటర్‌ఫేస్‌లు. WASM కోసం సంబంధించిన భాగం ప్రారంభ సంకేత భాష.
+
+```jsx
+import init from './rust-wasm/pkg/rust_wasm.js'
+```
+
+మనం [`wasm-pack`](https://rustwasm.github.io/docs/wasm-pack/)ని ఉపయోగించినప్పుడు, అది ఇక్కడ మనం ఉపయోగించే రెండు ఫైళ్ళను సృష్టిస్తుంది: అసలు సంకేత భాషతో ఒక wasm ఫైల్ (ఇక్కడ, `src/rust-wasm/pkg/rust_wasm_bg.wasm`) మరియు దానిని ఉపయోగించడానికి నిర్వచనాలతో ఒక జావాస్క్రిప్ట్ ఫైల్ (ఇక్కడ, `src/rust_wasm/pkg/rust_wasm.js`). ఆ జావాస్క్రిప్ట్ ఫైల్ యొక్క డిఫాల్ట్ ఎగుమతి WASMను ప్రారంభించడానికి అమలు చేయవలసిన సంకేత భాష.
+
+```jsx
+function App() {
+    .
+    .
+    .
+  useEffect(() => {
+    const loadWasm = async () => {
+      try {
+        await init();
+        setWasmReady(true)
+      } catch (err) {
+        console.error('Error loading wasm:', err)
+        alert("Wasm error: " + err)
+      }
+    }
+
+    loadWasm()
+    }, []
+  )
+```
+
+[`useEffect` హుక్](https://react.dev/reference/react/useEffect) మీకు స్టేట్ వేరియబుల్స్ మారినప్పుడు అమలు చేయబడే ఫంక్షన్‌ను నిర్దేశించడానికి అనుమతిస్తుంది. ఇక్కడ, స్టేట్ వేరియబుల్స్ జాబితా ఖాళీగా ఉంది (`[]`), కాబట్టి ఈ ఫంక్షన్ పేజీ లోడ్ అయినప్పుడు ఒకసారి మాత్రమే అమలు చేయబడుతుంది.
+
+ప్రభావ ఫంక్షన్ వెంటనే తిరిగి రావాలి. అసమకాలిక సంకేత భాషను ఉపయోగించడానికి, ఉదాహరణకు WASM `init` (ఇది `.wasm` ఫైల్‌ను లోడ్ చేయాలి మరియు అందువల్ల సమయం పడుతుంది) మనం అంతర్గత [`async`](https://en.wikipedia.org/wiki/Async/await) ఫంక్షన్‌ను నిర్వచించి, దానిని `await` లేకుండా అమలు చేస్తాము.
+
+**`Bill.jsx`**
+
+ఇది బిల్ కోసం వినియోగదారు ఇంటర్‌ఫేస్. అలీస్ అందించిన స్టెల్త్ మెటా-చిరునామా ఆధారంగా ఒక చిరునామాను సృష్టించడం దీనికి ఒకే ఒక చర్య.
+
+```jsx
+import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js'
+```
+
+డిఫాల్ట్ ఎగుమతితో పాటు, `wasm-pack` ద్వారా సృష్టించబడిన జావాస్క్రిప్ట్ సంకేత భాష WASM సంకేత భాషలోని ప్రతి ఫంక్షన్ కోసం ఒక ఫంక్షన్‌ను ఎగుమతి చేస్తుంది.
+
+```jsx
+            <button onClick={() => {
+              setPublicAddress(JSON.parse(wasm_generate_stealth_address(stealthMetaAddress)))
+            }}>
+```
+
+WASM ఫంక్షన్లను పిలవడానికి, మనం `wasm-pack` ద్వారా సృష్టించబడిన జావాస్క్రిప్ట్ ఫైల్ ద్వారా ఎగుమతి చేయబడిన ఫంక్షన్‌ను పిలిస్తే సరిపోతుంది.
+
+**`Alice.jsx`**
+
+`Alice.jsx`లోని సంకేత భాష సమానమైనది, కానీ అలీస్‌కు రెండు చర్యలు ఉన్నాయి:
+
+- ఒక మెటా-చిరునామాను సృష్టించడం
+- బిల్ ప్రచురించిన ఒక చిరునామా కోసం ప్రైవేట్ కీని పొందడం
+
+## ముగింపు {#conclusion}
+
+స్టెల్త్ చిరునామాలు సర్వరోగనివారిణి కాదు; వాటిని [సరిగ్గా ఉపయోగించాలి](#go-wrong). కానీ సరిగ్గా ఉపయోగించినప్పుడు, అవి ఒక పబ్లిక్ బ్లాక్ చైనులో గోప్యతను ప్రారంభించగలవు.
+
+[నా మరిన్ని పనుల కోసం ఇక్కడ చూడండి](https://cryptodocguy.pro/).
\ No newline at end of file
diff --git a/public/content/translations/te/developers/tutorials/the-graph-fixing-web3-data-querying/index.md b/public/content/translations/te/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
new file mode 100644
index 00000000000..768713ef371
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/the-graph-fixing-web3-data-querying/index.md
@@ -0,0 +1,314 @@
+---
+title: "ది గ్రాఫ్: వెబ్3 డేటా క్వేరింగ్ ను సరిచేయడం"
+description: "బ్లాక్ చైను ఒక డేటాబేస్ లాంటిది కానీ SQL లేకుండా. డేటా అంతా అక్కడే ఉంది, కానీ దాన్ని యాక్సెస్ చేయడానికి మార్గం లేదు. ది గ్రాఫ్ మరియు గ్రాఫ్ క్యూఎల్ తో దీనిని ఎలా పరిష్కరించాలో నేను మీకు చూపిస్తాను."
+author: Markus Waas
+lang: te
+tags:
+  [
+    "దృఢత్వం",
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "ప్రశ్నించడం",
+    "ది గ్రాఫ్",
+    "react"
+  ]
+skill: intermediate
+published: 2020-09-06
+source: soliditydeveloper.com
+sourceUrl: https://soliditydeveloper.com/thegraph
+---
+
+ఈసారి మనం ది గ్రాఫ్‌ను నిశితంగా పరిశీలిద్దాం, ఇది గత సంవత్సరంలో డాప్స్‌ను అభివృద్ధి చేయడానికి ప్రామాణిక స్టాక్‌లో ముఖ్యమైన భాగంగా మారింది. ముందుగా మనం సాంప్రదాయ పద్ధతిలో పనులను ఎలా చేస్తామో చూద్దాం...
+
+## ది గ్రాఫ్ లేకుండా... {#without-the-graph}
+
+కాబట్టి దృష్టాంత ప్రయోజనాల కోసం ఒక సాధారణ ఉదాహరణతో వెళ్దాం. మనందరికీ ఆటలు ఇష్టం, కాబట్టి వినియోగదారులు పందెం కాసే ఒక సాధారణ ఆటను ఊహించుకోండి:
+
+```solidity
+pragma solidity 0.7.1;
+
+contract Game {
+    uint256 totalGamesPlayerWon = 0;
+    uint256 totalGamesPlayerLost = 0;
+    event BetPlaced(address player, uint256 value, bool hasWon);
+
+    function placeBet() external payable {
+        bool hasWon = evaluateBetForPlayer(msg.sender);
+
+        if (hasWon) {
+            (bool success, ) = msg.sender.call{ value: msg.value * 2 }('');
+            require(success, "Transfer failed");
+            totalGamesPlayerWon++;
+        } else {
+            totalGamesPlayerLost++;
+        }
+
+        emit BetPlaced(msg.sender, msg.value, hasWon);
+    }
+}
+```
+
+ఇప్పుడు మన డాప్‌లో, మొత్తం పందాలను, ఓడిపోయిన/గెలిచిన మొత్తం ఆటలను ప్రదర్శించాలని మరియు ఎవరైనా మళ్లీ ఆడినప్పుడల్లా దాన్ని అప్‌డేట్ చేయాలని అనుకుందాం. విధానం ఇలా ఉంటుంది:
+
+1. `totalGamesPlayerWon`ను పొందండి.
+2. `totalGamesPlayerLost`ను పొందండి.
+3. `BetPlaced` ఈవెంట్‌లకు సబ్స్క్రయిబ్ అవ్వండి.
+
+కుడి వైపు చూపిన విధంగా మనం [వెబ్3లో ఈవెంట్](https://docs.web3js.org/api/web3/class/Contract#events) ను వినవచ్చు, కానీ దీనికి చాలా కేసులను నిర్వహించడం అవసరం.
+
+```solidity
+GameContract.events.BetPlaced({
+    fromBlock: 0
+}, function(error, event) { console.log(event); })
+.on('data', function(event) {
+    // ఈవెంట్ ఫైర్ చేయబడింది
+})
+.on('changed', function(event) {
+    // ఈవెంట్ మళ్ళీ తీసివేయబడింది
+})
+.on('error', function(error, receipt) {
+    // tx తిరస్కరించబడింది
+});
+```
+
+ఇప్పుడు ఇది మన సాధారణ ఉదాహరణకు కొంతవరకు బాగానే ఉంది. కానీ ఇప్పుడు మనం ప్రస్తుత ఆటగాడికి మాత్రమే ఓడిపోయిన/గెలిచిన పందాల మొత్తాలను ప్రదర్శించాలని అనుకుందాం. మనకు అదృష్టం లేదు, మీరు ఆ విలువలను నిల్వ చేసే కొత్త కాంట్రాక్ట్‌ను డిప్లాయ్ చేసి వాటిని పొందడం మంచిది. ఇప్పుడు చాలా సంక్లిష్టమైన స్మార్ట్ కాంట్రాక్ట్ మరియు డాప్‌ను ఊహించుకోండి, విషయాలు త్వరగా గందరగోళంగా మారవచ్చు.
+
+![కేవలం ప్రశ్నించడం సరిపోదు](./one-does-not-simply-query.jpg)
+
+ఇది ఎలా సరైనది కాదో మీరు చూడవచ్చు:
+
+- ఇప్పటికే డిప్లాయ్ చేసిన కాంట్రాక్టులకు పనిచేయదు.
+- ఆ విలువలను నిల్వ చేయడానికి అదనపు గ్యాస్ ఖర్చులు.
+- ఇతీరియము నోడ్ కోసం డేటాను పొందేందుకు మరొక కాల్ అవసరం.
+
+![అది సరిపోదు](./not-good-enough.jpg)
+
+ఇప్పుడు ఒక మంచి పరిష్కారాన్ని చూద్దాం.
+
+## మిమ్మల్ని GraphQLకు పరిచయం చేయనివ్వండి {#let-me-introduce-to-you-graphql}
+
+ముందుగా మనం GraphQL గురించి మాట్లాడుకుందాం, ఇది మొదట ఫేస్బుక్ చే రూపొందించబడింది మరియు అమలు చేయబడింది. మీకు సాంప్రదాయ రెస్ట్ ఎపిఐ మోడల్ గురించి తెలిసి ఉండవచ్చు. ఇప్పుడు దానికి బదులుగా మీకు కావలసిన డేటా కోసం కచ్చితంగా మీరు ఒక క్వెరీ వ్రాయగలరని ఊహించుకోండి:
+
+![గ్రాఫ్ క్యూఎల్ ఎపిఐ వర్సెస్ రెస్ట్ ఎపిఐ](./graphql.jpg)
+
+![](./graphql-query.gif)
+
+ఈ రెండు చిత్రాలు చాలా వరకు GraphQL సారాన్ని సంగ్రహిస్తాయి. కుడివైపున ఉన్న క్వెరీతో మనకు ఏ డేటా కావాలో కచ్చితంగా నిర్వచించవచ్చు, కాబట్టి అక్కడ మనం ఒకే అభ్యర్థనలో ప్రతిదీ పొందుతాము మరియు మనకు అవసరమైన దాని కంటే ఎక్కువ ఏమీ పొందము. ఒక GraphQL సర్వర్ అవసరమైన మొత్తం డేటాను పొందడాన్ని నిర్వహిస్తుంది, కాబట్టి ఫ్రంటెండ్ వినియోగదారు వైపు ఉపయోగించడం చాలా సులభం. [ఇది ఒక మంచి వివరణ](https://www.apollographql.com/blog/graphql-explained) మీకు ఆసక్తి ఉంటే సర్వర్ ఒక క్వెరీని కచ్చితంగా ఎలా నిర్వహిస్తుందో వివరిస్తుంది.
+
+ఇప్పుడు ఆ జ్ఞానంతో, చివరకు బ్లాక్ చైను స్పేస్ మరియు ది గ్రాఫ్‌లోకి ప్రవేశిద్దాం.
+
+## ది గ్రాఫ్ అంటే ఏమిటి? {#what-is-the-graph}
+
+బ్లాక్ చైను ఒక వికేంద్రీకృత డేటాబేస్, కానీ సాధారణంగా జరిగే దానికి భిన్నంగా, ఈ డేటాబేస్ కోసం మనకు క్వెరీ భాష లేదు. డేటాను తిరిగి పొందేందుకు పరిష్కారాలు బాధాకరంగా లేదా పూర్తిగా అసాధ్యంగా ఉంటాయి. ది గ్రాఫ్ అనేది బ్లాక్ చైను డేటాను ఇండెక్సింగ్ మరియు క్వెరీ చేయడం కోసం ఒక వికేంద్రీకృత ప్రోటోకాల్. మరియు మీరు ఊహించినట్లుగానే, ఇది క్వెరీ భాషగా GraphQLని ఉపయోగిస్తుంది.
+
+![ది గ్రాఫ్](./thegraph.png)
+
+ఏదైనా అర్థం చేసుకోవడానికి ఉదాహరణలు ఎల్లప్పుడూ ఉత్తమమైనవి, కాబట్టి మన GameContract ఉదాహరణ కోసం ది గ్రాఫ్‌ను ఉపయోగిద్దాం.
+
+## సబ్‌గ్రాఫ్‌ను ఎలా సృష్టించాలి {#how-to-create-a-subgraph}
+
+డేటాను ఎలా ఇండెక్స్ చేయాలో అనే నిర్వచనాన్ని సబ్‌గ్రాఫ్ అంటారు. దీనికి మూడు భాగాలు అవసరం:
+
+1. మ్యానిఫెస్ట్ (`subgraph.yaml`)
+2. స్కీమా (`schema.graphql`)
+3. మ్యాపింగ్ (`mapping.ts`)
+
+### మ్యానిఫెస్ట్ (`subgraph.yaml`) {#manifest}
+
+మ్యానిఫెస్ట్ మన కాన్ఫిగరేషన్ ఫైల్ మరియు నిర్వచిస్తుంది:
+
+- ఏ స్మార్ట్ కాంట్రాక్ట్‌లను ఇండెక్స్ చేయాలి (చిరునామా, నెట్‌వర్క్, ఎబిఐ...)
+- ఏ ఈవెంట్‌లను వినాలి
+- ఫంక్షన్ కాల్స్ లేదా బ్లాక్‌ల వంటి ఇతర విషయాలను వినడం
+- కాల్ చేయబడుతున్న మ్యాపింగ్ ఫంక్షన్‌లు (క్రింద `mapping.ts` చూడండి)
+
+మీరు ఇక్కడ బహుళ కాంట్రాక్టులను మరియు హ్యాండ్లర్లను నిర్వచించవచ్చు. ఒక సాధారణ సెటప్‌లో హార్డ్‌హాట్ ప్రాజెక్ట్ లోపల దాని స్వంత రిపోజిటరీతో ఒక సబ్‌గ్రాఫ్ ఫోల్డర్ ఉంటుంది. అప్పుడు మీరు ఎబిఐను సులభంగా సూచించవచ్చు.
+
+సౌలభ్యం కోసం మీరు మస్టాచ్ వంటి టెంప్లేట్ సాధనాన్ని కూడా ఉపయోగించాలనుకోవచ్చు. అప్పుడు మీరు ఒక `subgraph.template.yaml` సృష్టించి, తాజా డిప్లాయ్‌మెంట్ల ఆధారంగా చిరునామాలను చేర్చండి. మరింత అధునాతన ఉదాహరణ సెటప్ కోసం, ఉదాహరణకు [Aave సబ్ గ్రాఫ్ రెపో](https://github.com/aave/aave-protocol/tree/master/thegraph) చూడండి.
+
+మరియు పూర్తి డాక్యుమెంటేషన్ [ఇక్కడ](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest) చూడవచ్చు.
+
+```yaml
+specVersion: 0.0.1
+description: ఇతీరియముపై పందెం వేయడం
+repository: - GitHub లింక్ -
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: GameContract
+    network: mainnet
+    source:
+      address: '0x2E6454...cf77eC'
+      abi: GameContract
+      startBlock: 6175244
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.1
+      language: wasm/assemblyscript
+      entities:
+        - GameContract
+      abis:
+        - name: GameContract
+          file: ../build/contracts/GameContract.json
+      eventHandlers:
+        - event: PlacedBet(address,uint256,bool)
+          handler: handleNewBet
+      file: ./src/mapping.ts
+```
+
+### స్కీమా (`schema.graphql`) {#schema}
+
+స్కీమా అనేది GraphQL డేటా నిర్వచనం. ఇది ఏ ఎంటిటీలు ఉన్నాయి మరియు వాటి రకాలను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తుంది. ది గ్రాఫ్ నుండి మద్దతు ఉన్న రకాలు
+
+- బైట్‌లు
+- ID
+- స్ట్రింగ్
+- బూలియన్
+- ఇంట్
+- బిగ్ ఇంట్
+- బిగ్ డెసిమల్
+
+సంబంధాలను నిర్వచించడానికి మీరు ఎంటిటీలను రకంగా కూడా ఉపయోగించవచ్చు. మా ఉదాహరణలో మేము ఆటగాడి నుండి పందాలకు 1-నుండి-చాలా సంబంధాన్ని నిర్వచిస్తాము. !  అంటే విలువ ఖాళీగా ఉండకూడదు. పూర్తి డాక్యుమెంటేషన్ [ఇక్కడ](https://thegraph.com/docs/en/developing/creating-a-subgraph/#the-subgraph-manifest) చూడవచ్చు.
+
+```graphql
+type Bet @entity {
+  id: ID!
+  player: Player!
+  playerHasWon: Boolean!
+  time: Int!
+}
+
+type Player @entity {
+  id: ID!
+  totalPlayedCount: Int
+  hasWonCount: Int
+  hasLostCount: Int
+  bets: [Bet]!
+}
+```
+
+### మ్యాపింగ్ (`mapping.ts`) {#mapping}
+
+ది గ్రాఫ్‌లోని మ్యాపింగ్ ఫైల్ ఇన్‌కమింగ్ ఈవెంట్‌లను ఎంటిటీలుగా మార్చే మన ఫంక్షన్‌లను నిర్వచిస్తుంది. ఇది టైప్‌స్క్రిప్ట్ యొక్క ఉపసమితి అయిన అసెంబ్లీస్క్రిప్ట్‌లో వ్రాయబడింది. దీని అర్థం మ్యాపింగ్ యొక్క మరింత సమర్థవంతమైన మరియు పోర్టబుల్ అమలు కోసం దీనిని వాసం (వెబ్ అసెంబ్లీ) లోకి కంపైల్ చేయవచ్చు.
+
+మీరు `subgraph.yaml` ఫైల్‌లో పేరు పెట్టబడిన ప్రతి ఫంక్షన్‌ను నిర్వచించవలసి ఉంటుంది, కాబట్టి మన విషయంలో మనకు ఒకటి మాత్రమే అవసరం: `handleNewBet`. మనం మొదట పంపినవారి చిరునామా నుండి ప్లేయర్ ఎంటిటీని ఐడిగా లోడ్ చేయడానికి ప్రయత్నిస్తాము. అది ఉనికిలో లేకపోతే, మేము ఒక కొత్త ఎంటిటీని సృష్టించి దానిని ప్రారంభ విలువలతో నింపుతాము.
+
+అప్పుడు మనం ఒక కొత్త బెట్ ఎంటిటీని సృష్టిస్తాము. దీనికి ఐడి `event.transaction.hash.toHex() + "-" + event.logIndex.toString()`గా ఉంటుంది, ఇది ఎల్లప్పుడూ ప్రత్యేకమైన విలువను నిర్ధారిస్తుంది. ఒక స్మార్ట్ కాంట్రాక్ట్ ద్వారా ఒకే లావాదేవీలో ఎవరైనా ప్లేస్‌బెట్ ఫంక్షన్‌ను చాలాసార్లు కాల్ చేయవచ్చు కాబట్టి కేవలం హాష్‌ను ఉపయోగించడం సరిపోదు.
+
+చివరగా మనం ప్లేయర్ ఎంటిటీని మొత్తం డేటాతో అప్‌డేట్ చేయవచ్చు. శ్రేణులను నేరుగా పుష్ చేయలేము, కానీ ఇక్కడ చూపిన విధంగా నవీకరించబడాలి. పందెంను సూచించడానికి మనం ఐడిని ఉపయోగిస్తాము. మరియు ఒక ఎంటిటీని నిల్వ చేయడానికి చివరలో `.save()` అవసరం.
+
+పూర్తి డాక్యుమెంటేషన్ ఇక్కడ చూడవచ్చు: https://thegraph.com/docs/en/developing/creating-a-subgraph/#writing-mappings. మీరు మ్యాపింగ్ ఫైల్‌కు లాగింగ్ అవుట్‌పుట్‌ను కూడా జోడించవచ్చు, [ఇక్కడ](https://thegraph.com/docs/en/subgraphs/developing/creating/graph-ts/api/#api-reference) చూడండి.
+
+```typescript
+import { Bet, Player } from "../generated/schema"
+import { PlacedBet } from "../generated/GameContract/GameContract"
+
+export function handleNewBet(event: PlacedBet): void {
+  let player = Player.load(event.transaction.from.toHex())
+
+  if (player == null) {
+    // ఇంకా లేకపోతే సృష్టించండి
+    player = new Player(event.transaction.from.toHex())
+    player.bets = new Array<string>(0)
+    player.totalPlayedCount = 0
+    player.hasWonCount = 0
+    player.hasLostCount = 0
+  }
+
+  let bet = new Bet(
+    event.transaction.hash.toHex() + "-" + event.logIndex.toString()
+  )
+  bet.player = player.id
+  bet.playerHasWon = event.params.hasWon
+  bet.time = event.block.timestamp
+  bet.save()
+
+  player.totalPlayedCount++
+  if (event.params.hasWon) {
+    player.hasWonCount++
+  } else {
+    player.hasLostCount++
+  }
+
+  // శ్రేణిని ఇలా నవీకరించండి
+  let bets = player.bets
+  bets.push(bet.id)
+  player.bets = bets
+
+  player.save()
+}
+```
+
+## ఫ్రంటెండ్‌లో దీనిని ఉపయోగించడం {#using-it-in-the-frontend}
+
+అపోలో బూస్ట్ వంటి వాటిని ఉపయోగించి, మీరు మీ రియాక్ట్ డాప్‌లో (లేదా అపోలో-వ్యూ) ది గ్రాఫ్‌ను సులభంగా ఇంటిగ్రేట్ చేయవచ్చు. ముఖ్యంగా రియాక్ట్ హుక్స్ మరియు అపోలోను ఉపయోగిస్తున్నప్పుడు, మీ కాంపోనెంట్‌లో ఒకే GraphQL క్వెరీని వ్రాయడం అంత సులభం డేటాను పొందడం. ఒక సాధారణ సెటప్ ఇలా ఉండవచ్చు:
+
+```javascript
+// అన్ని సబ్‌గ్రాఫ్‌లను చూడండి: https://thegraph.com/explorer/
+const client = new ApolloClient({
+  uri: "{{ subgraphUrl }}",
+})
+
+ReactDOM.render(
+  <ApolloProvider client={client}>
+    <App />
+  </ApolloProvider>,
+  document.getElementById("root")
+)
+```
+
+మరియు ఇప్పుడు మనం ఉదాహరణకు ఇలాంటి క్వెరీని వ్రాయవచ్చు. ఇది మనకు అందిస్తుంది
+
+- ప్రస్తుత వినియోగదారు ఎన్నిసార్లు గెలిచారు
+- ప్రస్తుత వినియోగదారు ఎన్నిసార్లు ఓడిపోయారు
+- వారి మునుపటి అన్ని పందాలతో కూడిన టైమ్‌స్టాంప్‌ల జాబితా
+
+అన్నీ GraphQL సర్వర్‌కు ఒకే అభ్యర్థనలో.
+
+```javascript
+const myGraphQlQuery = gql`
+    players(where: { id: $currentUser }) {
+      totalPlayedCount
+      hasWonCount
+      hasLostCount
+      bets {
+        time
+      }
+    }
+`
+
+const { loading, error, data } = useQuery(myGraphQlQuery)
+
+React.useEffect(() => {
+  if (!loading && !error && data) {
+    console.log({ data })
+  }
+}, [loading, error, data])
+```
+
+![మాయ](./magic.jpg)
+
+కానీ మనం ఈ పజిల్ యొక్క చివరి భాగాన్ని కోల్పోతున్నాము మరియు అది సర్వర్. మీరు దానిని మీరే అమలు చేయవచ్చు లేదా హోస్ట్ చేసిన సేవను ఉపయోగించవచ్చు.
+
+## ది గ్రాఫ్ సర్వర్ {#the-graph-server}
+
+### గ్రాఫ్ ఎక్స్‌ప్లోరర్: హోస్ట్ చేసిన సేవ {#graph-explorer-the-hosted-service}
+
+సులభమైన మార్గం హోస్ట్ చేసిన సేవను ఉపయోగించడం. సబ్‌గ్రాఫ్‌ను డిప్లాయ్ చేయడానికి [ఇక్కడ](https://thegraph.com/docs/en/deploying/deploying-a-subgraph-to-hosted/) సూచనలను అనుసరించండి. అనేక ప్రాజెక్టుల కోసం మీరు వాస్తవానికి [ఎక్స్‌ప్లోరర్‌లో](https://thegraph.com/explorer/) ఇప్పటికే ఉన్న సబ్‌గ్రాఫ్‌లను కనుగొనవచ్చు.
+
+![ది గ్రాఫ్-ఎక్స్‌ప్లోరర్](./thegraph-explorer.png)
+
+### మీ స్వంత నోడ్‌ను నడపడం {#running-your-own-node}
+
+ప్రత్యామ్నాయంగా మీరు మీ స్వంత నోడ్‌ను అమలు చేయవచ్చు. డాక్స్ [ఇక్కడ](https://github.com/graphprotocol/graph-node#quick-start). దీనిని చేయడానికి ఒక కారణం హోస్ట్ చేసిన సేవ మద్దతు ఇవ్వని నెట్‌వర్క్‌ను ఉపయోగించడం కావచ్చు. ప్రస్తుతం మద్దతు ఉన్న నెట్‌వర్క్‌లను [ఇక్కడ కనుగొనవచ్చు](https://thegraph.com/docs/en/developing/supported-networks/).
+
+## వికేంద్రీకృత భవిష్యత్తు {#the-decentralized-future}
+
+GraphQL కొత్తగా వచ్చే ఈవెంట్‌ల కోసం స్ట్రీమ్‌లకు కూడా మద్దతు ఇస్తుంది. ఇవి గ్రాఫ్‌లో [సబ్‌స్ట్రీమ్‌ల](https://thegraph.com/docs/en/substreams/) ద్వారా మద్దతివ్వబడతాయి, ఇవి ప్రస్తుతం ఓపెన్ బీటాలో ఉన్నాయి.
+
+[2021](https://thegraph.com/blog/mainnet-migration/)లో ది గ్రాఫ్ వికేంద్రీకృత ఇండెక్సింగ్ నెట్‌వర్క్‌కు తన పరివర్తనను ప్రారంభించింది. ఈ వికేంద్రీకృత ఇండెక్సింగ్ నెట్‌వర్క్ యొక్క ఆర్కిటెక్చర్ గురించి మీరు మరింతగా [ఇక్కడ](https://thegraph.com/docs/en/network/explorer/) చదవవచ్చు.
+
+రెండు ముఖ్యమైన అంశాలు:
+
+1. వినియోగదారులు క్వెరీల కోసం ఇండెక్సర్లకు చెల్లిస్తారు.
+2. ఇండెక్సర్లు గ్రాఫ్ టోకెన్లను (జిఆర్టి) స్టేక్ చేస్తారు.
diff --git a/public/content/translations/te/developers/tutorials/token-integration-checklist/index.md b/public/content/translations/te/developers/tutorials/token-integration-checklist/index.md
new file mode 100644
index 00000000000..60a6e3b5d26
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/token-integration-checklist/index.md
@@ -0,0 +1,86 @@
+---
+title: "టోకెన్ ఇంటిగ్రేషన్ చెక్‌లిస్ట్"
+description: "టోకెన్‌లతో ఇంటరాక్ట్ అయ్యేటప్పుడు పరిగణించవలసిన విషయాల చెక్‌లిస్ట్"
+author: "Trailofbits"
+lang: te
+tags:
+  [
+    "దృఢత్వం",
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "భద్రత",
+    "టోకెన్లు"
+  ]
+skill: intermediate
+published: 2020-08-13
+source: Building secure contracts
+sourceUrl: https://github.com/crytic/building-secure-contracts/blob/master/development-guidelines/token_integration.md
+---
+
+ఏకపక్ష టోకెన్‌లతో ఇంటరాక్ట్ అయ్యేటప్పుడు ఈ చెక్‌లిస్ట్‌ను అనుసరించండి. ప్రతి అంశంతో ముడిపడి ఉన్న ప్రమాదాలను మీరు అర్థం చేసుకున్నారని నిర్ధారించుకోండి మరియు ఈ నియమాలకు ఏవైనా మినహాయింపులను సమర్థించుకోండి.
+
+సౌలభ్యం కోసం, అన్ని Slither [యుటిలిటీలను](https://github.com/crytic/slither#tools) నేరుగా టోకెన్ చిరునామాపై అమలు చేయవచ్చు, ఉదాహరణకు:
+
+[Slither ట్యుటోరియల్‌ను ఉపయోగించడం](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/)
+
+```bash
+slither-check-erc 0xdac17f958d2ee523a2206206994597c13d831ec7 TetherToken
+```
+
+ఈ చెక్‌లిస్ట్‌ను అనుసరించడానికి, మీరు టోకెన్ కోసం Slither నుండి ఈ అవుట్‌పుట్‌ను కలిగి ఉండాలి:
+
+```bash
+- slither-check-erc [target] [contractName] [optional: --erc ERC_NUMBER]
+- slither [target] --print human-summary
+- slither [target] --print contract-summary
+- slither-prop . --contract ContractName # కాన్ఫిగరేషన్ అవసరం, మరియు Echidna మరియు Manticore వాడకం
+```
+
+## సాధారణ పరిగణనలు {#general-considerations}
+
+- **కాంట్రాక్ట్‌కు భద్రతా సమీక్ష ఉంది.** భద్రతా సమీక్ష లేని కాంట్రాక్ట్‌లతో ఇంటరాక్ట్ అవ్వవద్దు. అంచనా యొక్క నిడివి (అకా “ప్రయత్న స్థాయి”), భద్రతా సంస్థ యొక్క కీర్తి, మరియు కనుగొన్న విషయాల సంఖ్య మరియు తీవ్రతను తనిఖీ చేయండి.
+- **మీరు డెవలపర్‌లను సంప్రదించారు.** మీరు ఒక సంఘటన గురించి వారి బృందాన్ని హెచ్చరించాల్సి రావచ్చు. [blockchain-security-contacts](https://github.com/crytic/blockchain-security-contacts) పై తగిన పరిచయాల కోసం చూడండి.
+- **వారికి క్లిష్టమైన ప్రకటనల కోసం ఒక భద్రతా మెయిలింగ్ జాబితా ఉంది.** వారి బృందం వినియోగదారులకు (మీలాంటి వారికి!) సలహా ఇవ్వాలి క్లిష్టమైన సమస్యలు కనుగొనబడినప్పుడు లేదా అప్‌గ్రేడ్‌లు జరిగినప్పుడు.
+
+## ERC అనుగుణ్యత {#erc-conformity}
+
+Slither లో [slither-check-erc](https://github.com/crytic/slither/wiki/ERC-Conformance) అనే ఒక యుటిలిటీ ఉంది, ఇది ఒక టోకెన్ అనేక సంబంధిత ERC ప్రమాణాలకు అనుగుణంగా ఉందో లేదో సమీక్షిస్తుంది. వీటిని సమీక్షించడానికి slither-check-ercని ఉపయోగించండి:
+
+- **ట్రాన్స్ఫర్ మరియు ట్రాన్స్ఫర్ ఫ్రమ్ ఒక బూలియన్‌ను తిరిగి ఇస్తాయి.** అనేక టోకెన్‌లు ఈ ఫంక్షన్‌లపై బూలియన్‌ను తిరిగి ఇవ్వవు. ఫలితంగా, కాంట్రాక్ట్‌లో వాటి కాల్స్ విఫలం కావచ్చు.
+- **పేరు, దశాంశాలు మరియు చిహ్నం ఫంక్షన్‌లు ఉపయోగించినట్లయితే ఉంటాయి.** ఈ ఫంక్షన్‌లు ERC20 ప్రమాణంలో ఐచ్ఛికం మరియు ఉండకపోవచ్చు.
+- **దశాంశాలు ఒక uint8 ను తిరిగి ఇస్తాయి.** అనేక టోకెన్‌లు తప్పుగా ఒక uint256 ను తిరిగి ఇస్తాయి. ఇదే జరిగితే, తిరిగి వచ్చిన విలువ 255 కంటే తక్కువగా ఉందని నిర్ధారించుకోండి.
+- **టోకెన్ తెలిసిన [ERC20 రేస్ కండిషన్‌ను](https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729) తగ్గిస్తుంది.** ERC20 ప్రమాణంలో తెలిసిన ERC20 రేస్ కండిషన్ ఉంది, దీనిని దాడి చేసేవారు టోకెన్‌లను దొంగిలించకుండా నిరోధించడానికి తగ్గించాలి.
+- **టోకెన్ ఒక ERC777 టోకెన్ కాదు మరియు ట్రాన్స్ఫర్ మరియు ట్రాన్స్ఫర్ ఫ్రమ్‌లో బాహ్య ఫంక్షన్ కాల్ లేదు.** ట్రాన్స్ఫర్ ఫంక్షన్‌లలో బాహ్య కాల్స్ రీఎంట్రాన్సీలకు దారితీయవచ్చు.
+
+Slither లో [slither-prop](https://github.com/crytic/slither/wiki/Property-generation) అనే ఒక యుటిలిటీ ఉంది, ఇది అనేక సాధారణ ERC లోపాలను కనుగొనగల యూనిట్ టెస్ట్‌లు మరియు భద్రతా లక్షణాలను ఉత్పత్తి చేస్తుంది. వీటిని సమీక్షించడానికి slither-propని ఉపయోగించండి:
+
+- **కాంట్రాక్ట్ slither-prop నుండి అన్ని యూనిట్ టెస్ట్‌లు మరియు భద్రతా లక్షణాలను పాస్ చేస్తుంది.** ఉత్పత్తి చేయబడిన యూనిట్ టెస్ట్‌లను అమలు చేయండి, ఆపై [Echidna](https://github.com/crytic/echidna) మరియు [Manticore](https://manticore.readthedocs.io/en/latest/verifier.html)తో లక్షణాలను తనిఖీ చేయండి.
+
+చివరగా, కొన్ని లక్షణాలను స్వయంచాలకంగా గుర్తించడం కష్టం. ఈ పరిస్థితుల కోసం చేతితో సమీక్షించండి:
+
+- **ట్రాన్స్ఫర్ మరియు ట్రాన్స్ఫర్ ఫ్రమ్ రుసుము తీసుకోకూడదు.** ప్రతి ద్రవ్యోల్బణ టోకెన్‌లు అనూహ్య ప్రవర్తనకు దారితీయవచ్చు.
+- **టోకెన్ నుండి సంపాదించిన సంభావ్య వడ్డీని పరిగణనలోకి తీసుకుంటారు.** కొన్ని టోకెన్‌లు టోకెన్ హోల్డర్‌లకు వడ్డీని పంపిణీ చేస్తాయి. ఈ వడ్డీని పరిగణనలోకి తీసుకోకపోతే కాంట్రాక్ట్‌లో చిక్కుకుపోవచ్చు.
+
+## కాంట్రాక్ట్ కూర్పు {#contract-composition}
+
+- **కాంట్రాక్ట్ అనవసరమైన సంక్లిష్టతను నివారిస్తుంది.** టోకెన్ ఒక సాధారణ కాంట్రాక్ట్ అయి ఉండాలి; సంక్లిష్టమైన కోడ్‌తో ఉన్న టోకెన్‌కు ఉన్నత స్థాయి సమీక్ష అవసరం. సంక్లిష్టమైన కోడ్‌ను గుర్తించడానికి Slither యొక్క [హ్యూమన్-సమ్మరీ ప్రింటర్‌ను](https://github.com/crytic/slither/wiki/Printer-documentation#human-summary) ఉపయోగించండి.
+- **కాంట్రాక్ట్ SafeMathను ఉపయోగిస్తుంది.** SafeMathను ఉపయోగించని కాంట్రాక్ట్‌లకు ఉన్నత స్థాయి సమీక్ష అవసరం. SafeMath వాడకం కోసం కాంట్రాక్ట్‌ను చేతితో తనిఖీ చేయండి.
+- **కాంట్రాక్ట్‌లో టోకెన్‌కు సంబంధం లేని కొన్ని ఫంక్షన్‌లు మాత్రమే ఉన్నాయి.** టోకెన్‌కు సంబంధం లేని ఫంక్షన్‌లు కాంట్రాక్ట్‌లో సమస్య వచ్చే సంభావ్యతను పెంచుతాయి. కాంట్రాక్ట్‌లో ఉపయోగించిన కోడ్‌ను విస్తృతంగా సమీక్షించడానికి Slither యొక్క [కాంట్రాక్ట్-సమ్మరీ ప్రింటర్‌ను](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) ఉపయోగించండి.
+- **టోకెన్‌కు ఒకే చిరునామా ఉంది.** బ్యాలెన్స్ అప్‌డేట్‌ల కోసం బహుళ ఎంట్రీ పాయింట్లు ఉన్న టోకెన్‌లు చిరునామా ఆధారంగా అంతర్గత బుక్‌కీపింగ్‌ను విచ్ఛిన్నం చేయగలవు (ఉదాహరణకు, `balances[token_address][msg.sender]` వాస్తవ బ్యాలెన్స్‌ను ప్రతిబింబించకపోవచ్చు).
+
+## యజమాని అధికారాలు {#owner-privileges}
+
+- **టోకెన్ అప్‌గ్రేడ్ చేయదగినది కాదు.** అప్‌గ్రేడ్ చేయగల కాంట్రాక్ట్‌లు కాలక్రమేణా వాటి నియమాలను మార్చవచ్చు. కాంట్రాక్ట్ అప్‌గ్రేడ్ చేయదగినదో లేదో నిర్ధారించడానికి Slither యొక్క [హ్యూమన్-సమ్మరీ ప్రింటర్‌ను](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) ఉపయోగించండి.
+- **యజమానికి పరిమిత మింటింగ్ సామర్థ్యాలు ఉన్నాయి.** హానికరమైన లేదా రాజీపడిన యజమానులు మింటింగ్ సామర్థ్యాలను దుర్వినియోగం చేయవచ్చు. మింటింగ్ సామర్థ్యాలను సమీక్షించడానికి Slither యొక్క [హ్యూమన్-సమ్మరీ ప్రింటర్‌ను](https://github.com/crytic/slither/wiki/Printer-documentation#contract-summary) ఉపయోగించండి మరియు కోడ్‌ను మాన్యువల్‌గా సమీక్షించడాన్ని పరిగణించండి.
+- **టోకెన్ పాజ్ చేయదగినది కాదు.** హానికరమైన లేదా రాజీపడిన యజమానులు పాజ్ చేయగల టోకెన్‌లపై ఆధారపడిన కాంట్రాక్ట్‌లను ట్రాప్ చేయవచ్చు. పాజ్ చేయగల కోడ్‌ను చేతితో గుర్తించండి.
+- **యజమాని కాంట్రాక్ట్‌ను బ్లాక్‌లిస్ట్ చేయలేరు.** హానికరమైన లేదా రాజీపడిన యజమానులు బ్లాక్‌లిస్ట్ ఉన్న టోకెన్‌లపై ఆధారపడిన కాంట్రాక్ట్‌లను ట్రాప్ చేయవచ్చు. బ్లాక్‌లిస్టింగ్ ఫీచర్లను చేతితో గుర్తించండి.
+- **టోకెన్ వెనుక ఉన్న బృందం సుపరిచితం మరియు దుర్వినియోగానికి బాధ్యత వహించగలదు.** అనామక డెవలప్‌మెంట్ బృందాలతో ఉన్న కాంట్రాక్ట్‌లు లేదా చట్టపరమైన ఆశ్రయాలలో నివసించే వాటికి ఉన్నత స్థాయి సమీక్ష అవసరం.
+
+## టోకెన్ కొరత {#token-scarcity}
+
+టోకెన్ కొరత సమస్యల కోసం సమీక్షలకు మాన్యువల్ సమీక్ష అవసరం. ఈ పరిస్థితుల కోసం తనిఖీ చేయండి:
+
+- **ఏ వినియోగదారుడు కూడా సరఫరాలో ఎక్కువ భాగాన్ని కలిగి ఉండరు.** కొద్దిమంది వినియోగదారులు చాలా టోకెన్‌లను కలిగి ఉంటే, వారు టోకెన్ పునఃపంపిణీ ఆధారంగా కార్యకలాపాలను ప్రభావితం చేయగలరు.
+- **మొత్తం సరఫరా సరిపోతుంది.** తక్కువ మొత్తం సరఫరాతో ఉన్న టోకెన్‌లను సులభంగా మానిప్యులేట్ చేయవచ్చు.
+- **టోకెన్‌లు కొన్ని ఎక్స్చేంజ్‌ల కంటే ఎక్కువ వాటిలో ఉన్నాయి.** అన్ని టోకెన్‌లు ఒకే ఎక్స్చేంజ్‌లో ఉంటే, ఎక్స్చేంజ్ యొక్క రాజీ టోకెన్‌పై ఆధారపడిన కాంట్రాక్ట్‌ను రాజీ చేయగలదు.
+- **వినియోగదారులు పెద్ద నిధులు లేదా ఫ్లాష్ లోన్‌లతో సంబంధం ఉన్న ప్రమాదాలను అర్థం చేసుకుంటారు.** టోకెన్ బ్యాలెన్స్‌పై ఆధారపడిన కాంట్రాక్ట్‌లు పెద్ద నిధులతో ఉన్న దాడి చేసేవారిని లేదా ఫ్లాష్ లోన్‌ల ద్వారా జరిగే దాడులను జాగ్రత్తగా పరిగణనలోకి తీసుకోవాలి.
+- **టోకెన్ ఫ్లాష్ మింటింగ్‌ను అనుమతించదు**. ఫ్లాష్ మింటింగ్ బ్యాలెన్స్ మరియు మొత్తం సరఫరాలో గణనీయమైన మార్పులకు దారితీయవచ్చు, దీనికి టోకెన్ ఆపరేషన్‌లో కఠినమైన మరియు సమగ్రమైన ఓవర్‌ఫ్లో తనిఖీలు అవసరం.
diff --git a/public/content/translations/te/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md b/public/content/translations/te/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
new file mode 100644
index 00000000000..88a362ea56d
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/transfers-and-approval-of-erc-20-tokens-from-a-solidity-smart-contract/index.md
@@ -0,0 +1,320 @@
+---
+title: "సాలిడిటీ స్మార్ట్ కాంట్రాక్ట్ నుండి ERC-20 టోకెన్ల బదిలీలు మరియు ఆమోదం"
+description: "సాలిడిటీని ఉపయోగించి ERC-20 టోకెన్ బదిలీలు మరియు ఆమోదాలను నిర్వహించే DEX స్మార్ట్ కాంట్రాక్ట్‌ను నిర్మించండి."
+author: "jdourlens"
+tags:
+  [
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "టోకెన్లు",
+    "దృఢత్వం",
+    "erc-20"
+  ]
+skill: intermediate
+lang: te
+published: 2020-04-07
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/transfers-and-approval-or-erc20-tokens-from-a-solidity-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+మునుపటి ట్యుటోరియల్‌లో మేము ఇతీరియము బ్లాక్‌చైన్‌లో [సాలిడిటీలో ERC-20 టోకెన్ యొక్క అనాటమీ](/developers/tutorials/understand-the-erc-20-token-smart-contract/) గురించి అధ్యయనం చేశాము. ఈ ఆర్టికల్‌లో మనం సాలిడిటీ భాషను ఉపయోగించి ఒక టోకెన్‌తో ఇంటరాక్ట్ అవ్వడానికి స్మార్ట్ కాంట్రాక్ట్‌ను ఎలా ఉపయోగించవచ్చో చూద్దాం.
+
+ఈ స్మార్ట్ కాంట్రాక్ట్ కోసం, మేము ఒక నిజమైన డమ్మీ వికేంద్రీకృత మార్పిడిని సృష్టిస్తాము, ఇక్కడ ఒక వినియోగదారుడు మన కొత్తగా డిప్లాయ్ చేసిన [ERC-20 టోకెన్](/developers/docs/standards/tokens/erc-20/) కోసం ఈథర్‌ను ట్రేడ్ చేయవచ్చు.
+
+ఈ ట్యుటోరియల్ కోసం మేము మునుపటి ట్యుటోరియల్‌లో రాసిన కోడ్‌ను బేస్‌గా ఉపయోగిస్తాము. మన DEX దాని కన్‌స్ట్రక్టర్‌లో కాంట్రాక్ట్ యొక్క ఇన్‌స్టాన్స్‌ను ఇన్‌స్టాన్షియేట్ చేస్తుంది మరియు ఈ క్రింది ఆపరేషన్‌లను నిర్వహిస్తుంది:
+
+- టోకెన్లను ఈథర్‌కు మార్పిడి చేయడం
+- ఈథర్‌ను టోకెన్లకు మార్పిడి చేయడం
+
+మనం మన సాధారణ ERC20 కోడ్‌బేస్‌ను జోడించడం ద్వారా మన వికేంద్రీకృత మార్పిడి కోడ్‌ను ప్రారంభిస్తాము:
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract ERC20Basic is IERC20 {
+
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+
+    mapping(address => uint256) balances;
+
+    mapping(address => mapping (address => uint256)) allowed;
+
+    uint256 totalSupply_ = 10 ether;
+
+
+   constructor() {
+	balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public override view returns (uint256) {
+	return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public override view returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender]-numTokens;
+        balances[receiver] = balances[receiver]+numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public override view returns (uint) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner]-numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
+        balances[buyer] = balances[buyer]+numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}
+
+
+```
+
+మన కొత్త DEX స్మార్ట్ కాంట్రాక్ట్ ERC-20 ని డిప్లాయ్ చేస్తుంది మరియు సరఫరా చేయబడినవన్నీ పొందుతుంది:
+
+```solidity
+contract DEX {
+
+    IERC20 public token;
+
+    event Bought(uint256 amount);
+    event Sold(uint256 amount);
+
+    constructor() {
+        token = new ERC20Basic();
+    }
+
+    function buy() payable public {
+        // TODO
+    }
+
+    function sell(uint256 amount) public {
+        // TODO
+    }
+
+}
+```
+
+కాబట్టి ఇప్పుడు మనకు మన DEX ఉంది మరియు దానిలో అందుబాటులో ఉన్న టోకెన్ రిజర్వ్ అంతా ఉంది. కాంట్రాక్ట్ రెండు ఫంక్షన్‌లను కలిగి ఉంది:
+
+- `buy`: వినియోగదారుడు ఈథర్‌ను పంపి బదులుగా టోకెన్‌లను పొందవచ్చు
+- `sell`: వినియోగదారుడు ఈథర్‌ను తిరిగి పొందడానికి టోకెన్‌లను పంపాలని నిర్ణయించుకోవచ్చు
+
+## కొనుగోలు ఫంక్షన్ {#the-buy-function}
+
+కొనుగోలు ఫంక్షన్‌ను కోడ్ చేద్దాం. మనం ముందుగా సందేశంలో ఎంత ఈథర్ ఉందో తనిఖీ చేయాలి మరియు కాంట్రాక్ట్‌లలో తగినన్ని టోకెన్లు ఉన్నాయని, అలాగే సందేశంలో కొంత ఈథర్ ఉందని ధృవీకరించాలి. కాంట్రాక్ట్‌లో తగినన్ని టోకెన్‌లు ఉంటే, అది వినియోగదారుడికి టోకెన్‌ల సంఖ్యను పంపి, `Bought` ఈవెంట్‌ను విడుదల చేస్తుంది.
+
+లోపం సంభవించినప్పుడు మనం రిక్వైర్ ఫంక్షన్‌ను కాల్ చేస్తే, పంపిన ఈథర్ నేరుగా రివర్ట్ చేయబడి వినియోగదారుడికి తిరిగి ఇవ్వబడుతుందని గమనించండి.
+
+విషయాలను సరళంగా ఉంచడానికి, మనం 1 టోకెన్‌కు 1 వెయిని మార్పిడి చేస్తాము.
+
+```solidity
+function buy() payable public {
+    uint256 amountTobuy = msg.value;
+    uint256 dexBalance = token.balanceOf(address(this));
+    require(amountTobuy > 0, "మీరు కొంత ఈథర్‌ను పంపాలి");
+    require(amountTobuy <= dexBalance, "రిజర్వ్‌లో తగినన్ని టోకెన్‌లు లేవు");
+    token.transfer(msg.sender, amountTobuy);
+    emit Bought(amountTobuy);
+}
+```
+
+కొనుగోలు విజయవంతం అయిన సందర్భంలో, మనం లావాదేవీలో రెండు ఈవెంట్‌లను చూడాలి: టోకెన్ `Transfer` మరియు `Bought` ఈవెంట్.
+
+![లావాదేవీలో రెండు ఈవెంట్‌లు: బదిలీ మరియు కొనుగోలు](./transfer-and-bought-events.png)
+
+## అమ్మకం ఫంక్షన్ {#the-sell-function}
+
+అమ్మకానికి బాధ్యత వహించే ఫంక్షన్, అప్రూవ్ ఫంక్షన్‌ను ముందుగానే కాల్ చేయడం ద్వారా వినియోగదారుడు మొత్తాన్ని ఆమోదించడాన్ని కోరుతుంది. బదిలీని ఆమోదించడానికి DEX ద్వారా ఇన్‌స్టాన్షియేట్ చేయబడిన ERC20Basic టోకెన్‌ను వినియోగదారుడు కాల్ చేయాల్సి ఉంటుంది. DEX `token` అని పిలవబడే ERC20Basic కాంట్రాక్ట్‌ను ఎక్కడ డిప్లాయ్ చేసిందో ఆ చిరునామాను తిరిగి పొందడానికి, ముందుగా DEX కాంట్రాక్ట్ యొక్క `token()` ఫంక్షన్‌ను కాల్ చేయడం ద్వారా ఇది సాధించవచ్చు. ఆ తర్వాత మనం మన సెషన్‌లో ఆ కాంట్రాక్ట్ యొక్క ఒక ఇన్‌స్టాన్స్‌ను సృష్టించి, దాని `approve` ఫంక్షన్‌ను కాల్ చేస్తాము. అప్పుడు మనం DEX యొక్క `sell` ఫంక్షన్‌ను కాల్ చేసి, మన టోకెన్‌లను తిరిగి ఈథర్ కోసం స్వాప్ చేయగలుగుతాము. ఉదాహరణకు, ఒక ఇంటరాక్టివ్ బ్రౌనీ సెషన్‌లో ఇది ఇలా కనిపిస్తుంది:
+
+```python
+#### ఇంటరాక్టివ్ బ్రౌనీ కన్సోల్‌లో పైథాన్...
+
+# DEX ని డిప్లాయ్ చేయండి
+dex = DEX.deploy({'from':account1})
+
+# టోకెన్ కోసం ఈథర్‌ను స్వాప్ చేయడానికి బై ఫంక్షన్‌ను కాల్ చేయండి
+# 1e18 అనేది వెయిలో సూచించబడిన 1 ఈథర్
+dex.buy({'from': account2, 1e18})
+
+# ERC20 టోకెన్ కోసం డిప్లాయ్‌మెంట్ చిరునామాను పొందండి
+# ఇది DEX కాంట్రాక్ట్ సృష్టి సమయంలో డిప్లాయ్ చేయబడింది
+# dex.token() టోకెన్ కోసం డిప్లాయ్ చేయబడిన చిరునామాను తిరిగి ఇస్తుంది
+token = ERC20Basic.at(dex.token())
+
+# టోకెన్ యొక్క అప్రూవ్ ఫంక్షన్‌ను కాల్ చేయండి
+# డెక్స్ చిరునామాను స్పేండర్‌గా ఆమోదించండి
+# మరియు అది మీ టోకెన్‌లలో ఎన్ని ఖర్చు చేయడానికి అనుమతించబడిందో
+token.approve(dex.address, 3e18, {'from':account2})
+
+```
+
+ఆ తర్వాత సెల్ ఫంక్షన్‌ను కాల్ చేసినప్పుడు, కాలర్ చిరునామా నుండి కాంట్రాక్ట్ చిరునామాకు బదిలీ విజయవంతమైందో లేదో తనిఖీ చేసి, ఆపై ఈథర్‌లను తిరిగి కాలర్ చిరునామాకు పంపుతాము.
+
+```solidity
+function sell(uint256 amount) public {
+    require(amount > 0, "మీరు కనీసం కొన్ని టోకెన్‌లను అమ్మాలి");
+    uint256 allowance = token.allowance(msg.sender, address(this));
+    require(allowance >= amount, "టోకెన్ అలవెన్సును తనిఖీ చేయండి");
+    token.transferFrom(msg.sender, address(this), amount);
+    payable(msg.sender).transfer(amount);
+    emit Sold(amount);
+}
+```
+
+అన్నీ సరిగ్గా పనిచేస్తే, మీరు లావాదేవీలో 2 ఈవెంట్‌లను (`Transfer` మరియు `Sold`) చూడాలి మరియు మీ టోకెన్ బ్యాలెన్స్ మరియు ఈథర్ బ్యాలెన్స్ నవీకరించబడతాయి.
+
+![లావాదేవీలో రెండు ఈవెంట్‌లు: బదిలీ మరియు అమ్మకం](./transfer-and-sold-events.png)
+
+<Divider />
+
+ఈ ట్యుటోరియల్ నుండి మనం ఒక ERC-20 టోకెన్ యొక్క బ్యాలెన్స్ మరియు అలవెన్సును ఎలా తనిఖీ చేయాలో, అలాగే ఇంటర్‌ఫేస్‌ను ఉపయోగించి ఒక ERC20 స్మార్ట్ కాంట్రాక్ట్ యొక్క `Transfer` మరియు `TransferFrom`ను ఎలా కాల్ చేయాలో చూశాము.
+
+మీరు ఒక లావాదేవీ చేసిన తర్వాత, మీ కాంట్రాక్ట్‌కు చేయబడిన [లావాదేవీల కోసం వేచి ఉండి వాటి వివరాలను పొందడానికి](https://ethereumdev.io/waiting-for-a-transaction-to-be-mined-on-ethereum-with-js/) మా వద్ద ఒక జావాస్క్రిప్ట్ ట్యుటోరియల్ ఉంది, మరియు మీ వద్ద ABI ఉన్నంత వరకు టోకెన్ బదిలీలు లేదా మరే ఇతర ఈవెంట్‌ల ద్వారా ఉత్పత్తి చేయబడిన [ఈవెంట్‌లను డీకోడ్ చేయడానికి ఒక ట్యుటోరియల్](https://ethereumdev.io/how-to-decode-event-logs-in-javascript-using-abi-decoder/) కూడా ఉంది.
+
+ట్యుటోరియల్ కోసం పూర్తి కోడ్ ఇక్కడ ఉంది:
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract ERC20Basic is IERC20 {
+
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+
+    mapping(address => uint256) balances;
+
+    mapping(address => mapping (address => uint256)) allowed;
+
+    uint256 totalSupply_ = 10 ether;
+
+
+   constructor() {
+	balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public override view returns (uint256) {
+	return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public override view returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender]-numTokens;
+        balances[receiver] = balances[receiver]+numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public override view returns (uint) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner]-numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
+        balances[buyer] = balances[buyer]+numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}
+
+
+contract DEX {
+
+    event Bought(uint256 amount);
+    event Sold(uint256 amount);
+
+
+    IERC20 public token;
+
+    constructor() {
+        token = new ERC20Basic();
+    }
+
+    function buy() payable public {
+        uint256 amountTobuy = msg.value;
+        uint256 dexBalance = token.balanceOf(address(this));
+        require(amountTobuy > 0, "మీరు కొంత ఈథర్‌ను పంపాలి");
+        require(amountTobuy <= dexBalance, "రిజర్వ్‌లో తగినన్ని టోకెన్‌లు లేవు");
+        token.transfer(msg.sender, amountTobuy);
+        emit Bought(amountTobuy);
+    }
+
+    function sell(uint256 amount) public {
+        require(amount > 0, "మీరు కనీసం కొన్ని టోకెన్‌లను అమ్మాలి");
+        uint256 allowance = token.allowance(msg.sender, address(this));
+        require(allowance >= amount, "టోకెన్ అలవెన్సును తనిఖీ చేయండి");
+        token.transferFrom(msg.sender, address(this), amount);
+        payable(msg.sender).transfer(amount);
+        emit Sold(amount);
+    }
+
+}
+```
diff --git a/public/content/translations/te/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md b/public/content/translations/te/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
new file mode 100644
index 00000000000..d4171e84745
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/understand-the-erc-20-token-smart-contract/index.md
@@ -0,0 +1,183 @@
+---
+title: "ERC-20 టోకెన్ స్మార్ట్ కాంట్రాక్టును అర్థం చేసుకోండి"
+description: "పూర్తి Solidity స్మార్ట్ కాంట్రాక్టు ఉదాహరణ మరియు వివరణతో ERC-20 టోకెన్ ప్రామాణికాన్ని ఎలా అమలు చేయాలో తెలుసుకోండి."
+author: "jdourlens"
+tags:
+  [
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "టోకెన్లు",
+    "దృఢత్వం",
+    "erc-20"
+  ]
+skill: beginner
+lang: te
+published: 2020-04-05
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/understand-the-erc20-token-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+Ethereumలో అత్యంత ముఖ్యమైన [స్మార్ట్ కాంట్రాక్టు ప్రామాణికాలలో](/developers/docs/standards/) ఒకటి [ERC-20](/developers/docs/standards/tokens/erc-20/)గా పిలువబడుతుంది, ఇది ఫంగిబుల్ టోకెన్ అమలుల కోసం Ethereum బ్లాక్ చైనులో అన్ని స్మార్ట్ కాంట్రాక్టుల కొరకు ఉపయోగించే సాంకేతిక ప్రామాణికంగా ఉద్భవించింది.
+
+అన్ని ఫంగిబుల్ Ethereum టోకెన్‌లు కట్టుబడి ఉండవలసిన సాధారణ నియమాల జాబితాను ERC-20 నిర్వచిస్తుంది. పర్యవసానంగా, ఈ టోకెన్ ప్రామాణికం అన్ని రకాల డెవలపర్‌లకు పెద్ద Ethereum వ్యవస్థలో కొత్త టోకెన్‌లు ఎలా పనిచేస్తాయో ఖచ్చితంగా అంచనా వేయడానికి అధికారం ఇస్తుంది. ఇది డెవలపర్‌ల పనులను సరళతరం చేస్తుంది మరియు సులభతరం చేస్తుంది, ఎందుకంటే టోకెన్ నియమాలను అనుసరిస్తున్నంత వరకు, ప్రతి కొత్త టోకెన్ విడుదలైన ప్రతిసారీ ప్రతి కొత్త ప్రాజెక్ట్‌ను పునరావృతం చేయాల్సిన అవసరం లేదని తెలుసుకుని వారు తమ పనిని కొనసాగించవచ్చు.
+
+ఒక ఇంటర్‌ఫేస్‌గా ఇక్కడ ప్రదర్శించబడింది, ఒక ERC-20 అమలు చేయవలసిన ఫంక్షన్‌లు. ఒక ఇంటర్‌ఫేస్ అంటే ఏమిటో మీకు ఖచ్చితంగా తెలియకపోతే: [Solidityలో OOP ప్రోగ్రామింగ్](https://ethereumdev.io/inheritance-in-solidity-contracts-are-classes/) గురించిన మా కథనాన్ని తనిఖీ చేయండి.
+
+```solidity
+pragma solidity ^0.6.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+```
+
+ప్రతి ఫంక్షన్ దేనికి ఉపయోగపడుతుందో ఇక్కడ ఒక లైన్-ద్వారా-లైన్ వివరణ ఉంది. దీని తర్వాత మేము ERC-20 టోకెన్ యొక్క ఒక సాధారణ అమలును ప్రదర్శిస్తాము.
+
+## గెట్టర్లు {#getters}
+
+```solidity
+function totalSupply() external view returns (uint256);
+```
+
+ఉనికిలో ఉన్న టోకెన్ల మొత్తాన్ని తిరిగి ఇస్తుంది. ఈ ఫంక్షన్ ఒక గెట్టర్ మరియు కాంట్రాక్టు యొక్క స్థితిని సవరించదు. Solidityలో ఫ్లోట్‌లు లేవని గుర్తుంచుకోండి. అందువల్ల చాలా టోకెన్‌లు 18 దశాంశాలను అవలంబిస్తాయి మరియు 1 టోకెన్ కోసం మొత్తం సరఫరా మరియు ఇతర ఫలితాలను 1000000000000000000గా తిరిగి ఇస్తాయి. ప్రతి టోకెన్‌కు 18 దశాంశాలు ఉండవు మరియు టోకెన్‌లతో వ్యవహరించేటప్పుడు మీరు నిజంగా గమనించవలసిన విషయం ఇది.
+
+```solidity
+function balanceOf(address account) external view returns (uint256);
+```
+
+ఒక చిరునామా (`account`) యాజమాన్యంలో ఉన్న టోకెన్ల మొత్తాన్ని తిరిగి ఇస్తుంది. ఈ ఫంక్షన్ ఒక గెట్టర్ మరియు కాంట్రాక్టు యొక్క స్థితిని సవరించదు.
+
+```solidity
+function allowance(address owner, address spender) external view returns (uint256);
+```
+
+ERC-20 ప్రామాణికం ఒక చిరునామా నుండి టోకెన్‌లను తిరిగి పొందగలిగేలా మరొక చిరునామాకు అనుమతి ఇవ్వడానికి ఒక చిరునామాను అనుమతిస్తుంది. `owner` తరపున `spender` ఖర్చు చేయడానికి అనుమతించబడే మిగిలిన టోకెన్‌ల సంఖ్యను ఈ గెట్టర్ తిరిగి ఇస్తుంది. ఈ ఫంక్షన్ ఒక గెట్టర్ మరియు కాంట్రాక్టు యొక్క స్థితిని మార్చదు మరియు డిఫాల్ట్‌గా 0ని తిరిగి ఇవ్వాలి.
+
+## ఫంక్షన్స్ {#functions}
+
+```solidity
+function transfer(address recipient, uint256 amount) external returns (bool);
+```
+
+ఫంక్షన్ కాలర్ చిరునామా (`msg.sender`) నుండి గ్రహీత చిరునామాకు టోకెన్ల `amount`ను తరలిస్తుంది. ఈ ఫంక్షన్ తరువాత నిర్వచించిన `Transfer` ఈవెంట్‌ను వెలువరిస్తుంది. బదిలీ సాధ్యమైతే అది ట్రూ (నిజం) అని తిరిగి ఇస్తుంది.
+
+```solidity
+function approve(address spender, uint256 amount) external returns (bool);
+```
+
+ఫంక్షన్ కాలర్ (`msg.sender`) బ్యాలెన్స్ నుండి `spender` బదిలీ చేయడానికి అనుమతించబడిన `allowance` మొత్తాన్ని సెట్ చేస్తుంది. ఈ ఫంక్షన్ Approval ఈవెంట్‌ను వెలువరిస్తుంది. అనుమతి విజయవంతంగా సెట్ చేయబడిందా లేదా అనేదాన్ని ఫంక్షన్ తిరిగి ఇస్తుంది.
+
+```solidity
+function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+```
+
+అనుమతి యంత్రాంగాన్ని ఉపయోగించి `sender` నుండి `recipient`కి టోకెన్‌ల `amount`ను తరలిస్తుంది. ఆ తర్వాత కాలర్ యొక్క అనుమతి నుండి amount తీసివేయబడుతుంది. ఈ ఫంక్షన్ `Transfer` ఈవెంట్‌ను వెలువరిస్తుంది.
+
+## ఈవెంట్‌లు {#events}
+
+```solidity
+event Transfer(address indexed from, address indexed to, uint256 value);
+```
+
+టోకెన్‌ల మొత్తం (value) `from` చిరునామా నుండి `to` చిరునామాకు పంపబడినప్పుడు ఈ ఈవెంట్ వెలువడుతుంది.
+
+కొత్త టోకెన్‌లను మింటింగ్ చేసే సందర్భంలో, బదిలీ సాధారణంగా `from` 0x00..0000 చిరునామా నుండి ఉంటుంది, అయితే టోకెన్‌లను బర్న్ చేసే సందర్భంలో బదిలీ `to` 0x00..0000 చిరునామాకు ఉంటుంది.
+
+```solidity
+event Approval(address indexed owner, address indexed spender, uint256 value);
+```
+
+`spender` ద్వారా ఉపయోగించబడటానికి `owner` ద్వారా టోకెన్‌ల మొత్తం (`value`) ఆమోదించబడినప్పుడు ఈ ఈవెంట్ వెలువడుతుంది.
+
+## ERC-20 టోకెన్‌ల యొక్క ఒక ప్రాథమిక అమలు {#a-basic-implementation-of-erc-20-tokens}
+
+మీ ERC-20 టోకెన్‌ను ఆధారంగా చేసుకోవడానికి అత్యంత సరళమైన కోడ్ ఇక్కడ ఉంది:
+
+```solidity
+pragma solidity ^0.8.0;
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract ERC20Basic is IERC20 {
+
+    string public constant name = "ERC20Basic";
+    string public constant symbol = "ERC";
+    uint8 public constant decimals = 18;
+
+
+    mapping(address => uint256) balances;
+
+    mapping(address => mapping (address => uint256)) allowed;
+
+    uint256 totalSupply_ = 10 ether;
+
+
+   constructor() {
+	balances[msg.sender] = totalSupply_;
+    }
+
+    function totalSupply() public override view returns (uint256) {
+	return totalSupply_;
+    }
+
+    function balanceOf(address tokenOwner) public override view returns (uint256) {
+        return balances[tokenOwner];
+    }
+
+    function transfer(address receiver, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[msg.sender]);
+        balances[msg.sender] = balances[msg.sender]-numTokens;
+        balances[receiver] = balances[receiver]+numTokens;
+        emit Transfer(msg.sender, receiver, numTokens);
+        return true;
+    }
+
+    function approve(address delegate, uint256 numTokens) public override returns (bool) {
+        allowed[msg.sender][delegate] = numTokens;
+        emit Approval(msg.sender, delegate, numTokens);
+        return true;
+    }
+
+    function allowance(address owner, address delegate) public override view returns (uint) {
+        return allowed[owner][delegate];
+    }
+
+    function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
+        require(numTokens <= balances[owner]);
+        require(numTokens <= allowed[owner][msg.sender]);
+
+        balances[owner] = balances[owner]-numTokens;
+        allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
+        balances[buyer] = balances[buyer]+numTokens;
+        emit Transfer(owner, buyer, numTokens);
+        return true;
+    }
+}
+```
+
+ERC-20 టోకెన్ ప్రామాణికం యొక్క మరొక అద్భుతమైన అమలు [ఓపెన్‌జెప్పెలిన్ ERC-20 అమలు](https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC20).
diff --git a/public/content/translations/te/developers/tutorials/uniswap-v2-annotated-code/index.md b/public/content/translations/te/developers/tutorials/uniswap-v2-annotated-code/index.md
new file mode 100644
index 00000000000..284a1397ff4
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/uniswap-v2-annotated-code/index.md
@@ -0,0 +1,1968 @@
+---
+title: "యూనిస్వాప్-వి2 ఒప్పంద విశ్లేషణ"
+description: "యూనిస్వాప్-వి2 ఒప్పందం ఎలా పనిచేస్తుంది? దీనిని ఆ విధంగా ఎందుకు రాసారు?"
+author: Ori Pomerantz
+tags: [ "దృఢత్వం" ]
+skill: intermediate
+published: 2021-05-01
+lang: te
+---
+
+## పరిచయం {#introduction}
+
+[Uniswap v2](https://app.uniswap.org/whitepaper.pdf) ఏవైనా రెండు ERC-20 టోకెన్ల మధ్య మార్పిడి మార్కెట్ ను సృష్టించగలదు. ఈ వ్యాసంలో మేము ఈ ప్రోటోకాల్‌ను అమలు చేసే ఒప్పందాల కోసం సోర్స్ కోడ్‌ను పరిశీలిస్తాము మరియు అవి ఈ విధంగా ఎందుకు వ్రాయబడ్డాయో చూస్తాము.
+
+### యూనిస్వాప్ ఏమి చేస్తుంది? {#what-does-uniswap-do}
+
+సాధారణంగా, రెండు రకాల వినియోగదారులు ఉంటారు: ద్రవ్యత్వ ప్రదాతలు మరియు వ్యాపారులు.
+
+_ద్రవ్యత్వ ప్రదాతలు_ మార్పిడి చేయగల రెండు టోకెన్‌లతో పూల్‌ను అందిస్తారు (మేము వాటిని **టోకెన్0** మరియు **టోకెన్1** అని పిలుస్తాము). ప్రతిఫలంగా, వారు _ద్రవ్యత్వ టోకెన్_ అని పిలువబడే పూల్ యొక్క పాక్షిక యాజమాన్యాన్ని సూచించే మూడవ టోకెన్‌ను స్వీకరిస్తారు.
+
+_వ్యాపారులు_ ఒక రకమైన టోకెన్‌ను పూల్‌కు పంపి, ద్రవ్యత్వ ప్రదాతలచే అందించబడిన పూల్ నుండి మరొకటి (ఉదాహరణకు, **టోకెన్0** ను పంపి, **టోకెన్1** ను అందుకుంటారు) అందుకుంటారు. పూల్ కలిగి ఉన్న **టోకెన్0**ల మరియు **టోకెన్1**ల సాపేక్ష సంఖ్య ద్వారా మార్పిడి రేటు నిర్ణయించబడుతుంది. అదనంగా, ద్రవ్యత్వ పూల్ కోసం పూల్ ఒక చిన్న శాతాన్ని రివార్డ్‌గా తీసుకుంటుంది.
+
+ద్రవ్యత్వ ప్రదాతలు తమ ఆస్తులను తిరిగి కోరుకున్నప్పుడు వారు పూల్ టోకెన్లను బర్న్ చేయవచ్చు మరియు వారి రివార్డ్ ల వాటాతో సహా వారి టోకెన్లను తిరిగి పొందవచ్చు.
+
+[పూర్తి వివరణ కోసం ఇక్కడ క్లిక్ చేయండి](https://docs.uniswap.org/contracts/v2/concepts/core-concepts/swaps/).
+
+### v2 ఎందుకు? v3 ఎందుకు కాదు? {#why-v2}
+
+[Uniswap v3](https://app.uniswap.org/whitepaper-v3.pdf) అనేది v2 కంటే చాలా క్లిష్టమైన అప్గ్రేడ్. మొదట v2 నేర్చుకుని తర్వాత v3 కి వెళ్లడం సులభం.
+
+### కోర్ ఒప్పందాలు vs పెరిఫెరీ ఒప్పందాలు {#contract-types}
+
+యూనిస్వాప్ v2 రెండు భాగాలుగా విభజించబడింది, ఒక కోర్ మరియు పెరిఫెరీ. ఈ విభజన ఆస్తులను కలిగి ఉన్న కోర్ ఒప్పందాలను, అందువల్ల _సురక్షితంగా_ ఉండవలసి ఉంటుంది, సరళంగా మరియు ఆడిట్ చేయడానికి సులభంగా ఉండటానికి అనుమతిస్తుంది. వ్యాపారులకు అవసరమైన అన్ని అదనపు ఫంక్షనాలిటీని పెరిఫెరీ ఒప్పందాల ద్వారా అందించవచ్చు.
+
+## డేటా మరియు నియంత్రణ ప్రవాహాలు {#flows}
+
+మీరు యూనిస్వాప్ యొక్క మూడు ప్రధాన చర్యలను చేసినప్పుడు జరిగే డేటా మరియు నియంత్రణ ప్రవాహం ఇది:
+
+1. విభిన్న టోకెన్ల మధ్య స్వాప్ చేయండి
+2. మార్కెట్ కు ద్రవ్యత్వం జోడించి, జత మార్పిడి ERC-20 ద్రవ్యత్వ టోకెన్లతో రివార్డ్ పొందండి
+3. ERC-20 ద్రవ్యత్వ టోకెన్లను బర్న్ చేసి, వ్యాపారులకు మార్పిడి చేయడానికి జత మార్పిడి అనుమతించే ERC-20 టోకెన్లను తిరిగి పొందండి
+
+### స్వాప్ {#swap-flow}
+
+ఇది వ్యాపారులు ఉపయోగించే అత్యంత సాధారణ ప్రవాహం:
+
+#### కాలర్ {#caller}
+
+1. స్వాప్ చేయవలసిన మొత్తంలో పెరిఫెరీ ఖాతాకు ఒక భత్యం అందించండి.
+2. పెరిఫెరీ ఒప్పందం యొక్క అనేక స్వాప్ ఫంక్షన్లలో ఒకదానిని కాల్ చేయండి (ETH ప్రమేయం ఉందో లేదో, వ్యాపారి డిపాజిట్ చేయడానికి టోకెన్ల మొత్తాన్ని లేదా తిరిగి పొందడానికి టోకెన్ల మొత్తాన్ని పేర్కొంటాడో లేదో ఆధారపడి ఉంటుంది).
+   ప్రతి స్వాప్ ఫంక్షన్ `పాత్`ను అంగీకరిస్తుంది, వెళ్లాల్సిన మార్పిడుల యొక్క శ్రేణి.
+
+#### పెరిఫెరీ ఒప్పందంలో (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02-sol}
+
+3. మార్గం వెంట ప్రతి మార్పిడిలో వర్తకం చేయవలసిన మొత్తాలను గుర్తించండి.
+4. మార్గంపై మళ్ళింపులు. మార్గం వెంట ప్రతి మార్పిడికి ఇది ఇన్‌పుట్ టోకెన్‌ను పంపుతుంది, ఆపై మార్పిడి యొక్క `swap` ఫంక్షన్‌ను పిలుస్తుంది.
+   చాలా సందర్భాల్లో టోకెన్ల కోసం గమ్యస్థానం చిరునామా మార్గంలో తదుపరి జత మార్పిడి. తుది మార్పిడిలో అది వ్యాపారి అందించిన చిరునామా.
+
+#### కోర్ ఒప్పందంలో (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. కోర్ ఒప్పందం మోసం చేయబడలేదని మరియు స్వాప్ తర్వాత తగినంత ద్రవ్యతను కొనసాగించగలదని ధృవీకరించండి.
+
+6. తెలిసిన నిల్వలకు అదనంగా మనకు ఎన్ని అదనపు టోకెన్లు ఉన్నాయో చూడండి. ఆ మొత్తం మార్పిడి కోసం మేము స్వీకరించిన ఇన్‌పుట్ టోకెన్ల సంఖ్య.
+7. అవుట్పుట్ టోకెన్లను గమ్యస్థానానికి పంపండి.
+8. నిల్వ మొత్తాలను అప్డేట్ చేయడానికి `_update` ని కాల్ చేయండి
+
+#### పెరిఫెరీ ఒప్పందానికి తిరిగి (UniswapV2Router02.sol) {#back-in-the-periphery-contract-uniswapv2router02-sol}
+
+9. ఏవైనా అవసరమైన శుభ్రతను నిర్వహించండి (ఉదాహరణకు, వ్యాపారికి పంపడానికి ETH ను తిరిగి పొందడానికి WETH టోకెన్లను బర్న్ చేయండి)
+
+### ద్రవ్యతను జోడించండి {#add-liquidity-flow}
+
+#### కాలర్ {#caller-2}
+
+1. ద్రవ్యత్వ పూల్ కు జోడించవలసిన మొత్తాలలో పెరిఫెరీ ఖాతాకు ఒక భత్యం అందించండి.
+2. పెరిఫెరీ ఒప్పందం యొక్క `addLiquidity` ఫంక్షన్లలో ఒకదానిని కాల్ చేయండి.
+
+#### పెరిఫెరీ ఒప్పందంలో (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-2}
+
+3. అవసరమైతే కొత్త జత మార్పిడిని సృష్టించండి
+4. ఒకవేళ ప్రస్తుతం ఒక జత మార్పిడి ఉంటే, జోడించడానికి టోకెన్ల మొత్తాన్ని లెక్కించండి. ఇది రెండు టోకెన్లకు ఒకేలాంటి విలువగా ఉండాలి, కాబట్టి కొత్త టోకెన్లకు మరియు ప్రస్తుతం ఉన్న టోకెన్లకు ఒకే నిష్పత్తి.
+5. మొత్తాలు ఆమోదయోగ్యమైనవా అని తనిఖీ చేయండి (కాలర్లు ఒక కనీస మొత్తాన్ని పేర్కొనవచ్చు, దాని కంటే తక్కువ ద్రవ్యతను జోడించడానికి ఇష్టపడరు)
+6. కోర్ ఒప్పందాన్ని కాల్ చేయండి.
+
+#### కోర్ ఒప్పందంలో (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}
+
+7. ద్రవ్యత్వ టోకెన్లను మింట్ చేసి, వాటిని కాలర్ కు పంపండి
+8. నిల్వ మొత్తాలను అప్డేట్ చేయడానికి `_update` ని కాల్ చేయండి
+
+### ద్రవ్యతను తొలగించండి {#remove-liquidity-flow}
+
+#### కాలర్ {#caller-3}
+
+1. అండర్లయింగ్ టోకెన్ల మార్పిడి కోసం బర్న్ చేయవలసిన ద్రవ్యత్వ టోకెన్ల భత్యంతో పెరిఫెరీ ఖాతాను అందించండి.
+2. పెరిఫెరీ ఒప్పందం యొక్క `removeLiquidity` ఫంక్షన్లలో ఒకదానిని కాల్ చేయండి.
+
+#### పెరిఫెరీ ఒప్పందంలో (UniswapV2Router02.sol) {#in-the-periphery-contract-uniswapv2router02sol-3}
+
+3. ద్రవ్యత్వ టోకెన్లను జత మార్పిడికి పంపండి
+
+#### కోర్ ఒప్పందంలో (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-3}
+
+4. గమ్యస్థాన చిరునామాకు బర్న్ చేయబడిన టోకెన్ల నిష్పత్తిలో అండర్లయింగ్ టోకెన్లను పంపండి. ఉదాహరణకు, పూల్ లో 1000 ఎ టోకెన్లు, 500 బి టోకెన్లు మరియు 90 ద్రవ్యత్వ టోకెన్లు ఉంటే, మరియు మనం బర్న్ చేయడానికి 9 టోకెన్లను స్వీకరిస్తే, మనం ద్రవ్యత్వ టోకెన్లలో 10% బర్న్ చేస్తున్నాము, కాబట్టి మనం వినియోగదారునికి 100 ఎ టోకెన్లు మరియు 50 బి టోకెన్లు తిరిగి పంపుతాము.
+5. ద్రవ్యత్వ టోకెన్లను బర్న్ చేయండి
+6. నిల్వ మొత్తాలను అప్డేట్ చేయడానికి `_update` ని కాల్ చేయండి
+
+## కోర్ ఒప్పందాలు {#core-contracts}
+
+ఇవి ద్రవ్యతను కలిగి ఉన్న సురక్షిత ఒప్పందాలు.
+
+### UniswapV2Pair.sol {#UniswapV2Pair}
+
+[ఈ ఒప్పందం](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol) టోకెన్లను మార్పిడి చేసే అసలు పూల్ ను అమలు చేస్తుంది. ఇది కోర్ యూనిస్వాప్ ఫంక్షనాలిటీ.
+
+```solidity
+pragma solidity =0.5.16;
+
+import './interfaces/IUniswapV2Pair.sol';
+import './UniswapV2ERC20.sol';
+import './libraries/Math.sol';
+import './libraries/UQ112x112.sol';
+import './interfaces/IERC20.sol';
+import './interfaces/IUniswapV2Factory.sol';
+import './interfaces/IUniswapV2Callee.sol';
+```
+
+ఒప్పందం అమలు చేసే కారణంగా (`IUniswapV2Pair` మరియు `UniswapV2ERC20`) లేదా అవి అమలు చేసే ఒప్పందాలను పిలిచే కారణంగా, ఒప్పందానికి తెలిసి ఉండవలసిన అన్ని ఇంటర్ఫేస్లు ఇవి.
+
+```solidity
+contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
+```
+
+ఈ ఒప్పందం `UniswapV2ERC20` నుండి వారసత్వం పొందుతుంది, ఇది ద్రవ్యత్వ టోకెన్ల కోసం ERC-20 ఫంక్షన్లను అందిస్తుంది.
+
+```solidity
+    using SafeMath  for uint;
+```
+
+ఓవర్ఫ్లో మరియు అండర్ఫ్లోలను నివారించడానికి [సేఫ్ మాథ్ లైబ్రరీ](https://docs.openzeppelin.com/contracts/2.x/api/math) ఉపయోగించబడుతుంది. ఇది ముఖ్యం ఎందుకంటే లేకపోతే మనం `-1` విలువ ఉండవలసిన పరిస్థితిలో ముగుస్తాము, కానీ బదులుగా `2^256-1` ఉంటుంది.
+
+```solidity
+    using UQ112x112 for uint224;
+```
+
+పూల్ ఒప్పందంలోని చాలా గణనలకు భిన్నాలు అవసరం. అయినప్పటికీ, భిన్నాలు EVM ద్వారా మద్దతు ఇవ్వబడవు.
+యూనిస్వాప్ కనుగొన్న పరిష్కారం 224 బిట్ విలువలను ఉపయోగించడం, పూర్ణాంక భాగం కోసం 112 బిట్స్ మరియు భిన్నం కోసం 112 బిట్స్. కాబట్టి `1.0` ను `2^112` గా, `1.5` ను `2^112 + 2^111` గా మొదలైనవిగా సూచిస్తారు.
+
+ఈ లైబ్రరీ గురించి మరిన్ని వివరాలు [పత్రంలో తరువాత](#FixedPoint) అందుబాటులో ఉన్నాయి.
+
+#### చరరాశులు {#pair-vars}
+
+```solidity
+    uint public constant MINIMUM_LIQUIDITY = 10**3;
+```
+
+సున్నాతో విభజన సందర్భాలను నివారించడానికి, ఎల్లప్పుడూ ఉండే కనీస సంఖ్యలో ద్రవ్యత్వ టోకెన్లు ఉన్నాయి (కానీ ఖాతా సున్నా యాజమాన్యంలో ఉంటాయి). ఆ సంఖ్య **MINIMUM_LIQUIDITY**, వెయ్యి.
+
+```solidity
+    bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
+```
+
+ఇది ERC-20 బదిలీ ఫంక్షన్ కోసం ABI సెలెక్టర్. ఇది రెండు టోకెన్ ఖాతాలలో ERC-20 టోకెన్లను బదిలీ చేయడానికి ఉపయోగించబడుతుంది.
+
+```solidity
+    address public factory;
+```
+
+ఈ పూల్ ను సృష్టించిన ఫ్యాక్టరీ ఒప్పందం ఇది. ప్రతి పూల్ రెండు ERC-20 టోకెన్ల మధ్య మార్పిడి, ఫ్యాక్టరీ ఈ పూల్స్ అన్నింటినీ కలిపే ఒక కేంద్ర బిందువు.
+
+```solidity
+    address public token0;
+    address public token1;
+```
+
+ఈ పూల్ ద్వారా మార్పిడి చేయగల రెండు రకాల ERC-20 టోకెన్ల కోసం ఒప్పందాల చిరునామాలు ఇవి.
+
+```solidity
+    uint112 private reserve0;           // ఒకే నిల్వ స్థానాన్ని ఉపయోగిస్తుంది, getReserves ద్వారా యాక్సెస్ చేయవచ్చు
+    uint112 private reserve1;           // ఒకే నిల్వ స్థానాన్ని ఉపయోగిస్తుంది, getReserves ద్వారా యాక్సెస్ చేయవచ్చు
+```
+
+ప్రతి టోకెన్ రకం కోసం పూల్ కలిగి ఉన్న నిల్వలు. మేము రెండూ ఒకే విలువను సూచిస్తాయని ఊహిస్తాము, కాబట్టి ప్రతి టోకెన్0 విలువ reserve1/reserve0 టోకెన్1 లు.
+
+```solidity
+    uint32  private blockTimestampLast; // ఒకే నిల్వ స్థానాన్ని ఉపయోగిస్తుంది, getReserves ద్వారా యాక్సెస్ చేయవచ్చు
+```
+
+ఒక మార్పిడి జరిగిన చివరి బ్లాక్ కోసం టైమ్స్టాంప్, కాలక్రమేణా మార్పిడి రేట్లను ట్రాక్ చేయడానికి ఉపయోగించబడుతుంది.
+
+Ethereum ఒప్పందాల యొక్క అతిపెద్ద గ్యాస్ ఖర్చులలో ఒకటి నిల్వ, ఇది ఒప్పందం యొక్క ఒక కాల్ నుండి మరొక దానికి నిలుస్తుంది. ప్రతి నిల్వ కణం 256 బిట్స్ పొడవు ఉంటుంది. కాబట్టి మూడు వేరియబుల్స్, `reserve0`, `reserve1`, మరియు `blockTimestampLast`, ఒకే నిల్వ విలువ ఈ మూడింటిని చేర్చగల విధంగా కేటాయించబడ్డాయి (112+112+32=256).
+
+```solidity
+    uint public price0CumulativeLast;
+    uint public price1CumulativeLast;
+```
+
+ఈ వేరియబుల్స్ ప్రతి టోకెన్ కోసం సంచిత ఖర్చులను కలిగి ఉంటాయి (ప్రతి ఒక్కటి మరొకదాని పరంగా). కాలక్రమేణా సగటు మార్పిడి రేటును లెక్కించడానికి వాటిని ఉపయోగించవచ్చు.
+
+```solidity
+    uint public kLast; // reserve0 * reserve1, అత్యంత ఇటీవలి ద్రవ్యత్వ సంఘటన తర్వాత వెంటనే
+```
+
+టోకెన్0 మరియు టోకెన్1 మధ్య మార్పిడి రేటుపై జత మార్పిడి నిర్ణయించే విధానం ట్రేడ్ల సమయంలో రెండు నిల్వల యొక్క గుణకారాన్ని స్థిరంగా ఉంచడం. `kLast` ఈ విలువ. ఒక ద్రవ్యత్వ ప్రదాత టోకెన్లను డిపాజిట్ చేసినప్పుడు లేదా ఉపసంహరించుకున్నప్పుడు ఇది మారుతుంది, మరియు 0.3% మార్కెట్ రుసుము కారణంగా ఇది కొద్దిగా పెరుగుతుంది.
+
+ఇక్కడ ఒక సాధారణ ఉదాహరణ. గమనించండి, సరళత కోసం పట్టికలో దశాంశ బిందువు తర్వాత మూడు అంకెలు మాత్రమే ఉన్నాయి, మరియు మేము 0.3% ట్రేడింగ్ రుసుమును విస్మరిస్తాము కాబట్టి సంఖ్యలు ఖచ్చితమైనవి కావు.
+
+| సంఘటన                                                                         |                    నిల్వ0 |                    నిల్వ1 | నిల్వ0 \* నిల్వ1 | సగటు మార్పిడి రేటు (టోకెన్1 / టోకెన్0) |
+| ----------------------------------------------------------------------------- | ------------------------: | ------------------------: | ---------------: | --------------------------------------------------------- |
+| ప్రారంభ సెటప్                                                                 | 1,000.000 | 1,000.000 |        1,000,000 |                                                           |
+| వ్యాపారి A 50 టోకెన్0 ను 47.619 టోకెన్1 కోసం స్వాప్ చేస్తాడు  | 1,050.000 |   952.381 |        1,000,000 | 0.952                                     |
+| వ్యాపారి B 10 టోకెన్0 ను 8.984 టోకెన్1 కోసం స్వాప్ చేస్తాడు   | 1,060.000 |   943.396 |        1,000,000 | 0.898                                     |
+| వ్యాపారి C 40 టోకెన్0 ను 34.305 టోకెన్1 కోసం స్వాప్ చేస్తాడు  | 1,100.000 |   909.090 |        1,000,000 | 0.858                                     |
+| వ్యాపారి D 100 టోకెన్1 ను 109.01 టోకెన్0 కోసం స్వాప్ చేస్తాడు |   990.990 | 1,009.090 |        1,000,000 | 0.917                                     |
+| వ్యాపారి E 10 టోకెన్0 ను 10.079 టోకెన్1 కోసం స్వాప్ చేస్తాడు  | 1,000.990 |   999.010 |        1,000,000 | 1.008                                     |
+
+వ్యాపారులు టోకెన్0 ను ఎక్కువగా అందించే కొద్దీ, టోకెన్1 యొక్క సాపేక్ష విలువ పెరుగుతుంది మరియు సరఫరా మరియు డిమాండ్ ఆధారంగా దీనికి విరుద్ధంగా ఉంటుంది.
+
+#### లాక్ {#pair-lock}
+
+```solidity
+    uint private unlocked = 1;
+```
+
+[పునఃప్రవేశ దుర్వినియోగం](https://medium.com/coinmonks/ethernaut-lvl-10-re-entrancy-walkthrough-how-to-abuse-execution-ordering-and-reproduce-the-dao-7ec88b912c14) ఆధారంగా ఉండే భద్రతా దుర్బలత్వాల యొక్క ఒక తరగతి ఉంది. యూనిస్వాప్ అనధికారిక ERC-20 టోకెన్లను బదిలీ చేయవలసి ఉంటుంది, అంటే వాటిని పిలిచే యూనిస్వాప్ మార్కెట్ ను దుర్వినియోగం చేయడానికి ప్రయత్నించే ERC-20 ఒప్పందాలను పిలవడం.
+ఒప్పందంలో భాగంగా `unlocked` వేరియబుల్ ను కలిగి ఉండటం ద్వారా, ఫంక్షన్లు నడుస్తున్నప్పుడు (ఒకే లావాదేవీలో) పిలవకుండా నిరోధించవచ్చు.
+
+```solidity
+    modifier lock() {
+```
+
+ఈ ఫంక్షన్ ఒక [మాడిఫైయర్](https://docs.soliditylang.org/en/v0.8.3/contracts.html#function-modifiers), దాని ప్రవర్తనను మార్చడానికి ఒక సాధారణ ఫంక్షన్ చుట్టూ చుట్టుకునే ఫంక్షన్.
+
+```solidity
+        require(unlocked == 1, 'UniswapV2: LOCKED');
+        unlocked = 0;
+```
+
+`unlocked` ఒకటితో సమానంగా ఉంటే, దానిని సున్నాకు సెట్ చేయండి. ఇది ఇప్పటికే సున్నా అయితే కాల్ ను రద్దు చేయండి, దానిని విఫలం చేయండి.
+
+```solidity
+        _;
+```
+
+ఒక మాడిఫైయర్ లో `_;` అనేది అసలు ఫంక్షన్ కాల్ (అన్ని పారామీటర్లతో). ఇక్కడ ఫంక్షన్ కాల్ `unlocked` పిలిచినప్పుడు ఒకటిగా ఉంటేనే జరుగుతుందని అర్థం, మరియు అది నడుస్తున్నప్పుడు `unlocked` విలువ సున్నాగా ఉంటుంది.
+
+```solidity
+        unlocked = 1;
+    }
+```
+
+ప్రధాన ఫంక్షన్ తిరిగి వచ్చిన తర్వాత, లాక్ ను విడుదల చేయండి.
+
+#### ఇతరములు ఫంక్షన్లు {#pair-misc}
+
+```solidity
+    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
+        _reserve0 = reserve0;
+        _reserve1 = reserve1;
+        _blockTimestampLast = blockTimestampLast;
+    }
+```
+
+ఈ ఫంక్షన్ కాలర్లకు మార్పిడి యొక్క ప్రస్తుత స్థితిని అందిస్తుంది. Solidity ఫంక్షన్లు [బహుళ విలువలను తిరిగి ఇవ్వగలవు](https://docs.soliditylang.org/en/v0.8.3/contracts.html#returning-multiple-values) గమనించండి.
+
+```solidity
+    function _safeTransfer(address token, address to, uint value) private {
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
+```
+
+ఈ అంతర్గత ఫంక్షన్ మార్పిడి నుండి ERC20 టోకెన్ల మొత్తాన్ని మరొకరికి బదిలీ చేస్తుంది. `SELECTOR` మనం పిలుస్తున్న ఫంక్షన్ `transfer(address,uint)` అని పేర్కొంటుంది (పైన నిర్వచనం చూడండి).
+
+టోకెన్ ఫంక్షన్ కోసం ఒక ఇంటర్ఫేస్ ను దిగుమతి చేసుకోవాల్సిన అవసరం లేకుండా, మేము [ABI ఫంక్షన్లలో](https://docs.soliditylang.org/en/v0.8.3/units-and-global-variables.html#abi-encoding-and-decoding-functions) ఒకదానిని ఉపయోగించి కాల్ ను "మాన్యువల్ గా" సృష్టిస్తాము.
+
+```solidity
+        require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
+    }
+```
+
+ఒక ERC-20 బదిలీ కాల్ వైఫల్యాన్ని నివేదించగల రెండు మార్గాలు ఉన్నాయి:
+
+1. తిరిగి వెళ్లండి. ఒక బాహ్య ఒప్పందానికి కాల్ తిరిగి వెళ్ళినట్లయితే, బూలియన్ రిటర్న్ విలువ `false` అవుతుంది
+2. సాధారణంగా ముగించండి కానీ వైఫల్యాన్ని నివేదించండి. ఆ సందర్భంలో రిటర్న్ విలువ బఫర్ సున్నా కాని పొడవును కలిగి ఉంటుంది, మరియు బూలియన్ విలువగా డీకోడ్ చేసినప్పుడు అది `false` అవుతుంది
+
+ఈ పరిస్థితులలో ఏది జరిగినా, తిరిగి వెళ్లండి.
+
+#### సంఘటనలు {#pair-events}
+
+```solidity
+    event Mint(address indexed sender, uint amount0, uint amount1);
+    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
+```
+
+ద్రవ్యత్వ ప్రదాత ద్రవ్యతను డిపాజిట్ చేసినప్పుడు (`Mint`) లేదా ఉపసంహరించుకున్నప్పుడు (`Burn`) ఈ రెండు సంఘటనలు విడుదల చేయబడతాయి. ఏ సందర్భంలోనైనా, డిపాజిట్ చేయబడిన లేదా ఉపసంహరించుకున్న టోకెన్0 మరియు టోకెన్1 మొత్తాలు సంఘటనలో భాగంగా ఉంటాయి, అలాగే మనల్ని పిలిచిన ఖాతా యొక్క గుర్తింపు (`sender`) కూడా ఉంటుంది. ఉపసంహరణ సందర్భంలో, సంఘటన టోకెన్లను స్వీకరించిన లక్ష్యాన్ని (`to`) కూడా కలిగి ఉంటుంది, ఇది పంపినవారికి సమానంగా ఉండకపోవచ్చు.
+
+```solidity
+    event Swap(
+        address indexed sender,
+        uint amount0In,
+        uint amount1In,
+        uint amount0Out,
+        uint amount1Out,
+        address indexed to
+    );
+```
+
+ఒక వ్యాపారి ఒక టోకెన్ ను మరొక దాని కోసం స్వాప్ చేసినప్పుడు ఈ సంఘటన విడుదల చేయబడుతుంది. మళ్ళీ, పంపినవారు మరియు గమ్యం ఒకేలా ఉండకపోవచ్చు.
+ప్రతి టోకెన్ మార్పిడికి పంపబడవచ్చు లేదా దాని నుండి స్వీకరించబడవచ్చు.
+
+```solidity
+    event Sync(uint112 reserve0, uint112 reserve1);
+```
+
+చివరగా, కారణంతో సంబంధం లేకుండా, తాజా నిల్వ సమాచారం (మరియు అందువల్ల మార్పిడి రేటు) అందించడానికి టోకెన్లు జోడించబడినప్పుడు లేదా ఉపసంహరించుకున్నప్పుడు ప్రతిసారీ `Sync` విడుదల చేయబడుతుంది.
+
+#### సెటప్ ఫంక్షన్లు {#pair-setup}
+
+కొత్త జత మార్పిడి ఏర్పాటు చేసినప్పుడు ఈ ఫంక్షన్లను ఒకసారి పిలవాలి.
+
+```solidity
+    constructor() public {
+        factory = msg.sender;
+    }
+```
+
+నిర్మాణకర్త జతను సృష్టించిన ఫ్యాక్టరీ యొక్క చిరునామాను మేము ట్రాక్ చేస్తామని నిర్ధారిస్తుంది. `initialize` మరియు ఫ్యాక్టరీ రుసుము (ఒకవేళ ఉంటే) కోసం ఈ సమాచారం అవసరం
+
+```solidity
+    // విస్తరణ సమయంలో ఫ్యాక్టరీ ద్వారా ఒకసారి పిలవబడుతుంది
+    function initialize(address _token0, address _token1) external {
+        require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // తగినంత తనిఖీ
+        token0 = _token0;
+        token1 = _token1;
+    }
+```
+
+ఈ ఫంక్షన్ ఫ్యాక్టరీకి (మరియు ఫ్యాక్టరీకి మాత్రమే) ఈ జత మార్పిడి చేసే రెండు ERC-20 టోకెన్లను పేర్కొనడానికి అనుమతిస్తుంది.
+
+#### అంతర్గత నవీకరణ ఫంక్షన్లు {#pair-update-internal}
+
+##### \_update
+
+```solidity
+    // నిల్వలను నవీకరించండి మరియు, ప్రతి బ్లాక్ కు మొదటి కాల్ లో, ధర సంచితాలను
+    function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
+```
+
+టోకెన్లు డిపాజిట్ చేయబడినప్పుడు లేదా ఉపసంహరించుకున్నప్పుడు ప్రతిసారీ ఈ ఫంక్షన్ పిలవబడుతుంది.
+
+```solidity
+        require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
+```
+
+ఒకవేళ బ్యాలెన్స్0 లేదా బ్యాలెన్స్1 (uint256) uint112(-1) (=2^112-1) కంటే ఎక్కువగా ఉంటే (కాబట్టి అది ఓవర్ఫ్లో అవుతుంది & uint112 కు మార్చబడినప్పుడు తిరిగి 0 కు చుట్టబడుతుంది) ఓవర్ఫ్లోలను నివారించడానికి \_అప్డేట్ కొనసాగించడాన్ని తిరస్కరించండి. 10^18 యూనిట్లుగా విభజించగల ఒక సాధారణ టోకెన్ తో, ప్రతి మార్పిడి ప్రతి టోకెన్లకు సుమారు 5.1\*10^15 వరకు పరిమితం చేయబడిందని అర్థం. ఇప్పటివరకు అది సమస్య కాదు.
+
+```solidity
+        uint32 blockTimestamp = uint32(block.timestamp % 2**32);
+        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // ఓవర్ఫ్లో కోరబడుతుంది
+        if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
+```
+
+గడచిన సమయం సున్నా కాకపోతే, ఈ బ్లాక్ లో మేము మొదటి మార్పిడి లావాదేవీ అని అర్థం. ఆ సందర్భంలో, మేము ధర సంచితాలను నవీకరించాలి.
+
+```solidity
+            // * ఎప్పుడూ ఓవర్ఫ్లో కాదు, మరియు + ఓవర్ఫ్లో కోరబడుతుంది
+            price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
+            price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
+        }
+```
+
+ప్రతి ధర సంచితం తాజా ధరతో (ఇతర టోకెన్ నిల్వ/ఈ టోకెన్ నిల్వ) సెకన్లలో గడచిన సమయంతో నవీకరించబడుతుంది. సగటు ధరను పొందడానికి, మీరు కాలంలో రెండు బిందువులలో సంచిత ధరను చదివి, వాటి మధ్య సమయ వ్యత్యాసంతో విభజిస్తారు. ఉదాహరణకు, ఈ సంఘటనల క్రమాన్ని ఊహించండి:
+
+| సంఘటన                                                                                      |                    నిల్వ0 |                    నిల్వ1 | టైమ్ స్టాంప్ | ఉపాంత మార్పిడి రేటు (నిల్వ1 / నిల్వ0) |                                                              ధర0సంచితచివరి |
+| ------------------------------------------------------------------------------------------ | ------------------------: | ------------------------: | ------------ | -------------------------------------------------------: | -------------------------------------------------------------------------: |
+| ప్రారంభ సెటప్                                                                              | 1,000.000 | 1,000.000 | 5,000        |                                    1.000 |                                                                          0 |
+| వ్యాపారి A 50 టోకెన్0 ను డిపాజిట్ చేసి 47.619 టోకెన్1 ను తిరిగి పొందుతాడు  | 1,050.000 |   952.381 | 5,020        |                                    0.907 |                                                                         20 |
+| వ్యాపారి B 10 టోకెన్0 ను డిపాజిట్ చేసి 8.984 టోకెన్1 ను తిరిగి పొందుతాడు   | 1,060.000 |   943.396 | 5,030        |                                    0.890 |                       20+10\*0.907 = 29.07 |
+| వ్యాపారి C 40 టోకెన్0 ను డిపాజిట్ చేసి 34.305 టోకెన్1 ను తిరిగి పొందుతాడు  | 1,100.000 |   909.090 | 5,100        |                                    0.826 |    29.07+70\*0.890 = 91.37 |
+| వ్యాపారి D 100 టోకెన్1 ను డిపాజిట్ చేసి 109.01 టోకెన్0 ను తిరిగి పొందుతాడు |   990.990 | 1,009.090 | 5,110        |                                    1.018 |    91.37+10\*0.826 = 99.63 |
+| వ్యాపారి E 10 టోకెన్0 ను డిపాజిట్ చేసి 10.079 టోకెన్1 ను తిరిగి పొందుతాడు  | 1,000.990 |   999.010 | 5,150        |                                    0.998 | 99.63+40\*1.1018 = 143.702 |
+
+5,030 మరియు 5,150 టైమ్ స్టాంప్ ల మధ్య **టోకెన్0** సగటు ధరను లెక్కించాలనుకుందాం. `price0Cumulative` విలువలో వ్యత్యాసం 143.702-29.07=114.632. ఇది రెండు నిమిషాల (120 సెకన్లు) సగటు. కాబట్టి సగటు ధర 114.632/120 = 0.955.
+
+ఈ ధర గణన పాత నిల్వ పరిమాణాలను తెలుసుకోవాల్సిన కారణం.
+
+```solidity
+        reserve0 = uint112(balance0);
+        reserve1 = uint112(balance1);
+        blockTimestampLast = blockTimestamp;
+        emit Sync(reserve0, reserve1);
+    }
+```
+
+చివరగా, గ్లోబల్ వేరియబుల్స్ నవీకరించి `Sync` సంఘటనను విడుదల చేయండి.
+
+##### \_mintFee
+
+```solidity
+    // రుసుము ఆన్లో ఉంటే, sqrt(k) లోని పెరుగుదలలో 1/6 వ వంతుకు సమానమైన ద్రవ్యతను మింట్ చేయండి
+    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
+```
+
+యూనిస్వాప్ 2.0లో వ్యాపారులు మార్కెట్ ను ఉపయోగించడానికి 0.30% రుసుము చెల్లిస్తారు. ఆ రుసుములో ఎక్కువ భాగం (ట్రేడ్ లో 0.25%) ఎల్లప్పుడూ ద్రవ్యత్వ ప్రదాతలకు వెళ్తుంది. మిగిలిన 0.05% ద్రవ్యత్వ ప్రదాతలకు లేదా ఫ్యాక్టరీ ద్వారా ప్రోటోకాల్ రుసుముగా పేర్కొన్న చిరునామాకు వెళ్ళవచ్చు, ఇది యూనిస్వాప్ కు వారి అభివృద్ధి ప్రయత్నానికి చెల్లిస్తుంది.
+
+గణనలను (మరియు అందువల్ల గ్యాస్ ఖర్చులను) తగ్గించడానికి, ప్రతి లావాదేవీ వద్ద కాకుండా, పూల్ నుండి ద్రవ్యత జోడించబడినప్పుడు లేదా తీసివేయబడినప్పుడు మాత్రమే ఈ రుసుము లెక్కించబడుతుంది.
+
+```solidity
+        address feeTo = IUniswapV2Factory(factory).feeTo();
+        feeOn = feeTo != address(0);
+```
+
+ఫ్యాక్టరీ యొక్క రుసుము గమ్యాన్ని చదవండి. అది సున్నా అయితే ప్రోటోకాల్ రుసుము లేదు మరియు ఆ రుసుమును లెక్కించాల్సిన అవసరం లేదు.
+
+```solidity
+        uint _kLast = kLast; // గ్యాస్ పొదుపు
+```
+
+`kLast` స్థితి వేరియబుల్ నిల్వలో ఉంది, కాబట్టి ఒప్పందానికి విభిన్న కాల్ ల మధ్య దానికి ఒక విలువ ఉంటుంది.
+నిల్వకు ప్రాప్యత ఒప్పందానికి ఫంక్షన్ కాల్ ముగిసినప్పుడు విడుదల చేయబడే అస్థిర జ్ఞాపకశక్తికి ప్రాప్యత కంటే చాలా ఖరీదైనది, కాబట్టి మేము గ్యాస్ మీద ఆదా చేయడానికి ఒక అంతర్గత వేరియబుల్ ను ఉపయోగిస్తాము.
+
+```solidity
+        if (feeOn) {
+            if (_kLast != 0) {
+```
+
+ద్రవ్యత్వ ప్రదాతలు వారి ద్రవ్యత్వ టోకెన్ల ప్రశంసల ద్వారా తమ వాటాను పొందుతారు. కానీ ప్రోటోకాల్ రుసుము కొత్త ద్రవ్యత్వ టోకెన్లను మింట్ చేసి `feeTo` చిరునామాకు అందించాలి.
+
+```solidity
+                uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
+                uint rootKLast = Math.sqrt(_kLast);
+                if (rootK > rootKLast) {
+```
+
+ఒక ప్రోటోకాల్ రుసుమును వసూలు చేయడానికి కొత్త ద్రవ్యత ఉంటే. మీరు ఈ వ్యాసంలో తరువాత స్క్వేర్ రూట్ ఫంక్షన్ ను చూడవచ్చు (#Math)
+
+```solidity
+                    uint numerator = totalSupply.mul(rootK.sub(rootKLast));
+                    uint denominator = rootK.mul(5).add(rootKLast);
+                    uint liquidity = numerator / denominator;
+```
+
+రుసుముల యొక్క ఈ సంక్లిష్ట గణన [వైట్‌పేపర్](https://app.uniswap.org/whitepaper.pdf) లో 5వ పేజీలో వివరించబడింది. `kLast` లెక్కించబడిన సమయం మరియు ప్రస్తుతం మధ్య ద్రవ్యత జోడించబడలేదు లేదా తీసివేయబడలేదు అని మనకు తెలుసు (ఎందుకంటే ద్రవ్యత జోడించబడినప్పుడు లేదా తీసివేయబడినప్పుడు ప్రతిసారీ, అది వాస్తవంగా మారే ముందు ఈ గణనను మేము అమలు చేస్తాము), కాబట్టి `reserve0 * reserve1` లో ఏదైనా మార్పు లావాదేవీ రుసుముల నుండి రావాలి (అవి లేకుండా మేము `reserve0 * reserve1` ను స్థిరంగా ఉంచుతాము).
+
+```solidity
+                    if (liquidity > 0) _mint(feeTo, liquidity);
+                }
+            }
+```
+
+అదనపు ద్రవ్యత్వ టోకెన్లను వాస్తవంగా సృష్టించి, వాటిని `feeTo` కు కేటాయించడానికి `UniswapV2ERC20._mint` ఫంక్షన్ ను ఉపయోగించండి.
+
+```solidity
+        } else if (_kLast != 0) {
+            kLast = 0;
+        }
+    }
+```
+
+`kLast` కు రుసుము సెట్ చేయకపోతే దానిని సున్నాకు సెట్ చేయండి (ఒకవేళ అది ఇప్పటికే అలా లేకపోతే). ఈ ఒప్పందం వ్రాయబడినప్పుడు ఒక [గ్యాస్ రీఫండ్ ఫీచర్](https://eips.ethereum.org/EIPS/eip-3298) ఉండేది, ఇది ఒప్పందాలను వారు అవసరం లేని నిల్వను సున్నా చేయడం ద్వారా ఎథేరియం స్థితి యొక్క మొత్తం పరిమాణాన్ని తగ్గించడానికి ప్రోత్సహించింది.
+ఈ కోడ్ సాధ్యమైనప్పుడు ఆ రీఫండ్ ను పొందుతుంది.
+
+#### బాహ్యంగా యాక్సెస్ చేయగల ఫంక్షన్లు {#pair-external}
+
+ఏదైనా లావాదేవీ లేదా ఒప్పందం ఈ ఫంక్షన్లను కాల్ _చేయగలదు_ గమనించండి, అవి పెరిఫెరీ ఒప్పందం నుండి పిలవబడటానికి రూపొందించబడ్డాయి. మీరు వాటిని నేరుగా పిలిస్తే మీరు జత మార్పిడిని మోసం చేయలేరు, కానీ మీరు పొరపాటు ద్వారా విలువను కోల్పోవచ్చు.
+
+##### మింట్
+
+```solidity
+    // ఈ తక్కువ-స్థాయి ఫంక్షన్ ముఖ్యమైన భద్రతా తనిఖీలను చేసే ఒప్పందం నుండి పిలవబడాలి
+    function mint(address to) external lock returns (uint liquidity) {
+```
+
+ఒక ద్రవ్యత్వ ప్రదాత పూల్ కు ద్రవ్యతను జోడించినప్పుడు ఈ ఫంక్షన్ పిలవబడుతుంది. ఇది రివార్డుగా అదనపు ద్రవ్యత్వ టోకెన్లను మింట్ చేస్తుంది. దీనిని [పెరిఫెరీ ఒప్పందం](#UniswapV2Router02) నుండి పిలవాలి, ఇది అదే లావాదేవీలో ద్రవ్యతను జోడించిన తర్వాత దానిని పిలుస్తుంది (కాబట్టి చట్టబద్ధమైన యజమానికి ముందు కొత్త ద్రవ్యతను క్లెయిమ్ చేసే లావాదేవీని ఎవరూ సమర్పించలేరు).
+
+```solidity
+        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // గ్యాస్ పొదుపు
+```
+
+బహుళ విలువలను తిరిగి ఇచ్చే Solidity ఫంక్షన్ ఫలితాలను చదవడానికి ఇది విధానం. చివరిగా తిరిగి ఇచ్చిన విలువలను, బ్లాక్ టైమ్స్టాంప్ ను మేము విస్మరిస్తాము, ఎందుకంటే అది మాకు అవసరం లేదు.
+
+```solidity
+        uint balance0 = IERC20(token0).balanceOf(address(this));
+        uint balance1 = IERC20(token1).balanceOf(address(this));
+        uint amount0 = balance0.sub(_reserve0);
+        uint amount1 = balance1.sub(_reserve1);
+```
+
+ప్రస్తుత బ్యాలెన్స్ లను పొంది, ప్రతి టోకెన్ రకానికి ఎంత జోడించబడిందో చూడండి.
+
+```solidity
+        bool feeOn = _mintFee(_reserve0, _reserve1);
+```
+
+సేకరించవలసిన ప్రోటోకాల్ రుసుములను లెక్కించండి, ఒకవేళ ఉంటే, మరియు దానికి అనుగుణంగా ద్రవ్యత్వ టోకెన్లను మింట్ చేయండి. `_mintFee` పారామీటర్లు పాత నిల్వ విలువలు కాబట్టి, రుసుము కారణంగా పూల్ మార్పుల ఆధారంగా మాత్రమే రుసుము ఖచ్చితంగా లెక్కించబడుతుంది.
+
+```solidity
+        uint _totalSupply = totalSupply; // గ్యాస్ పొదుపు, totalSupply _mintFee లో అప్డేట్ కాగలదు కాబట్టి ఇక్కడ నిర్వచించాలి
+        if (_totalSupply == 0) {
+            liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
+           _mint(address(0), MINIMUM_LIQUIDITY); // మొదటి MINIMUM_LIQUIDITY టోకెన్లను శాశ్వతంగా లాక్ చేయండి
+```
+
+ఇది మొదటి డిపాజిట్ అయితే, `MINIMUM_LIQUIDITY` టోకెన్లను సృష్టించి, వాటిని లాక్ చేయడానికి చిరునామా సున్నాకు పంపండి. వాటిని ఎప్పటికీ విమోచించలేరు, అంటే పూల్ ఎప్పటికీ పూర్తిగా ఖాళీ చేయబడదు (ఇది కొన్ని చోట్ల సున్నాతో విభజన నుండి మనల్ని రక్షిస్తుంది). `MINIMUM_LIQUIDITY` విలువ వెయ్యి, ఇది చాలా ERC-20 లు ఒక టోకెన్ యొక్క 10^-18 వ యూనిట్లుగా విభజించబడ్డాయని పరిగణనలోకి తీసుకుంటే, ETH wei గా విభజించబడినట్లుగా, ఒకే టోకెన్ విలువకు 10^-15. అధిక ఖర్చు కాదు.
+
+మొదటి డిపాజిట్ సమయంలో రెండు టోకెన్ల సాపేక్ష విలువ మనకు తెలియదు, కాబట్టి మేము మొత్తాలను గుణించి, డిపాజిట్ రెండు టోకెన్లలో సమాన విలువను అందిస్తుందని ఊహించి స్క్వేర్ రూట్ తీసుకుంటాము.
+
+ఆర్బిట్రేజ్ వల్ల విలువను కోల్పోకుండా ఉండటానికి సమాన విలువను అందించడం డిపాజిటర్ ప్రయోజనం కాబట్టి మనం దీనిని నమ్మవచ్చు.
+రెండు టోకెన్ల విలువ ఒకేలా ఉందని అనుకుందాం, కానీ మన డిపాజిటర్ **టోకెన్0** కంటే నాలుగు రెట్లు ఎక్కువ **టోకెన్1** ని డిపాజిట్ చేసారు. ఒక వ్యాపారి **టోకెన్0** విలువైనదని జత మార్పిడి భావించే వాస్తవాన్ని ఉపయోగించి దాని నుండి విలువను తీయవచ్చు.
+
+| సంఘటన                                                                                  | నిల్వ0 | నిల్వ1 | నిల్వ0 \* నిల్వ1 | పూల్ విలువ (నిల్వ0 + నిల్వ1) |
+| -------------------------------------------------------------------------------------- | -----: | -----: | ---------------: | ----------------------------------------------: |
+| ప్రారంభ సెటప్                                                                          |      8 |     32 |              256 |                                              40 |
+| వ్యాపారి 8 **టోకెన్0** టోకెన్లను డిపాజిట్ చేస్తాడు, తిరిగి 16 **టోకెన్1** ను పొందుతాడు |     16 |     16 |              256 |                                              32 |
+
+మీరు చూడగలరు, వ్యాపారి అదనంగా 8 టోకెన్లను సంపాదించాడు, ఇది పూల్ విలువలో తగ్గుదల నుండి వస్తుంది, దాని యజమాని అయిన డిపాజిటర్ కు నష్టం కలిగిస్తుంది.
+
+```solidity
+        } else {
+            liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
+```
+
+ప్రతి తదుపరి డిపాజిట్ తో రెండు ఆస్తుల మధ్య మార్పిడి రేటు మనకు ఇప్పటికే తెలుసు, మరియు ద్రవ్యత్వ ప్రదాతలు రెండింటిలోనూ సమాన విలువను అందిస్తారని మేము ఆశిస్తున్నాము. వారు అలా చేయకపోతే, శిక్షగా వారు అందించిన తక్కువ విలువ ఆధారంగా మేము వారికి ద్రవ్యత్వ టోకెన్లను ఇస్తాము.
+
+ఇది ప్రారంభ డిపాజిట్ అయినా లేదా తదుపరిది అయినా, మేము అందించే ద్రవ్యత్వ టోకెన్ల సంఖ్య `reserve0*reserve1` లోని మార్పు యొక్క స్క్వేర్ రూట్ కు సమానం మరియు ద్రవ్యత్వ టోకెన్ విలువ మారదు (రెండు రకాల సమాన విలువలు లేని డిపాజిట్ ను మేము పొందితే తప్ప, ఆ సందర్భంలో "జరిమానా" పంపిణీ చేయబడుతుంది). ఇక్కడ అదే విలువ కలిగిన రెండు టోకెన్లతో మరొక ఉదాహరణ ఉంది, మూడు మంచి డిపాజిట్లు మరియు ఒకటి చెడ్డది (ఒకే టోకెన్ రకం డిపాజిట్, కాబట్టి ఇది ఏ ద్రవ్యత్వ టోకెన్లను ఉత్పత్తి చేయదు).
+
+| సంఘటన                            |                                  నిల్వ0 |                                  నిల్వ1 | నిల్వ0 \* నిల్వ1 | పూల్ విలువ (నిల్వ0 + నిల్వ1) | ఈ డిపాజిట్ కోసం ముద్రించిన ద్రవ్యత్వ టోకెన్లు | మొత్తం ద్రవ్యత్వ టోకెన్లు |           ప్రతి ద్రవ్యత్వ టోకెన్ విలువ |
+| -------------------------------- | --------------------------------------: | --------------------------------------: | ---------------: | ----------------------------------------------: | --------------------------------------------: | ------------------------: | -------------------------------------: |
+| ప్రారంభ సెటప్                    |                   8.000 |                   8.000 |               64 |                          16.000 |                                             8 |                         8 |                  2.000 |
+| ప్రతి రకం నాలుగు డిపాజిట్ చేయండి |                  12.000 |                  12.000 |              144 |                          24.000 |                                             4 |                        12 |                  2.000 |
+| ప్రతి రకం రెండు డిపాజిట్ చేయండి  |                  14.000 |                  14.000 |              196 |                          28.000 |                                             2 |                        14 |                  2.000 |
+| అసమాన విలువ డిపాజిట్             |                  18.000 |                  14.000 |              252 |                          32.000 |                                             0 |                        14 | ~2.286 |
+| ఆర్బిట్రేజ్ తరువాత               | ~15.874 | ~15.874 |              252 |         ~31.748 |                                             0 |                        14 | ~2.267 |
+
+```solidity
+        }
+        require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
+        _mint(to, liquidity);
+```
+
+అదనపు ద్రవ్యత్వ టోకెన్లను వాస్తవంగా సృష్టించి, సరైన ఖాతాకు ఇవ్వడానికి `UniswapV2ERC20._mint` ఫంక్షన్ ను ఉపయోగించండి.
+
+```solidity
+
+        _update(balance0, balance1, _reserve0, _reserve1);
+        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 మరియు reserve1 నవీకరించబడినవి
+        emit Mint(msg.sender, amount0, amount1);
+    }
+```
+
+స్థితి వేరియబుల్స్ (`reserve0`, `reserve1`, మరియు అవసరమైతే `kLast`) నవీకరించి, తగిన సంఘటనను విడుదల చేయండి.
+
+##### బర్న్
+
+```solidity
+    // ఈ తక్కువ-స్థాయి ఫంక్షన్ ముఖ్యమైన భద్రతా తనిఖీలను చేసే ఒప్పందం నుండి పిలవబడాలి
+    function burn(address to) external lock returns (uint amount0, uint amount1) {
+```
+
+ద్రవ్యత ఉపసంహరించబడినప్పుడు మరియు తగిన ద్రవ్యత్వ టోకెన్లను బర్న్ చేయవలసినప్పుడు ఈ ఫంక్షన్ పిలవబడుతుంది.
+ఇది [పెరిఫెరీ ఖాతా](#UniswapV2Router02) నుండి కూడా పిలవబడాలి.
+
+```solidity
+        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // గ్యాస్ పొదుపు
+        address _token0 = token0;                                // గ్యాస్ పొదుపు
+        address _token1 = token1;                                // గ్యాస్ పొదుపు
+        uint balance0 = IERC20(_token0).balanceOf(address(this));
+        uint balance1 = IERC20(_token1).balanceOf(address(this));
+        uint liquidity = balanceOf[address(this)];
+```
+
+పెరిఫెరీ ఒప్పందం కాల్ కు ముందు బర్న్ చేయవలసిన ద్రవ్యతను ఈ ఒప్పందానికి బదిలీ చేసింది. ఆ విధంగా ఎంత ద్రవ్యతను బర్న్ చేయాలో మనకు తెలుసు, మరియు అది బర్న్ అవుతుందని మనం నిర్ధారించుకోవచ్చు.
+
+```solidity
+        bool feeOn = _mintFee(_reserve0, _reserve1);
+        uint _totalSupply = totalSupply; // గ్యాస్ పొదుపు, totalSupply _mintFee లో నవీకరించగలదు కాబట్టి ఇక్కడ నిర్వచించాలి
+        amount0 = liquidity.mul(balance0) / _totalSupply; // బ్యాలెన్స్ లను ఉపయోగించడం ప్రో-రాటా పంపిణీని నిర్ధారిస్తుంది
+        amount1 = liquidity.mul(balance1) / _totalSupply; // బ్యాలెన్స్ లను ఉపయోగించడం ప్రో-రాటా పంపిణీని నిర్ధారిస్తుంది
+        require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
+```
+
+ద్రవ్యత్వ ప్రదాత రెండు టోకెన్ల సమాన విలువను పొందుతాడు. ఈ విధంగా మనం మార్పిడి రేటును మార్చము.
+
+```solidity
+        _burn(address(this), liquidity);
+        _safeTransfer(_token0, to, amount0);
+        _safeTransfer(_token1, to, amount1);
+        balance0 = IERC20(_token0).balanceOf(address(this));
+        balance1 = IERC20(_token1).balanceOf(address(this));
+
+        _update(balance0, balance1, _reserve0, _reserve1);
+        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 మరియు reserve1 నవీకరించబడినవి
+        emit Burn(msg.sender, amount0, amount1, to);
+    }
+
+```
+
+`burn` ఫంక్షన్ యొక్క మిగిలిన భాగం పైన ఉన్న `mint` ఫంక్షన్ యొక్క ప్రతిబింబం.
+
+##### స్వాప్
+
+```solidity
+    // ఈ తక్కువ-స్థాయి ఫంక్షన్ ముఖ్యమైన భద్రతా తనిఖీలను చేసే ఒప్పందం నుండి పిలవబడాలి
+    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
+```
+
+ఈ ఫంక్షన్ కూడా [పెరిఫెరీ ఒప్పందం](#UniswapV2Router02) నుండి పిలవబడాలి.
+
+```solidity
+        require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
+        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // గ్యాస్ పొదుపు
+        require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
+
+        uint balance0;
+        uint balance1;
+        { // _token{0,1} కోసం స్కోప్, స్టాక్ చాలా లోతైన లోపాలను నివారిస్తుంది
+```
+
+స్థానిక వేరియబుల్స్ మెమరీలో లేదా, వాటి సంఖ్య చాలా ఎక్కువగా లేకపోతే, నేరుగా స్టాక్ మీద నిల్వ చేయబడతాయి.
+మనం స్టాక్ ను ఉపయోగించడానికి సంఖ్యను పరిమితం చేయగలిగితే మనం తక్కువ గ్యాస్ ను ఉపయోగిస్తాము. మరిన్ని వివరాల కోసం [ఎల్లో పేపర్, అధికారిక Ethereum స్పెసిఫికేషన్లు](https://ethereum.github.io/yellowpaper/paper.pdf), p. 26, సమీకరణం 298 చూడండి.
+
+```solidity
+            address _token0 = token0;
+            address _token1 = token1;
+            require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
+            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // ఆశాజనకంగా టోకెన్లను బదిలీ చేయండి
+            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // ఆశాజనకంగా టోకెన్లను బదిలీ చేయండి
+```
+
+ఈ బదిలీ ఆశాజనకమైనది, ఎందుకంటే అన్ని షరతులు నెరవేరాయని మేము ఖచ్చితంగా తెలుసుకోకముందే మేము బదిలీ చేస్తాము. ఇది Ethereum లో సరే, ఎందుకంటే కాల్ లో తరువాత షరతులు నెరవేరకపోతే మేము దాని నుండి మరియు అది సృష్టించిన ఏవైనా మార్పుల నుండి తిరిగి వస్తాము.
+
+```solidity
+            if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
+```
+
+అభ్యర్థించినట్లయితే స్వాప్ గురించి స్వీకర్తకు తెలియజేయండి.
+
+```solidity
+            balance0 = IERC20(_token0).balanceOf(address(this));
+            balance1 = IERC20(_token1).balanceOf(address(this));
+        }
+```
+
+ప్రస్తుత బ్యాలెన్స్ లను పొందండి. పెరిఫెరీ ఒప్పందం స్వాప్ కోసం మమ్మల్ని పిలిచే ముందు టోకెన్లను మాకు పంపుతుంది. ఇది ఒప్పందానికి అది మోసం చేయబడలేదని తనిఖీ చేయడానికి సులభం చేస్తుంది, ఇది కోర్ ఒప్పందంలో జరగవలసిన తనిఖీ (ఎందుకంటే మా పెరిఫెరీ ఒప్పందం కంటే ఇతర సంస్థల నుండి మమ్మల్ని పిలవవచ్చు).
+
+```solidity
+        uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
+        uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
+        require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
+        { // reserve{0,1}Adjusted కోసం స్కోప్, స్టాక్ చాలా లోతైన లోపాలను నివారిస్తుంది
+            uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
+            uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
+            require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
+```
+
+ఇది స్వాప్ నుండి మనం నష్టపోకుండా చూసుకోవడానికి ఒక సానిటీ తనిఖీ. ఒక స్వాప్ `reserve0*reserve1` ను తగ్గించే పరిస్థితి ఏదీ లేదు. ఇది కూడా స్వాప్ పై 0.3% రుసుము పంపబడుతుందని మేము నిర్ధారించుకునే చోట; K విలువను సానిటీ తనిఖీ చేసే ముందు, మేము రెండు బ్యాలెన్స్ లను 1000 తో గుణించి, మొత్తాలను 3 తో గుణించి తీసివేస్తాము, అంటే 0.3% (3/1000 = 0.003 = 0.3%) బ్యాలెన్స్ నుండి తీసివేయబడుతుంది, దాని K విలువను ప్రస్తుత నిల్వల K విలువతో పోల్చడానికి ముందు.
+
+```solidity
+        }
+
+        _update(balance0, balance1, _reserve0, _reserve1);
+        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
+    }
+```
+
+`reserve0` మరియు `reserve1` ను నవీకరించండి, మరియు అవసరమైతే ధర సంచితాలు మరియు టైమ్ స్టాంప్ ను నవీకరించి, ఒక సంఘటనను విడుదల చేయండి.
+
+##### సింక్ లేదా స్కిమ్
+
+నిజమైన బ్యాలెన్స్ లు జత మార్పిడి భావించే నిల్వలతో సమకాలీకరణ కోల్పోవడం సాధ్యమే.
+ఒప్పందం యొక్క అనుమతి లేకుండా టోకెన్లను ఉపసంహరించుకోవడానికి మార్గం లేదు, కానీ డిపాజిట్లు వేరే విషయం. ఒక ఖాతా `mint` లేదా `swap` ను పిలవకుండానే మార్పిడికి టోకెన్లను బదిలీ చేయగలదు.
+
+ఆ సందర్భంలో రెండు పరిష్కారాలు ఉన్నాయి:
+
+- `sync`, నిల్వలను ప్రస్తుత బ్యాలెన్స్ లకు నవీకరించండి
+- `skim`, అదనపు మొత్తాన్ని ఉపసంహరించుకోండి. టోకెన్లను ఎవరు డిపాజిట్ చేశారో మాకు తెలియదు కాబట్టి ఏ ఖాతానైనా `skim` ను పిలవడానికి అనుమతించబడుతుంది గమనించండి. ఈ సమాచారం ఒక సంఘటనలో విడుదల చేయబడుతుంది, కానీ సంఘటనలు బ్లాక్‌చెయిన్ నుండి అందుబాటులో ఉండవు.
+
+```solidity
+    // నిల్వలకు బ్యాలెన్స్ లను సరిపోల్చడానికి బలవంతం చేయండి
+    function skim(address to) external lock {
+        address _token0 = token0; // గ్యాస్ పొదుపు
+        address _token1 = token1; // గ్యాస్ పొదుపు
+        _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
+        _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
+    }
+
+
+
+    // నిల్వలను బ్యాలెన్స్ లకు సరిపోల్చడానికి బలవంతం చేయండి
+    function sync() external lock {
+        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
+    }
+}
+```
+
+### UniswapV2Factory.sol {#UniswapV2Factory}
+
+[ఈ ఒప్పందం](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Factory.sol) జత మార్పిడులను సృష్టిస్తుంది.
+
+```solidity
+pragma solidity =0.5.16;
+
+import './interfaces/IUniswapV2Factory.sol';
+import './UniswapV2Pair.sol';
+
+contract UniswapV2Factory is IUniswapV2Factory {
+    address public feeTo;
+    address public feeToSetter;
+```
+
+ఈ స్థితి వేరియబుల్స్ ప్రోటోకాల్ రుసుమును అమలు చేయడానికి అవసరం ([వైట్‌పేపర్](https://app.uniswap.org/whitepaper.pdf), p. 5 చూడండి).
+`feeTo` చిరునామా ప్రోటోకాల్ రుసుము కోసం ద్రవ్యత్వ టోకెన్లను సేకరిస్తుంది, మరియు `feeToSetter` `feeTo` ను వేరే చిరునామాకు మార్చడానికి అనుమతించబడిన చిరునామా.
+
+```solidity
+    mapping(address => mapping(address => address)) public getPair;
+    address[] public allPairs;
+```
+
+ఈ వేరియబుల్స్ జతలను, రెండు టోకెన్ రకాల మధ్య మార్పిడులను ట్రాక్ చేస్తాయి.
+
+మొదటిది, `getPair`, ఇది రెండు ERC-20 టోకెన్లు మార్పిడి చేసే జత మార్పిడి ఒప్పందాన్ని గుర్తించే ఒక మ్యాపింగ్. ERC-20 టోకెన్లు వాటిని అమలు చేసే ఒప్పందాల చిరునామాల ద్వారా గుర్తించబడతాయి, కాబట్టి కీలు మరియు విలువ అన్నీ చిరునామాలే. `tokenA` నుండి `tokenB` కు మార్చడానికి అనుమతించే జత మార్పిడి చిరునామాను పొందడానికి, మీరు `getPair[<tokenA address>][<tokenB address>]` (లేదా ఇంకో విధంగా) ఉపయోగిస్తారు.
+
+రెండవ వేరియబుల్, `allPairs`, ఈ ఫ్యాక్టరీ సృష్టించిన జత మార్పిడుల అన్ని చిరునామాలను కలిగి ఉన్న ఒక శ్రేణి. Ethereum లో మీరు ఒక మ్యాపింగ్ యొక్క కంటెంట్ పై మళ్ళింపు చేయలేరు, లేదా అన్ని కీ ల జాబితాను పొందలేరు, కాబట్టి ఈ ఫ్యాక్టరీ ఏ మార్పిడులను నిర్వహిస్తుందో తెలుసుకోవడానికి ఈ వేరియబుల్ మాత్రమే మార్గం.
+
+గమనిక: మీరు ఒక మ్యాపింగ్ యొక్క అన్ని కీ లపై మళ్ళింపు చేయలేకపోవడానికి కారణం ఒప్పంద డేటా నిల్వ _ఖరీదైనది_, కాబట్టి దానిని తక్కువగా ఉపయోగించడం మరియు దానిని తక్కువగా మార్చడం మంచిది. మీరు [మళ్ళింపుకు మద్దతు ఇచ్చే మ్యాపింగ్స్](https://github.com/ethereum/dapp-bin/blob/master/library/iterable_mapping.sol) ను సృష్టించవచ్చు, కానీ వాటికి కీ ల జాబితా కోసం అదనపు నిల్వ అవసరం. చాలా అప్లికేషన్లలో మీకు అది అవసరం లేదు.
+
+```solidity
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+```
+
+ఒక కొత్త జత మార్పిడి సృష్టించబడినప్పుడు ఈ సంఘటన విడుదల చేయబడుతుంది. ఇది టోకెన్ల చిరునామాలు, జత మార్పిడి చిరునామా, మరియు ఫ్యాక్టరీ ద్వారా నిర్వహించబడే మొత్తం మార్పిడుల సంఖ్యను కలిగి ఉంటుంది.
+
+```solidity
+    constructor(address _feeToSetter) public {
+        feeToSetter = _feeToSetter;
+    }
+```
+
+నిర్మాణకర్త చేసే ఏకైక పని `feeToSetter` ను పేర్కొనడం. ఫ్యాక్టరీలు రుసుము లేకుండా ప్రారంభమవుతాయి, మరియు `feeSetter` మాత్రమే దానిని మార్చగలదు.
+
+```solidity
+    function allPairsLength() external view returns (uint) {
+        return allPairs.length;
+    }
+```
+
+ఈ ఫంక్షన్ మార్పిడి జతల సంఖ్యను తిరిగి ఇస్తుంది.
+
+```solidity
+    function createPair(address tokenA, address tokenB) external returns (address pair) {
+```
+
+ఇది ఫ్యాక్టరీ యొక్క ప్రధాన ఫంక్షన్, రెండు ERC-20 టోకెన్ల మధ్య జత మార్పిడిని సృష్టించడం. ఎవరైనా ఈ ఫంక్షన్ ను పిలవవచ్చు గమనించండి. కొత్త జత మార్పిడిని సృష్టించడానికి మీకు యూనిస్వాప్ నుండి అనుమతి అవసరం లేదు.
+
+```solidity
+        require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
+        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+```
+
+మేము కొత్త మార్పిడి చిరునామాను డిటర్మినిస్టిక్ గా ఉండాలని కోరుకుంటున్నాము, కాబట్టి దానిని ముందుగానే ఆఫ్ చైన్ లో లెక్కించవచ్చు (ఇది [/developers/docs/scaling/](/developers/docs/scaling/) లావాదేవీలకు ఉపయోగపడవచ్చు).
+దీనిని చేయడానికి, మనం వాటిని స్వీకరించిన క్రమంతో సంబంధం లేకుండా టోకెన్ చిరునామాల యొక్క స్థిరమైన క్రమాన్ని కలిగి ఉండాలి, కాబట్టి మనం వాటిని ఇక్కడ క్రమబద్ధీకరిస్తాము.
+
+```solidity
+        require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
+        require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // ఒకే తనిఖీ సరిపోతుంది
+```
+
+చిన్న వాటి కంటే పెద్ద ద్రవ్యత్వ పూల్స్ మంచివి, ఎందుకంటే వాటికి మరింత స్థిరమైన ధరలు ఉంటాయి. మేము ప్రతి జత టోకెన్లకు ఒకే ద్రవ్యత్వ పూల్ కంటే ఎక్కువ ఉండకూడదని కోరుకుంటున్నాము. ఒకవేళ ఇప్పటికే ఒక మార్పిడి ఉంటే, అదే జత కోసం మరొకటి సృష్టించవలసిన అవసరం లేదు.
+
+```solidity
+        bytes memory bytecode = type(UniswapV2Pair).creationCode;
+```
+
+ఒక కొత్త ఒప్పందాన్ని సృష్టించడానికి మనకు దానిని సృష్టించే కోడ్ అవసరం (నిర్మాణకర్త ఫంక్షన్ మరియు అసలు ఒప్పందం యొక్క EVM బైట్కోడ్ ను మెమరీకి వ్రాసే కోడ్ రెండూ). సాధారణంగా Solidity లో మేము `addr = new <name of contract>(<constructor parameters>)` ను ఉపయోగిస్తాము మరియు కంపైలర్ మా కోసం అన్నింటినీ చూసుకుంటుంది, కానీ ఒక డిటర్మినిస్టిక్ ఒప్పంద చిరునామాను కలిగి ఉండటానికి మేము [CREATE2 ఆప్కోడ్](https://eips.ethereum.org/EIPS/eip-1014) ను ఉపయోగించాలి.
+ఈ కోడ్ వ్రాయబడినప్పుడు ఆ ఆప్కోడ్ ఇంకా Solidity ద్వారా మద్దతు ఇవ్వబడలేదు, కాబట్టి కోడ్ ను మాన్యువల్ గా పొందడం అవసరం. ఇది ఇప్పుడు సమస్య కాదు, ఎందుకంటే [Solidity ఇప్పుడు CREATE2 కు మద్దతు ఇస్తుంది](https://docs.soliditylang.org/en/v0.8.3/control-structures.html#salted-contract-creations-create2).
+
+```solidity
+        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
+        assembly {
+            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
+        }
+```
+
+ఒక ఆప్కోడ్ ఇంకా Solidity ద్వారా మద్దతు ఇవ్వబడనప్పుడు మనం దానిని [ఇన్లైన్ అసెంబ్లీ](https://docs.soliditylang.org/en/v0.8.3/assembly.html) ఉపయోగించి పిలవవచ్చు.
+
+```solidity
+        IUniswapV2Pair(pair).initialize(token0, token1);
+```
+
+కొత్త మార్పిడి ఏ రెండు టోకెన్లను మార్పిడి చేస్తుందో చెప్పడానికి `initialize` ఫంక్షన్ ను పిలవండి.
+
+```solidity
+        getPair[token0][token1] = pair;
+        getPair[token1][token0] = pair; // రివర్స్ దిశలో మ్యాపింగ్ నింపండి
+        allPairs.push(pair);
+        emit PairCreated(token0, token1, pair, allPairs.length);
+```
+
+కొత్త జత సమాచారాన్ని స్థితి వేరియబుల్స్ లో సేవ్ చేసి, కొత్త జత మార్పిడి గురించి ప్రపంచానికి తెలియజేయడానికి ఒక సంఘటనను విడుదల చేయండి.
+
+```solidity
+    function setFeeTo(address _feeTo) external {
+        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
+        feeTo = _feeTo;
+    }
+
+    function setFeeToSetter(address _feeToSetter) external {
+        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
+        feeToSetter = _feeToSetter;
+    }
+}
+```
+
+ఈ రెండు ఫంక్షన్లు `feeSetter` రుసుము స్వీకర్తను (ఏదైనా ఉంటే) నియంత్రించడానికి మరియు `feeSetter` ను కొత్త చిరునామాకు మార్చడానికి అనుమతిస్తాయి.
+
+### UniswapV2ERC20.sol {#UniswapV2ERC20}
+
+[ఈ ఒప్పందం](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) ERC-20 ద్రవ్యత్వ టోకెన్ ను అమలు చేస్తుంది. ఇది [ఓపెన్జెప్పెలిన్ ERC-20 ఒప్పందం](/developers/tutorials/erc20-annotated-code) లాంటిది, కాబట్టి నేను భిన్నమైన భాగాన్ని, `permit` ఫంక్షనాలిటీని మాత్రమే వివరిస్తాను.
+
+Ethereum పై లావాదేవీలకు ether (ETH) ఖర్చవుతుంది, ఇది నిజమైన డబ్బుతో సమానం. మీ దగ్గర ERC-20 టోకెన్లు ఉండి ETH లేకపోతే, మీరు లావాదేవీలను పంపలేరు, కాబట్టి మీరు వాటితో ఏమీ చేయలేరు. ఈ సమస్యను నివారించడానికి ఒక పరిష్కారం [మెటా-లావాదేవీలు](https://docs.uniswap.org/contracts/v2/guides/smart-contract-integration/supporting-meta-transactions).
+టోకెన్ల యజమాని టోకెన్లను ఆఫ్చైన్ ఉపసంహరించుకోవడానికి వేరొకరికి అనుమతించే లావాదేవీపై సంతకం చేసి, దానిని ఇంటర్నెట్ ద్వారా స్వీకర్తకు పంపుతాడు. ETH ఉన్న స్వీకర్త, యజమాని తరఫున అనుమతిని సమర్పిస్తాడు.
+
+```solidity
+    bytes32 public DOMAIN_SEPARATOR;
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+```
+
+ఈ హాష్ [లావాదేవీ రకం యొక్క ఐడెంటిఫైయర్](https://eips.ethereum.org/EIPS/eip-712#rationale-for-typehash). మేము ఇక్కడ మద్దతు ఇచ్చే ఏకైక రకం `Permit` ఈ పారామీటర్లతో.
+
+```solidity
+    mapping(address => uint) public nonces;
+```
+
+ఒక స్వీకర్త డిజిటల్ సంతకాన్ని నకిలీ చేయడం అసాధ్యం. అయినప్పటికీ, అదే లావాదేవీని రెండుసార్లు పంపడం చాలా సులభం (ఇది [రీప్లే అటాక్](https://wikipedia.org/wiki/Replay_attack) యొక్క ఒక రూపం). దీనిని నివారించడానికి, మేము ఒక [నోన్స్](https://wikipedia.org/wiki/Cryptographic_nonce) ను ఉపయోగిస్తాము. ఒక కొత్త `Permit` యొక్క నోన్స్ చివరిగా ఉపయోగించిన దానికంటే ఒకటి ఎక్కువగా లేకపోతే, మేము దానిని చెల్లనిదిగా భావిస్తాము.
+
+```solidity
+    constructor() public {
+        uint chainId;
+        assembly {
+            chainId := chainid
+        }
+```
+
+ఇది [చైన్ ఐడెంటిఫైయర్](https://chainid.network/) ను తిరిగి పొందడానికి కోడ్. ఇది [యూల్](https://docs.soliditylang.org/en/v0.8.4/yul.html) అని పిలువబడే EVM అసెంబ్లీ మాండలికాన్ని ఉపయోగిస్తుంది. యూల్ యొక్క ప్రస్తుత వెర్షన్ లో మీరు `chainid()` ఉపయోగించాలని గమనించండి, `chainid` కాదు.
+
+```solidity
+        DOMAIN_SEPARATOR = keccak256(
+            abi.encode(
+                keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
+                keccak256(bytes(name)),
+                keccak256(bytes('1')),
+                chainId,
+                address(this)
+            )
+        );
+    }
+```
+
+EIP-712 కోసం [డొమైన్ సెపరేటర్](https://eips.ethereum.org/EIPS/eip-712#rationale-for-domainseparator) ను లెక్కించండి.
+
+```solidity
+    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
+```
+
+అనుమతులను అమలు చేసే ఫంక్షన్ ఇది. ఇది పారామీటర్లుగా సంబంధిత ఫీల్డ్స్, మరియు [సంతకం](https://yos.io/2018/11/16/ethereum-signatures/) (v, r, మరియు s) కోసం మూడు స్కేలార్ విలువలను స్వీకరిస్తుంది.
+
+```solidity
+        require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
+```
+
+గడువు తేదీ తర్వాత లావాదేవీలను అంగీకరించవద్దు.
+
+```solidity
+        bytes32 digest = keccak256(
+            abi.encodePacked(
+                '\x19\x01',
+                DOMAIN_SEPARATOR,
+                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
+            )
+        );
+```
+
+`abi.encodePacked(...)` అనేది మేము పొందాలని ఆశించే సందేశం. నోన్స్ ఎలా ఉండాలో మనకు తెలుసు, కాబట్టి దానిని పారామీటర్ గా పొందాల్సిన అవసరం లేదు.
+
+Ethereum సంతకం అల్గోరిథం సంతకం చేయడానికి 256 బిట్స్ పొందాలని ఆశిస్తుంది, కాబట్టి మేము `keccak256` హాష్ ఫంక్షన్ ను ఉపయోగిస్తాము.
+
+```solidity
+        address recoveredAddress = ecrecover(digest, v, r, s);
+```
+
+డైజెస్ట్ మరియు సంతకం నుండి మనం దానిపై సంతకం చేసిన చిరునామాను [ecrecover](https://coders-errand.com/ecrecover-signature-verification-ethereum/) ఉపయోగించి పొందవచ్చు.
+
+```solidity
+        require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
+        _approve(owner, spender, value);
+    }
+
+```
+
+అన్నీ సరే అయితే, దీనిని [ఒక ERC-20 ఆమోదం](https://eips.ethereum.org/EIPS/eip-20#approve) గా పరిగణించండి.
+
+## పెరిఫెరీ ఒప్పందాలు {#periphery-contracts}
+
+పెరిఫెరీ ఒప్పందాలు యూనిస్వాప్ కోసం API (అప్లికేషన్ ప్రోగ్రామ్ ఇంటర్ఫేస్). అవి ఇతర ఒప్పందాల నుండి లేదా వికేంద్రీకృత అప్లికేషన్ల నుండి బాహ్య కాల్స్ కోసం అందుబాటులో ఉన్నాయి. మీరు కోర్ ఒప్పందాలను నేరుగా పిలవవచ్చు, కానీ అది మరింత సంక్లిష్టంగా ఉంటుంది మరియు మీరు పొరపాటు చేస్తే విలువను కోల్పోవచ్చు. కోర్ ఒప్పందాలలో అవి మోసగించబడలేదని నిర్ధారించుకోవడానికి మాత్రమే పరీక్షలు ఉంటాయి, ఇతరుల కోసం సానిటీ తనిఖీలు ఉండవు. అవి పెరిఫెరీలో ఉన్నాయి కాబట్టి వాటిని అవసరమైనప్పుడు నవీకరించవచ్చు.
+
+### UniswapV2Router01.sol {#UniswapV2Router01}
+
+[ఈ ఒప్పందానికి](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router01.sol) సమస్యలు ఉన్నాయి, మరియు [ఇకపై ఉపయోగించకూడదు](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-01). అదృష్టవశాత్తు, పెరిఫెరీ ఒప్పందాలు స్థితిరహితంగా ఉంటాయి మరియు ఏ ఆస్తులనూ కలిగి ఉండవు, కాబట్టి దానిని తొలగించి, బదులుగా `UniswapV2Router02` ను ఉపయోగించమని ప్రజలకు సూచించడం సులభం.
+
+### UniswapV2Router02.sol {#UniswapV2Router02}
+
+చాలా సందర్భాల్లో మీరు [ఈ ఒప్పందం](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/UniswapV2Router02.sol) ద్వారా యూనిస్వాప్ ను ఉపయోగిస్తారు.
+మీరు దానిని ఎలా ఉపయోగించాలో [ఇక్కడ](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02) చూడవచ్చు.
+
+```solidity
+pragma solidity =0.6.6;
+
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
+import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
+
+import './interfaces/IUniswapV2Router02.sol';
+import './libraries/UniswapV2Library.sol';
+import './libraries/SafeMath.sol';
+import './interfaces/IERC20.sol';
+import './interfaces/IWETH.sol';
+```
+
+వీటిలో చాలా వరకు మేము ఇంతకుముందు ఎదుర్కొన్నాము, లేదా చాలా స్పష్టంగా ఉన్నాయి. ఒక మినహాయింపు `IWETH.sol`. యూనిస్వాప్ v2 ఏ జత ERC-20 టోకెన్లకైనా మార్పిడులను అనుమతిస్తుంది, కానీ ether (ETH) స్వయంగా ERC-20 టోకెన్ కాదు. ఇది ప్రమాణానికి ముందుది మరియు ప్రత్యేక యంత్రాంగాల ద్వారా బదిలీ చేయబడుతుంది. ERC-20 టోకెన్లకు వర్తించే ఒప్పందాలలో ETH వాడకాన్ని ప్రారంభించడానికి ప్రజలు [చుట్టబడిన ఈథర్ (WETH)](https://weth.tkn.eth.limo/) ఒప్పందంతో వచ్చారు. మీరు ఈ ఒప్పందానికి ETH ను పంపుతారు, మరియు అది మీకు సమానమైన WETH ను మింట్ చేస్తుంది. లేదా మీరు WETH ను బర్న్ చేసి, ETH ను తిరిగి పొందవచ్చు.
+
+```solidity
+contract UniswapV2Router02 is IUniswapV2Router02 {
+    using SafeMath for uint;
+
+    address public immutable override factory;
+    address public immutable override WETH;
+```
+
+రౌటర్ ఏ ఫ్యాక్టరీని ఉపయోగించాలో తెలుసుకోవాలి, మరియు WETH అవసరమయ్యే లావాదేవీల కోసం ఏ WETH ఒప్పందాన్ని ఉపయోగించాలో తెలుసుకోవాలి. ఈ విలువలు [మార్పులేనివి](https://docs.soliditylang.org/en/v0.8.3/contracts.html#constant-and-immutable-state-variables), అంటే అవి నిర్మాణకర్తలో మాత్రమే సెట్ చేయబడతాయి. ఇది వినియోగదారులకు వాటిని తక్కువ నిజాయితీ గల ఒప్పందాలకు మార్చడానికి ఎవరూ మార్చలేరనే విశ్వాసాన్ని ఇస్తుంది.
+
+```solidity
+    modifier ensure(uint deadline) {
+        require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
+        _;
+    }
+```
+
+ఈ మాడిఫైయర్ కాలపరిమితి గల లావాదేవీలు ("సమయం Y కంటే ముందు X చేయండి, ఒకవేళ వీలైతే") వాటి కాలపరిమితి తర్వాత జరగకుండా చూస్తుంది.
+
+```solidity
+    constructor(address _factory, address _WETH) public {
+        factory = _factory;
+        WETH = _WETH;
+    }
+```
+
+నిర్మాణకర్త మార్పులేని స్థితి వేరియబుల్స్ ను సెట్ చేస్తుంది.
+
+```solidity
+    receive() external payable {
+        assert(msg.sender == WETH); // WETH ఒప్పందం నుండి ఫాల్‌బ్యాక్ ద్వారా మాత్రమే ETH ని అంగీకరించండి
+    }
+```
+
+WETH ఒప్పందం నుండి టోకెన్లను తిరిగి ETH గా విమోచించుకున్నప్పుడు ఈ ఫంక్షన్ పిలవబడుతుంది. మేము ఉపయోగించే WETH ఒప్పందం మాత్రమే అలా చేయడానికి అధికారం కలిగి ఉంది.
+
+#### ద్రవ్యతను జోడించండి {#add-liquidity}
+
+ఈ ఫంక్షన్లు జత మార్పిడికి టోకెన్లను జోడిస్తాయి, ఇది ద్రవ్యత్వ పూల్ ను పెంచుతుంది.
+
+```solidity
+
+    // **** ద్రవ్యతను జోడించండి ****
+    function _addLiquidity(
+```
+
+ఈ ఫంక్షన్ జత మార్పిడిలోకి డిపాజిట్ చేయవలసిన A మరియు B టోకెన్ల మొత్తాన్ని లెక్కించడానికి ఉపయోగించబడుతుంది.
+
+```solidity
+        address tokenA,
+        address tokenB,
+```
+
+ఇవి ERC-20 టోకెన్ ఒప్పందాల చిరునామాలు.
+
+```solidity
+        uint amountADesired,
+        uint amountBDesired,
+```
+
+ఇవి ద్రవ్యత్వ ప్రదాత డిపాజిట్ చేయాలనుకుంటున్న మొత్తాలు. ఇవి డిపాజిట్ చేయవలసిన గరిష్ట మొత్తాలు A మరియు B.
+
+```solidity
+        uint amountAMin,
+        uint amountBMin
+```
+
+ఇవి డిపాజిట్ చేయడానికి కనీస ఆమోదయోగ్యమైన మొత్తాలు. లావాదేవీ ఈ మొత్తాలతో లేదా అంతకంటే ఎక్కువతో జరగలేకపోతే, దాని నుండి తిరిగి రండి. మీకు ఈ ఫీచర్ వద్దనుకుంటే, కేవలం సున్నాను పేర్కొనండి.
+
+ద్రవ్యత్వ ప్రదాతలు సాధారణంగా ఒక కనీస మొత్తాన్ని పేర్కొంటారు, ఎందుకంటే వారు లావాదేవీని ప్రస్తుత రేటుకు దగ్గరగా ఉండే మార్పిడి రేటుకు పరిమితం చేయాలనుకుంటారు. మార్పిడి రేటు చాలా ఎక్కువ హెచ్చుతగ్గులకు గురైతే, అది అంతర్లీన విలువలను మార్చే వార్తలను సూచిస్తుంది, మరియు వారు ఏమి చేయాలో మాన్యువల్ గా నిర్ణయించుకోవాలనుకుంటారు.
+
+ఉదాహరణకు, మార్పిడి రేటు ఒకటికి ఒకటిగా ఉన్న ఒక సందర్భాన్ని ఊహించండి మరియు ద్రవ్యత్వ ప్రదాత ఈ విలువలను పేర్కొంటారు:
+
+| పరామితి       | విలువ |
+| ------------- | ----: |
+| కోరిన మొత్తంA |  1000 |
+| కోరిన మొత్తంB |  1000 |
+| కనీస మొత్తంA  |   900 |
+| కనీస మొత్తంB  |   800 |
+
+మార్పిడి రేటు 0.9 మరియు 1.25 మధ్య ఉన్నంత కాలం, లావాదేవీ జరుగుతుంది. మార్పిడి రేటు ఆ పరిధి నుండి బయటకు వెళితే, లావాదేవీ రద్దు చేయబడుతుంది.
+
+ఈ జాగ్రత్తకు కారణం లావాదేవీలు తక్షణమే జరగవు, మీరు వాటిని సమర్పిస్తారు మరియు చివరికి ఒక ధృవీకరణకర్త వాటిని ఒక బ్లాక్‌లో చేర్చబోతున్నాడు (మీ గ్యాస్ ధర చాలా తక్కువగా ఉంటే తప్ప, ఆ సందర్భంలో మీరు దానిని ఓవర్‌రైట్ చేయడానికి అదే నోన్స్ మరియు అధిక గ్యాస్ ధరతో మరొక లావాదేవీని సమర్పించవలసి ఉంటుంది). సమర్పణ మరియు చేర్పు మధ్య వ్యవధిలో ఏమి జరుగుతుందో మీరు నియంత్రించలేరు.
+
+```solidity
+    ) internal virtual returns (uint amountA, uint amountB) {
+```
+
+ద్రవ్యత్వ ప్రదాత నిల్వల మధ్య ప్రస్తుత నిష్పత్తికి సమానమైన నిష్పత్తిని కలిగి ఉండటానికి డిపాజిట్ చేయవలసిన మొత్తాలను ఫంక్షన్ తిరిగి ఇస్తుంది.
+
+```solidity
+        // ఇంకా జత లేకపోతే దాన్ని సృష్టించండి
+        if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
+            IUniswapV2Factory(factory).createPair(tokenA, tokenB);
+        }
+```
+
+ఈ టోకెన్ జత కోసం ఇంకా మార్పిడి లేకపోతే, దానిని సృష్టించండి.
+
+```solidity
+        (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
+```
+
+జతలో ప్రస్తుత నిల్వలను పొందండి.
+
+```solidity
+        if (reserveA == 0 && reserveB == 0) {
+            (amountA, amountB) = (amountADesired, amountBDesired);
+```
+
+ప్రస్తుత నిల్వలు ఖాళీగా ఉంటే ఇది కొత్త జత మార్పిడి. డిపాజిట్ చేయవలసిన మొత్తాలు ద్రవ్యత్వ ప్రదాత అందించాలనుకుంటున్న వాటికి సరిగ్గా సమానంగా ఉండాలి.
+
+```solidity
+        } else {
+            uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
+```
+
+మొత్తాలు ఎలా ఉంటాయో చూడాలనుకుంటే, మేము [ఈ ఫంక్షన్](https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol#L35) ఉపయోగించి ఉత్తమమైన మొత్తాన్ని పొందుతాము. మేము ప్రస్తుత నిల్వల మాదిరిగానే నిష్పత్తిని కోరుకుంటున్నాము.
+
+```solidity
+            if (amountBOptimal <= amountBDesired) {
+                require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
+                (amountA, amountB) = (amountADesired, amountBOptimal);
+```
+
+`amountBOptimal` ద్రవ్యత్వ ప్రదాత డిపాజిట్ చేయాలనుకుంటున్న మొత్తం కంటే తక్కువగా ఉంటే, టోకెన్ B ప్రస్తుతం ద్రవ్యత్వ డిపాజిటర్ భావించే దానికంటే ఎక్కువ విలువైనదని అర్థం, కాబట్టి తక్కువ మొత్తం అవసరం.
+
+```solidity
+            } else {
+                uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA);
+                assert(amountAOptimal <= amountADesired);
+                require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
+                (amountA, amountB) = (amountAOptimal, amountBDesired);
+```
+
+ఉత్తమ B మొత్తం కోరిన B మొత్తం కంటే ఎక్కువగా ఉంటే, B టోకెన్లు ప్రస్తుతం ద్రవ్యత్వ డిపాజిటర్ భావించే దానికంటే తక్కువ విలువైనవని అర్థం, కాబట్టి అధిక మొత్తం అవసరం. అయినప్పటికీ, కోరిన మొత్తం గరిష్టంగా ఉంటుంది, కాబట్టి మేము అలా చేయలేము. బదులుగా మేము కోరిన B టోకెన్ల మొత్తానికి ఉత్తమమైన A టోకెన్ల సంఖ్యను లెక్కించుకుంటాము.
+
+అన్నింటినీ కలిపి మనం ఈ గ్రాఫ్ ను పొందుతాము. మీరు వెయ్యి A టోకెన్లు (నీలి గీత) మరియు వెయ్యి B టోకెన్లు (ఎరుపు గీత) డిపాజిట్ చేయడానికి ప్రయత్నిస్తున్నారని అనుకుందాం. x అక్షం మార్పిడి రేటు, A/B. x=1 అయితే, అవి విలువలో సమానంగా ఉంటాయి మరియు మీరు ప్రతి దాని నుండి వెయ్యి డిపాజిట్ చేస్తారు. x=2 అయితే, A విలువ B కంటే రెండు రెట్లు ఎక్కువ (ప్రతి A టోకెన్ కు రెండు B టోకెన్లు పొందుతారు) కాబట్టి మీరు వెయ్యి B టోకెన్లను డిపాజిట్ చేస్తారు, కానీ కేవలం 500 A టోకెన్లను మాత్రమే. x=0.5 అయితే, పరిస్థితి రివర్స్ అవుతుంది, వెయ్యి A టోకెన్లు మరియు ఐదు వందల B టోకెన్లు.
+
+![గ్రాఫ్](liquidityProviderDeposit.png)
+
+మీరు ద్రవ్యతను నేరుగా కోర్ ఒప్పందంలోకి డిపాజిట్ చేయవచ్చు ( [UniswapV2Pair::mint](https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L110) ఉపయోగించి), కానీ కోర్ ఒప్పందం అది మోసగించబడలేదని మాత్రమే తనిఖీ చేస్తుంది, కాబట్టి మీరు మీ లావాదేవీని సమర్పించిన సమయం మరియు అది అమలు చేయబడిన సమయం మధ్య మార్పిడి రేటు మారితే మీరు విలువను కోల్పోయే ప్రమాదం ఉంది. మీరు పెరిఫెరీ ఒప్పందాన్ని ఉపయోగిస్తే, అది మీరు డిపాజిట్ చేయవలసిన మొత్తాన్ని లెక్కిస్తుంది మరియు దానిని వెంటనే డిపాజిట్ చేస్తుంది, కాబట్టి మార్పిడి రేటు మారదు మరియు మీరు ఏమీ కోల్పోరు.
+
+```solidity
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint amountADesired,
+        uint amountBDesired,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+```
+
+ఈ ఫంక్షన్ ద్రవ్యతను డిపాజిట్ చేయడానికి ఒక లావాదేవీ ద్వారా పిలవబడవచ్చు. చాలా పారామీటర్లు పైన ఉన్న `_addLiquidity` లోని వాటితో సమానంగా ఉంటాయి, రెండు మినహాయింపులతో:
+
+. `to` అనేది ద్రవ్యత్వ ప్రదాత యొక్క పూల్ లోని వాటాను చూపించడానికి ముద్రించబడిన కొత్త ద్రవ్యత్వ టోకెన్లను పొందే చిరునామా
+. `deadline` అనేది లావాదేవీపై ఒక కాలపరిమితి
+
+```solidity
+    ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
+        (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
+        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
+```
+
+మేము వాస్తవంగా డిపాజిట్ చేయవలసిన మొత్తాలను లెక్కిస్తాము, ఆపై ద్రవ్యత్వ పూల్ యొక్క చిరునామాను కనుగొంటాము. గ్యాస్ ఆదా చేయడానికి మేము ఫ్యాక్టరీని అడగడం ద్వారా ఇది చేయము, కానీ లైబ్రరీ ఫంక్షన్ `pairFor` (లైబ్రరీలలో క్రింద చూడండి) ను ఉపయోగిస్తాము.
+
+```solidity
+        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
+        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
+```
+
+వినియోగదారు నుండి సరైన మొత్తంలో టోకెన్లను జత మార్పిడిలోకి బదిలీ చేయండి.
+
+```solidity
+        liquidity = IUniswapV2Pair(pair).mint(to);
+```
+
+ప్రతిఫలంగా `to` చిరునామాకు పూల్ లో పాక్షిక యాజమాన్యం కోసం ద్రవ్యత్వ టోకెన్లను ఇవ్వండి. కోర్ ఒప్పందం యొక్క `mint` ఫంక్షన్ దాని వద్ద ఎన్ని అదనపు టోకెన్లు ఉన్నాయో చూస్తుంది (ద్రవ్యత చివరిసారి మారినప్పుడు దాని వద్ద ఉన్న దానితో పోలిస్తే) మరియు దానికి అనుగుణంగా ద్రవ్యతను మింట్ చేస్తుంది.
+
+```solidity
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+```
+
+ఒక ద్రవ్యత్వ ప్రదాత టోకెన్/ETH జత మార్పిడికి ద్రవ్యతను అందించాలనుకున్నప్పుడు, కొన్ని తేడాలు ఉన్నాయి. ద్రవ్యత్వ ప్రదాత కోసం ETH ను చుట్టే పనిని ఒప్పందం నిర్వహిస్తుంది. వినియోగదారు ఎన్ని ETH డిపాజిట్ చేయాలనుకుంటున్నారో పేర్కొనవలసిన అవసరం లేదు, ఎందుకంటే వినియోగదారు వాటిని లావాదేవీతో పంపుతారు (మొత్తం `msg.value` లో అందుబాటులో ఉంటుంది).
+
+```solidity
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
+        (amountToken, amountETH) = _addLiquidity(
+            token,
+            WETH,
+            amountTokenDesired,
+            msg.value,
+            amountTokenMin,
+            amountETHMin
+        );
+        address pair = UniswapV2Library.pairFor(factory, token, WETH);
+        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
+        IWETH(WETH).deposit{value: amountETH}();
+        assert(IWETH(WETH).transfer(pair, amountETH));
+```
+
+ETH ను డిపాజిట్ చేయడానికి ఒప్పందం మొదట దానిని WETH గా చుట్టి, ఆపై WETH ను జతలోకి బదిలీ చేస్తుంది. బదిలీ `assert` లో చుట్టబడిందని గమనించండి. దీని అర్థం బదిలీ విఫలమైతే ఈ ఒప్పంద కాల్ కూడా విఫలమవుతుంది, అందువల్ల చుట్టేది వాస్తవంగా జరగదు.
+
+```solidity
+        liquidity = IUniswapV2Pair(pair).mint(to);
+        // దుమ్ము ఈథర్ ను తిరిగి చెల్లించండి, ఏదైనా ఉంటే
+        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
+```
+
+వినియోగదారు మాకు ఇప్పటికే ETH ను పంపారు, కాబట్టి ఏదైనా అదనంగా మిగిలి ఉంటే (ఎందుకంటే ఇతర టోకెన్ వినియోగదారు భావించిన దానికంటే తక్కువ విలువైనది), మేము వాపసు జారీ చేయాలి.
+
+#### ద్రవ్యతను తొలగించండి {#remove-liquidity}
+
+ఈ ఫంక్షన్లు ద్రవ్యతను తొలగించి, ద్రవ్యత్వ ప్రదాతకు తిరిగి చెల్లిస్తాయి.
+
+```solidity
+    // **** ద్రవ్యతను తొలగించండి ****
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
+```
+
+ద్రవ్యతను తొలగించే అత్యంత సులభమైన సందర్భం. ద్రవ్యత్వ ప్రదాత అంగీకరించడానికి ప్రతి టోకెన్ యొక్క కనీస మొత్తం ఉంది, మరియు అది గడువు తేదీకి ముందు జరగాలి.
+
+```solidity
+        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
+        IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // ద్రవ్యతను జతకు పంపండి
+        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
+```
+
+కోర్ ఒప్పందం యొక్క `burn` ఫంక్షన్ వినియోగదారుకు టోకెన్లను తిరిగి చెల్లించే పనిని నిర్వహిస్తుంది.
+
+```solidity
+        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
+```
+
+ఒక ఫంక్షన్ బహుళ విలువలను తిరిగి ఇచ్చినప్పుడు, కానీ మనం వాటిలో కొన్నింటిపై మాత్రమే ఆసక్తి కలిగి ఉన్నప్పుడు, మనం ఆ విలువలను మాత్రమే పొందే విధానం ఇది. ఒక విలువను చదివి ఎప్పుడూ ఉపయోగించకపోవడం కంటే గ్యాస్ పరంగా ఇది కొంత చౌకైనది.
+
+```solidity
+        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
+```
+
+కోర్ ఒప్పందం వాటిని తిరిగి ఇచ్చే విధానం (తక్కువ చిరునామా టోకెన్ మొదట) నుండి వినియోగదారు వాటిని ఆశించే విధానానికి (`tokenA` మరియు `tokenB` కు అనుగుణంగా) మొత్తాలను అనువదించండి.
+
+```solidity
+        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
+        require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
+    }
+```
+
+మొదట బదిలీ చేసి, ఆపై అది చట్టబద్ధమైనదేనా అని ధృవీకరించడం సరే, ఎందుకంటే అది కాకపోతే మనం అన్ని స్థితి మార్పుల నుండి తిరిగి వస్తాము.
+
+```solidity
+    function removeLiquidityETH(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) public virtual override ensure(deadline) returns (uint amountToken, uint amountETH) {
+        (amountToken, amountETH) = removeLiquidity(
+            token,
+            WETH,
+            liquidity,
+            amountTokenMin,
+            amountETHMin,
+            address(this),
+            deadline
+        );
+        TransferHelper.safeTransfer(token, to, amountToken);
+        IWETH(WETH).withdraw(amountETH);
+        TransferHelper.safeTransferETH(to, amountETH);
+    }
+```
+
+ETH కోసం ద్రవ్యతను తొలగించడం దాదాపు అదే, కానీ మేము WETH టోకెన్లను స్వీకరించి, ఆపై వాటిని ETH కోసం విమోచించి, ద్రవ్యత్వ ప్రదాతకు తిరిగి ఇస్తాము.
+
+```solidity
+    function removeLiquidityWithPermit(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external virtual override returns (uint amountA, uint amountB) {
+        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
+        uint value = approveMax ? uint(-1) : liquidity;
+        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
+        (amountA, amountB) = removeLiquidity(tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline);
+    }
+
+
+    function removeLiquidityETHWithPermit(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external virtual override returns (uint amountToken, uint amountETH) {
+        address pair = UniswapV2Library.pairFor(factory, token, WETH);
+        uint value = approveMax ? uint(-1) : liquidity;
+        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
+        (amountToken, amountETH) = removeLiquidityETH(token, liquidity, amountTokenMin, amountETHMin, to, deadline);
+    }
+```
+
+ఈ ఫంక్షన్లు ఈథర్ లేని వినియోగదారులను పూల్ నుండి ఉపసంహరించుకోవడానికి మెటా-లావాదేవీలను రిలే చేస్తాయి, [అనుమతి యంత్రాంగం](#UniswapV2ERC20) ను ఉపయోగిస్తాయి.
+
+```solidity
+
+    // **** ద్రవ్యతను తొలగించండి (రుసుము-బదిలీ టోకెన్లకు మద్దతు ఇస్తుంది) ****
+    function removeLiquidityETHSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) public virtual override ensure(deadline) returns (uint amountETH) {
+        (, amountETH) = removeLiquidity(
+            token,
+            WETH,
+            liquidity,
+            amountTokenMin,
+            amountETHMin,
+            address(this),
+            deadline
+        );
+        TransferHelper.safeTransfer(token, to, IERC20(token).balanceOf(address(this)));
+        IWETH(WETH).withdraw(amountETH);
+        TransferHelper.safeTransferETH(to, amountETH);
+    }
+
+```
+
+బదిలీ లేదా నిల్వ రుసుములు ఉన్న టోకెన్ల కోసం ఈ ఫంక్షన్ ను ఉపయోగించవచ్చు. ఒక టోకెన్ కు అలాంటి రుసుములు ఉన్నప్పుడు, మేము ఎంత టోకెన్ తిరిగి పొందాలో చెప్పడానికి `removeLiquidity` ఫంక్షన్ పై ఆధారపడలేము, కాబట్టి మేము మొదట ఉపసంహరించుకుని, ఆపై బ్యాలెన్స్ ను పొందాలి.
+
+```solidity
+
+
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external virtual override returns (uint amountETH) {
+        address pair = UniswapV2Library.pairFor(factory, token, WETH);
+        uint value = approveMax ? uint(-1) : liquidity;
+        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
+        amountETH = removeLiquidityETHSupportingFeeOnTransferTokens(
+            token, liquidity, amountTokenMin, amountETHMin, to, deadline
+        );
+    }
+```
+
+తుది ఫంక్షన్ మెటా-లావాదేవీలతో నిల్వ రుసుములను కలుపుతుంది.
+
+#### వర్తకం {#trade}
+
+```solidity
+    // **** స్వాప్ ****
+    // ప్రారంభ మొత్తాన్ని ఇప్పటికే మొదటి జతకు పంపవలసి ఉంటుంది
+    function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
+```
+
+ఈ ఫంక్షన్ వర్తకులకు అందుబాటులో ఉండే ఫంక్షన్‌ల కోసం అవసరమైన అంతర్గత ప్రాసెసింగ్‌ను నిర్వహిస్తుంది.
+
+```solidity
+        for (uint i; i < path.length - 1; i++) {
+```
+
+నేను ఇది వ్రాస్తున్నప్పుడు [388,160 ERC-20 టోకెన్లు](https://eth.blockscout.com/tokens) ఉన్నాయి. ప్రతి టోకెన్ జతకు ఒక జత ఎక్స్ఛేంజ్ ఉంటే, అది 150 బిలియన్లకు పైగా జత ఎక్స్ఛేంజ్‌లు అవుతుంది. ప్రస్తుతానికి, మొత్తం గొలుసులో, [ఖాతాల సంఖ్యలో కేవలం 0.1% మాత్రమే ఉంది](https://eth.blockscout.com/stats/accountsGrowth). దానికి బదులుగా, స్వాప్ ఫంక్షన్‌లు పాత్ భావనకు మద్దతు ఇస్తాయి. ఒక వర్తకుడు A ని B కి, B ని C కి, మరియు C ని D కి మార్చుకోవచ్చు, కాబట్టి ప్రత్యక్ష A-D జత మార్పిడి అవసరం లేదు.
+
+ఈ మార్కెట్లలోని ధరలు సమకాలీకరించబడతాయి, ఎందుకంటే అవి సమకాలీకరణలో లేనప్పుడు మధ్యవర్తిత్వానికి అవకాశం ఏర్పడుతుంది. ఉదాహరణకు, మూడు టోకెన్లు A, B, మరియు C అని ఊహించుకోండి. ప్రతి జతకు ఒకటి చొప్పున మూడు జతల మార్పిడిలు ఉన్నాయి.
+
+1. ప్రారంభ పరిస్థితి
+2. ఒక వర్తకుడు 24.695 A టోకెన్లను అమ్మి, 25.305 B టోకెన్లను పొందుతాడు.
+3. వర్తకుడు 24.695 B టోకెన్లను 25.305 C టోకెన్లకు అమ్మి, లాభంగా సుమారు 0.61 B టోకెన్లను ఉంచుకుంటాడు.
+4. తర్వాత వర్తకుడు 24.695 C టోకెన్లను 25.305 A టోకెన్లకు అమ్మి, సుమారు 0.61 C టోకెన్లను లాభంగా ఉంచుకుంటాడు. వర్తకుడికి 0.61 అదనపు A టోకెన్లు కూడా ఉన్నాయి (వర్తకుడు చివరికి పొందిన 25.305, అసలు పెట్టుబడి అయిన 24.695 మినహా).
+
+| దశ | A-B ఎక్స్ఛేంజ్                                                                              | B-C ఎక్స్ఛేంజ్                                                                              | A-C ఎక్స్ఛేంజ్                                                                              |
+| -- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| 1  | A:1000 B:1050 A/B=1.05                      | B:1000 C:1050 B/C=1.05                      | A:1050 C:1000 C/A=1.05                      |
+| 2  | A:1024.695 B:1024.695 A/B=1 | B:1000 C:1050 B/C=1.05                      | A:1050 C:1000 C/A=1.05                      |
+| 3  | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1050 C:1000 C/A=1.05                      |
+| 4  | A:1024.695 B:1024.695 A/B=1 | B:1024.695 C:1024.695 B/C=1 | A:1024.695 C:1024.695 C/A=1 |
+
+```solidity
+            (address input, address output) = (path[i], path[i + 1]);
+            (address token0,) = UniswapV2Library.sortTokens(input, output);
+            uint amountOut = amounts[i + 1];
+```
+
+మనం ప్రస్తుతం నిర్వహిస్తున్న జతను పొందండి, దానిని క్రమబద్ధీకరించండి (జతతో ఉపయోగం కోసం) మరియు ఊహించిన అవుట్‌పుట్ మొత్తాన్ని పొందండి.
+
+```solidity
+            (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0));
+```
+
+ఊహించిన అవుట్ మొత్తాలను పొందండి, జత మార్పిడి వాటిని ఆశించే విధంగా క్రమబద్ధీకరించబడింది.
+
+```solidity
+            address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
+```
+
+ఇది చివరి మార్పిడియా? అవును అయితే, వర్తకం కోసం అందుకున్న టోకెన్లను గమ్యస్థానానికి పంపండి. కాకపోతే, దాన్ని తదుపరి జత మార్పిడికి పంపండి.
+
+```solidity
+
+            IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap(
+                amount0Out, amount1Out, to, new bytes(0)
+            );
+        }
+    }
+```
+
+టోకెన్లను మార్చడానికి జత మార్పిడిని వాస్తవానికి కాల్ చేయండి. మార్పిడి గురించి మాకు తెలియజేయడానికి మాకు కాల్‌బ్యాక్ అవసరం లేదు, కాబట్టి మేము ఆ ఫీల్డ్‌లో ఏ బైట్‌లను పంపము.
+
+```solidity
+    function swapExactTokensForTokens(
+```
+
+ఈ ఫంక్షన్‌ను వర్తకులు ఒక టోకెన్‌ను మరొకదానికి మార్చడానికి నేరుగా ఉపయోగిస్తారు.
+
+```solidity
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+```
+
+ఈ పరామితి ERC-20 కాంట్రాక్టుల చిరునామాలను కలిగి ఉంటుంది. పైన వివరించినట్లుగా, ఇది ఒక శ్రేణి ఎందుకంటే మీరు మీ దగ్గర ఉన్న ఆస్తి నుండి మీకు కావలసిన ఆస్తిని పొందడానికి అనేక జత మార్పిడిల ద్వారా వెళ్ళవలసి రావచ్చు.
+
+Solidityలోని ఒక ఫంక్షన్ పరామితిని `memory` లేదా `calldata`లో నిల్వ చేయవచ్చు. ఒకవేళ ఫంక్షన్ కాంట్రాక్ట్‌కు ఎంట్రీ పాయింట్ అయితే, వినియోగదారు (ఒక లావాదేవీని ఉపయోగించి) నుండి లేదా వేరే కాంట్రాక్ట్ నుండి నేరుగా కాల్ చేయబడితే, అప్పుడు పరామితి విలువను కాల్ డేటా నుండి నేరుగా తీసుకోవచ్చు. పైన `_swap` వలె, ఫంక్షన్‌ను అంతర్గతంగా కాల్ చేస్తే, అప్పుడు పరామితులను `memory`లో నిల్వ చేయాలి. కాల్ చేయబడిన కాంట్రాక్ట్ దృక్కోణం నుండి `calldata` కేవలం చదవడానికి మాత్రమే.
+
+`uint` లేదా `address` వంటి స్కేలార్ రకాలతో, కంపైలర్ మా కోసం నిల్వ ఎంపికను నిర్వహిస్తుంది, కానీ శ్రేణులతో, అవి పొడవుగా మరియు ఖరీదైనవిగా ఉంటాయి, మేము ఉపయోగించాల్సిన నిల్వ రకాన్ని నిర్దేశిస్తాము.
+
+```solidity
+        address to,
+        uint deadline
+    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
+```
+
+తిరిగి వచ్చే విలువలు ఎల్లప్పుడూ మెమరీలో తిరిగి వస్తాయి.
+
+```solidity
+        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
+        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+```
+
+ప్రతి స్వాప్‌లో కొనుగోలు చేయవలసిన మొత్తాన్ని లెక్కించండి. ఫలితం వర్తకుడు అంగీకరించడానికి ఇష్టపడే కనీస మొత్తం కంటే తక్కువగా ఉంటే, లావాదేవీ నుండి తిరిగి వెళ్ళండి.
+
+```solidity
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, to);
+    }
+```
+
+చివరగా, ప్రారంభ ERC-20 టోకెన్‌ను మొదటి జత మార్పిడి ఖాతాకు బదిలీ చేసి, `_swap`ను కాల్ చేయండి. ఇదంతా ఒకే లావాదేవీలో జరుగుతోంది, కాబట్టి ఊహించని టోకెన్లు ఈ బదిలీలో భాగంగా ఉన్నాయని జత మార్పిడికి తెలుసు.
+
+```solidity
+    function swapTokensForExactTokens(
+        uint amountOut,
+        uint amountInMax,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external virtual override ensure(deadline) returns (uint[] memory amounts) {
+        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
+        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, to);
+    }
+```
+
+మునుపటి ఫంక్షన్, `swapTokensForTokens`, వర్తకుడికి అతను ఇవ్వడానికి ఇష్టపడే ఖచ్చితమైన ఇన్‌పుట్ టోకెన్‌ల సంఖ్యను మరియు దానికి బదులుగా అతను స్వీకరించడానికి ఇష్టపడే కనీస అవుట్‌పుట్ టోకెన్‌ల సంఖ్యను పేర్కొనడానికి అనుమతిస్తుంది. ఈ ఫంక్షన్ రివర్స్ స్వాప్‌ను చేస్తుంది, ఇది వర్తకుడికి అతను కోరుకునే అవుట్‌పుట్ టోకెన్‌ల సంఖ్యను మరియు వాటి కోసం అతను చెల్లించడానికి ఇష్టపడే గరిష్ట ఇన్‌పుట్ టోకెన్‌ల సంఖ్యను పేర్కొనడానికి అనుమతిస్తుంది.
+
+రెండు సందర్భాల్లో, వర్తకుడు మొదట ఈ పెరిఫెరీ కాంట్రాక్ట్‌కు వాటిని బదిలీ చేయడానికి అనుమతించే భత్యాన్ని ఇవ్వాలి.
+
+```solidity
+    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        payable
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsOut(factory, msg.value, path);
+        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+        IWETH(WETH).deposit{value: amounts[0]}();
+        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
+        _swap(amounts, path, to);
+    }
+
+
+    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
+        require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, address(this));
+        IWETH(WETH).withdraw(amounts[amounts.length - 1]);
+        TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
+    }
+
+
+
+    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path);
+        require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]
+        );
+        _swap(amounts, path, address(this));
+        IWETH(WETH).withdraw(amounts[amounts.length - 1]);
+        TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
+    }
+
+
+    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+        external
+        virtual
+        override
+        payable
+        ensure(deadline)
+        returns (uint[] memory amounts)
+    {
+        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
+        amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path);
+        require(amounts[0] <= msg.value, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT');
+        IWETH(WETH).deposit{value: amounts[0]}();
+        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0]));
+        _swap(amounts, path, to);
+        // refund dust eth, if any
+        if (msg.value > amounts[0]) TransferHelper.safeTransferETH(msg.sender, msg.value - amounts[0]);
+    }
+```
+
+ఈ నాలుగు వేరియంట్‌లు అన్నీ ETH మరియు టోకెన్ల మధ్య వర్తకంతో ముడిపడి ఉన్నాయి. వర్తకుని నుండి మనం ETHని స్వీకరించి, దానిని WETHని ముద్రించడానికి ఉపయోగించడం లేదా మార్గంలో చివరి మార్పిడి నుండి WETHని స్వీకరించి, దానిని బర్న్ చేసి, ఫలితంగా వచ్చే ETHని వర్తకునికి తిరిగి పంపడం మాత్రమే తేడా.
+
+```solidity
+    // **** స్వాప్ (ఫీ-ఆన్-ట్రాన్స్‌ఫర్ టోకెన్‌లకు మద్దతు) ****
+    // ప్రారంభ మొత్తాన్ని ఇప్పటికే మొదటి జతకు పంపవలసి ఉంటుంది
+    function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual {
+```
+
+బదిలీ లేదా నిల్వ రుసుములు ఉన్న టోకెన్‌లను మార్చుకోవడానికి ఇది అంతర్గత ఫంక్షన్ ([ఈ సమస్యను](https://github.com/Uniswap/uniswap-interface/issues/835) పరిష్కరించడానికి).
+
+```solidity
+        for (uint i; i < path.length - 1; i++) {
+            (address input, address output) = (path[i], path[i + 1]);
+            (address token0,) = UniswapV2Library.sortTokens(input, output);
+            IUniswapV2Pair pair = IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output));
+            uint amountInput;
+            uint amountOutput;
+            { // స్టాక్ చాలా లోతుగా ఉండే లోపాలను నివారించడానికి స్కోప్
+            (uint reserve0, uint reserve1,) = pair.getReserves();
+            (uint reserveInput, uint reserveOutput) = input == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+            amountInput = IERC20(input).balanceOf(address(pair)).sub(reserveInput);
+            amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput);
+```
+
+బదిలీ రుసుముల కారణంగా, ప్రతి బదిలీ నుండి మనకు ఎంత లభిస్తుందో చెప్పడానికి `getAmountsOut` ఫంక్షన్‌పై మేము ఆధారపడలేము (అసలు `_swap`ను కాల్ చేయడానికి ముందు మేము చేసే విధంగా). దానికి బదులుగా మనం మొదట బదిలీ చేసి, తర్వాత మనకు ఎన్ని టోకెన్లు తిరిగి వచ్చాయో చూడాలి.
+
+గమనిక: సిద్ధాంతపరంగా మనం `_swap`కు బదులుగా ఈ ఫంక్షన్‌ను ఉపయోగించవచ్చు, కానీ కొన్ని సందర్భాల్లో (ఉదాహరణకు, అవసరమైన కనీస మొత్తాన్ని చేరుకోవడానికి చివరిలో తగినంతగా లేనందున బదిలీ తిరిగి మార్చబడితే) దానికి ఎక్కువ గ్యాస్ ఖర్చవుతుంది. ట్రాన్స్‌ఫర్ ఫీ టోకెన్లు చాలా అరుదుగా ఉంటాయి, కాబట్టి వాటికి అనుగుణంగా ఉండాల్సిన అవసరం ఉన్నప్పటికీ, అన్ని స్వాప్‌లు వాటిలో కనీసం ఒకదాని ద్వారా వెళ్తాయని ఊహించుకోవాల్సిన అవసరం లేదు.
+
+```solidity
+            }
+            (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOutput) : (amountOutput, uint(0));
+            address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to;
+            pair.swap(amount0Out, amount1Out, to, new bytes(0));
+        }
+    }
+
+
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external virtual override ensure(deadline) {
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
+        );
+        uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
+        _swapSupportingFeeOnTransferTokens(path, to);
+        require(
+            IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
+            'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
+        );
+    }
+
+
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    )
+        external
+        virtual
+        override
+        payable
+        ensure(deadline)
+    {
+        require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH');
+        uint amountIn = msg.value;
+        IWETH(WETH).deposit{value: amountIn}();
+        assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn));
+        uint balanceBefore = IERC20(path[path.length - 1]).balanceOf(to);
+        _swapSupportingFeeOnTransferTokens(path, to);
+        require(
+            IERC20(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin,
+            'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'
+        );
+    }
+
+
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    )
+        external
+        virtual
+        override
+        ensure(deadline)
+    {
+        require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH');
+        TransferHelper.safeTransferFrom(
+            path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn
+        );
+        _swapSupportingFeeOnTransferTokens(path, address(this));
+        uint amountOut = IERC20(WETH).balanceOf(address(this));
+        require(amountOut >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT');
+        IWETH(WETH).withdraw(amountOut);
+        TransferHelper.safeTransferETH(to, amountOut);
+    }
+```
+
+ఇవి సాధారణ టోకెన్ల కోసం ఉపయోగించే అదే వేరియంట్‌లు, కానీ అవి బదులుగా `_swapSupportingFeeOnTransferTokens`ను కాల్ చేస్తాయి.
+
+```solidity
+    // **** లైబ్రరీ ఫంక్షన్‌లు ****
+    function quote(uint amountA, uint reserveA, uint reserveB) public pure virtual override returns (uint amountB) {
+        return UniswapV2Library.quote(amountA, reserveA, reserveB);
+    }
+
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut)
+        public
+        pure
+        virtual
+        override
+        returns (uint amountOut)
+    {
+        return UniswapV2Library.getAmountOut(amountIn, reserveIn, reserveOut);
+    }
+
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut)
+        public
+        pure
+        virtual
+        override
+        returns (uint amountIn)
+    {
+        return UniswapV2Library.getAmountIn(amountOut, reserveIn, reserveOut);
+    }
+
+    function getAmountsOut(uint amountIn, address[] memory path)
+        public
+        view
+        virtual
+        override
+        returns (uint[] memory amounts)
+    {
+        return UniswapV2Library.getAmountsOut(factory, amountIn, path);
+    }
+
+    function getAmountsIn(uint amountOut, address[] memory path)
+        public
+        view
+        virtual
+        override
+        returns (uint[] memory amounts)
+    {
+        return UniswapV2Library.getAmountsIn(factory, amountOut, path);
+    }
+}
+```
+
+ఈ ఫంక్షన్‌లు [UniswapV2Library ఫంక్షన్‌లను](#uniswapV2library) కాల్ చేసే ప్రాక్సీలు మాత్రమే.
+
+### UniswapV2Migrator.sol {#UniswapV2Migrator}
+
+ఈ కాంట్రాక్ట్ పాత v1 నుండి v2 కి ఎక్స్‌ఛేంజ్‌లను మైగ్రేట్ చేయడానికి ఉపయోగించబడింది. ఇప్పుడు అవి మైగ్రేట్ చేయబడ్డాయి, ఇది ఇకపై సంబంధితం కాదు.
+
+## లైబ్రరీలు {#libraries}
+
+[SafeMath లైబ్రరీ](https://docs.openzeppelin.com/contracts/2.x/api/math) బాగా డాక్యుమెంట్ చేయబడింది, కాబట్టి ఇక్కడ దానిని డాక్యుమెంట్ చేయవలసిన అవసరం లేదు.
+
+### గణితం {#Math}
+
+ఈ లైబ్రరీలో Solidity కోడ్‌లో సాధారణంగా అవసరం లేని కొన్ని గణిత ఫంక్షన్‌లు ఉన్నాయి, కాబట్టి అవి భాషలో భాగం కావు.
+
+```solidity
+pragma solidity =0.5.16;
+
+// వివిధ గణిత కార్యకలాపాలను నిర్వహించడానికి ఒక లైబ్రరీ
+
+library Math {
+    function min(uint x, uint y) internal pure returns (uint z) {
+        z = x < y ? x : y;
+    }
+
+    // బాబిలోనియన్ పద్ధతి (https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
+    function sqrt(uint y) internal pure returns (uint z) {
+        if (y > 3) {
+            z = y;
+            uint x = y / 2 + 1;
+```
+
+xను వర్గమూలానికి కంటే ఎక్కువగా ఉన్న అంచనాతో ప్రారంభించండి (అందుకే మనం 1-3ను ప్రత్యేక సందర్భాలుగా పరిగణించవలసి ఉంటుంది).
+
+```solidity
+            while (x < z) {
+                z = x;
+                x = (y / x + x) / 2;
+```
+
+మరింత దగ్గరి అంచనాను పొందండి, మునుపటి అంచనా యొక్క సగటు మరియు మనం వర్గమూలాన్ని కనుగొనడానికి ప్రయత్నిస్తున్న సంఖ్యను మునుపటి అంచనాతో భాగించడం. కొత్త అంచనా ప్రస్తుత దాని కంటే తక్కువగా లేనంత వరకు పునరావృతం చేయండి. మరిన్ని వివరాల కోసం, [ఇక్కడ చూడండి](https://wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method).
+
+```solidity
+            }
+        } else if (y != 0) {
+            z = 1;
+```
+
+మనకు సున్నా వర్గమూలం ఎప్పుడూ అవసరం లేదు. ఒకటి, రెండు మరియు మూడు వర్గమూలాలు సుమారు ఒకటి (మనం పూర్ణాంకాలను ఉపయోగిస్తాము, కాబట్టి మనం భిన్నాన్ని విస్మరిస్తాము).
+
+```solidity
+        }
+    }
+}
+```
+
+### స్థిర పాయింట్ భిన్నాలు (UQ112x112) {#FixedPoint}
+
+ఈ లైబ్రరీ భిన్నాలను నిర్వహిస్తుంది, ఇవి సాధారణంగా ఇతీరియము అంకగణితంలో భాగంగా ఉండవు. ఇది x సంఖ్యను x\*2^112గా ఎన్‌కోడ్ చేయడం ద్వారా చేస్తుంది. ఇది అసలు కూడిక మరియు తీసివేత ఆప్కోడ్లను మార్పు లేకుండా ఉపయోగించడానికి అనుమతిస్తుంది.
+
+```solidity
+pragma solidity =0.5.16;
+
+// బైనరీ ఫిక్స్‌డ్ పాయింట్ సంఖ్యలను నిర్వహించడానికి ఒక లైబ్రరీ (https://wikipedia.org/wiki/Q_(number_format))
+
+// పరిధి: [0, 2**112 - 1]
+// రిజల్యూషన్: 1 / 2**112
+
+library UQ112x112 {
+    uint224 constant Q112 = 2**112;
+```
+
+`Q112` అనేది ఒకటి కోసం ఎన్‌కోడింగ్.
+
+```solidity
+    // ఒక uint112ను UQ112x112గా ఎన్‌కోడ్ చేయండి
+    function encode(uint112 y) internal pure returns (uint224 z) {
+        z = uint224(y) * Q112; // ఎప్పటికీ ఓవర్‌ఫ్లో కాదు
+    }
+```
+
+y అనేది `uint112` కాబట్టి, అది గరిష్టంగా 2^112-1 కావచ్చు. ఆ సంఖ్యను ఇప్పటికీ `UQ112x112`గా ఎన్‌కోడ్ చేయవచ్చు.
+
+```solidity
+    // ఒక UQ112x112ను ఒక uint112తో భాగించి, UQ112x112ను తిరిగి ఇవ్వండి
+    function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
+        z = x / uint224(y);
+    }
+}
+```
+
+మనం రెండు `UQ112x112` విలువలను భాగిస్తే, ఫలితం ఇకపై 2^112తో గుణించబడదు. కాబట్టి బదులుగా మనం హారం కోసం ఒక పూర్ణాంకాన్ని తీసుకుంటాము. గుణకారం చేయడానికి కూడా మనం ఇలాంటి ట్రిక్‌ను ఉపయోగించాల్సి ఉండేది, కానీ `UQ112x112` విలువల గుణకారం మనం చేయవలసిన అవసరం లేదు.
+
+### UniswapV2Library {#uniswapV2library}
+
+ఈ లైబ్రరీ కేవలం పెరిఫెరీ కాంట్రాక్టుల ద్వారా మాత్రమే ఉపయోగించబడుతుంది.
+
+```solidity
+pragma solidity >=0.5.0;
+
+import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol';
+
+import "./SafeMath.sol";
+
+library UniswapV2Library {
+    using SafeMath for uint;
+
+    // క్రమబద్ధీకరించబడిన టోకెన్ చిరునామాలను తిరిగి ఇస్తుంది, ఈ క్రమంలో క్రమబద్ధీకరించబడిన జతల నుండి తిరిగి వచ్చే విలువలను నిర్వహించడానికి ఉపయోగిస్తారు
+    function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
+        require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
+        (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
+        require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
+    }
+```
+
+రెండు టోకెన్‌లను చిరునామా ద్వారా క్రమబద్ధీకరించండి, తద్వారా వాటి కోసం జత మార్పిడి చిరునామాను పొందగలుగుతాము. ఇది అవసరం ఎందుకంటే లేకపోతే మనకు రెండు అవకాశాలు ఉంటాయి, ఒకటి పరామితులు A,B కోసం మరియు మరొకటి పరామితులు B,A కోసం, ఇది ఒకదాని బదులుగా రెండు మార్పిడిలకు దారి తీస్తుంది.
+
+```solidity
+    // ఏ బాహ్య కాల్స్ చేయకుండా ఒక జత కోసం CREATE2 చిరునామాను లెక్కిస్తుంది
+    function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
+        (address token0, address token1) = sortTokens(tokenA, tokenB);
+        pair = address(uint(keccak256(abi.encodePacked(
+                hex'ff',
+                factory,
+                keccak256(abi.encodePacked(token0, token1)),
+                hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' // init code hash
+            ))));
+    }
+```
+
+ఈ ఫంక్షన్ రెండు టోకెన్ల కోసం జత మార్పిడి చిరునామాను లెక్కిస్తుంది. ఈ కాంట్రాక్ట్ [CREATE2 ఆప్కోడ్](https://eips.ethereum.org/EIPS/eip-1014) ఉపయోగించి సృష్టించబడింది, కాబట్టి అది ఉపయోగించే పరామితులను మనం తెలిస్తే, అదే అల్గారిథమ్ ఉపయోగించి చిరునామాను లెక్కించవచ్చు. ఇది ఫ్యాక్టరీని అడగడం కంటే చాలా చౌకైనది, మరియు
+
+```solidity
+    // ఒక జత కోసం రిజర్వ్‌లను పొందుతుంది మరియు క్రమబద్ధీకరిస్తుంది
+    function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
+        (address token0,) = sortTokens(tokenA, tokenB);
+        (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
+        (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
+    }
+```
+
+ఈ ఫంక్షన్ జత మార్పిడి వద్ద ఉన్న రెండు టోకెన్ల రిజర్వ్‌లను తిరిగి ఇస్తుంది. ఇది టోకెన్‌లను ఏ క్రమంలోనైనా స్వీకరించగలదని మరియు అంతర్గత ఉపయోగం కోసం వాటిని క్రమబద్ధీకరిస్తుందని గమనించండి.
+
+```solidity
+    // ఒక ఆస్తి యొక్క కొంత మొత్తం మరియు జత రిజర్వ్‌లు ఇవ్వబడినప్పుడు, ఇతర ఆస్తి యొక్క సమానమైన మొత్తాన్ని తిరిగి ఇస్తుంది
+    function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
+        require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
+        require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+        amountB = amountA.mul(reserveB) / reserveA;
+    }
+```
+
+ఈ ఫంక్షన్ ఎటువంటి రుసుము లేకుండా టోకెన్ Aకు బదులుగా మీరు ఎంత టోకెన్ B పొందుతారో తెలియజేస్తుంది. ఈ లెక్కింపు బదిలీ మార్పిడి రేటును మారుస్తుందని పరిగణనలోకి తీసుకుంటుంది.
+
+```solidity
+    // ఒక ఆస్తి యొక్క ఇన్‌పుట్ మొత్తం మరియు జత నిల్వలు ఇచ్చినప్పుడు, ఇతర ఆస్తి యొక్క గరిష్ట అవుట్‌పుట్ మొత్తాన్ని తిరిగి ఇస్తుంది
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
+```
+
+పైన ఉన్న `quote` ఫంక్షన్ జత మార్పిడిని ఉపయోగించడానికి ఎటువంటి రుసుము లేనప్పుడు గొప్పగా పనిచేస్తుంది. అయితే, 0.3% మార్పిడి రుసుము ఉన్నట్లయితే, మీరు వాస్తవానికి పొందే మొత్తం తక్కువగా ఉంటుంది. ఈ ఫంక్షన్ మార్పిడి రుసుము తర్వాత మొత్తాన్ని లెక్కిస్తుంది.
+
+```solidity
+
+        require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
+        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+        uint amountInWithFee = amountIn.mul(997);
+        uint numerator = amountInWithFee.mul(reserveOut);
+        uint denominator = reserveIn.mul(1000).add(amountInWithFee);
+        amountOut = numerator / denominator;
+    }
+```
+
+Solidity స్థానికంగా భిన్నాలను నిర్వహించదు, కాబట్టి మనం మొత్తాన్ని 0.997తో గుణించలేము. దానికి బదులుగా, మనం లవాన్ని 997తో మరియు హారాన్ని 1000తో గుణిస్తాము, అదే ప్రభావాన్ని సాధిస్తాము.
+
+```solidity
+    // ఒక ఆస్తి యొక్క అవుట్‌పుట్ మొత్తం మరియు జత నిల్వలు ఇచ్చినప్పుడు, ఇతర ఆస్తి యొక్క అవసరమైన ఇన్‌పుట్ మొత్తాన్ని తిరిగి ఇస్తుంది
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
+        require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
+        require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
+        uint numerator = reserveIn.mul(amountOut).mul(1000);
+        uint denominator = reserveOut.sub(amountOut).mul(997);
+        amountIn = (numerator / denominator).add(1);
+    }
+```
+
+ఈ ఫంక్షన్ సుమారుగా అదే పని చేస్తుంది, కానీ ఇది అవుట్‌పుట్ మొత్తాన్ని పొంది, ఇన్‌పుట్‌ను అందిస్తుంది.
+
+```solidity
+
+    // ఏ సంఖ్యలోనైనా జతల మీద చైన్డ్ గెట్అమౌంట్అవుట్ గణనలను చేస్తుంది
+    function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
+        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
+        amounts = new uint[](path.length);
+        amounts[0] = amountIn;
+        for (uint i; i < path.length - 1; i++) {
+            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
+            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
+        }
+    }
+
+    // ఏ సంఖ్యలోనైనా జతల మీద చైన్డ్ గెట్అమౌంట్ఇన్ గణనలను చేస్తుంది
+    function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
+        require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
+        amounts = new uint[](path.length);
+        amounts[amounts.length - 1] = amountOut;
+        for (uint i = path.length - 1; i > 0; i--) {
+            (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
+            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
+        }
+    }
+}
+```
+
+అనేక జతల మార్పిడిల ద్వారా వెళ్ళవలసిన అవసరం ఉన్నప్పుడు ఈ రెండు ఫంక్షన్‌లు విలువలను గుర్తించడంలో సహాయపడతాయి.
+
+### బదిలీ సహాయకం {#transfer-helper}
+
+[ఈ లైబ్రరీ](https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/TransferHelper.sol) ERC-20 మరియు ఇతీరియము బదిలీల చుట్టూ విజయవంతమైన తనిఖీలను జోడిస్తుంది, ఇది ఒక రివర్ట్ మరియు `false` విలువ రిటర్న్‌ను ఒకే విధంగా పరిగణిస్తుంది.
+
+```solidity
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity >=0.6.0;
+
+// నిరంతరం true/false తిరిగి ఇవ్వని ERC20 టోకెన్‌లతో పరస్పర చర్య మరియు ETH పంపడం కోసం సహాయక పద్ధతులు
+library TransferHelper {
+    function safeApprove(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        // bytes4(keccak256(bytes('approve(address,uint256)')));
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
+
+```
+
+మనం వేరే కాంట్రాక్ట్‌ను రెండు మార్గాలలో ఒకటిగా కాల్ చేయవచ్చు:
+
+- ఫంక్షన్ కాల్‌ను సృష్టించడానికి ఇంటర్‌ఫేస్ నిర్వచనాన్ని ఉపయోగించండి
+- కాల్‌ను సృష్టించడానికి [అప్లికేషన్ బైనరీ ఇంటర్‌ఫేస్ (ఎబిఐ)](https://docs.soliditylang.org/en/v0.8.3/abi-spec.html)ని "మాన్యువల్‌గా" ఉపయోగించండి. కోడ్ రచయిత దీన్ని చేయాలని నిర్ణయించుకున్నది ఇదే.
+
+```solidity
+        require(
+            success && (data.length == 0 || abi.decode(data, (bool))),
+            'TransferHelper::safeApprove: approve failed'
+        );
+    }
+```
+
+ERC-20 ప్రమాణానికి ముందు సృష్టించబడిన టోకెన్‌లతో వెనుకబడిన అనుకూలత కోసం, ఒక ERC-20 కాల్ రివర్ట్ చేయడం ద్వారా (ఈ సందర్భంలో `success` `false` అవుతుంది) లేదా విజయవంతమై, `false` విలువను తిరిగి ఇవ్వడం ద్వారా (ఈ సందర్భంలో అవుట్‌పుట్ డేటా ఉంటుంది, మరియు దానిని బూలియన్‌గా డీకోడ్ చేస్తే `false` వస్తుంది) విఫలం కావచ్చు.
+
+```solidity
+
+
+    function safeTransfer(
+        address token,
+        address to,
+        uint256 value
+    ) internal {
+        // bytes4(keccak256(bytes('transfer(address,uint256)')));
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
+        require(
+            success && (data.length == 0 || abi.decode(data, (bool))),
+            'TransferHelper::safeTransfer: transfer failed'
+        );
+    }
+```
+
+ఈ ఫంక్షన్ [ERC-20 యొక్క బదిలీ కార్యాచరణను](https://eips.ethereum.org/EIPS/eip-20#transfer) అమలు చేస్తుంది, ఇది ఒక ఖాతా వేరే ఖాతా ద్వారా అందించబడిన భత్యాన్ని ఖర్చు చేయడానికి అనుమతిస్తుంది.
+
+```solidity
+
+    function safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
+        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
+        require(
+            success && (data.length == 0 || abi.decode(data, (bool))),
+            'TransferHelper::transferFrom: transferFrom failed'
+        );
+    }
+```
+
+ఈ ఫంక్షన్ [ERC-20 యొక్క transferFrom కార్యాచరణను](https://eips.ethereum.org/EIPS/eip-20#transferfrom) అమలు చేస్తుంది, ఇది ఒక ఖాతా వేరే ఖాతా ద్వారా అందించబడిన భత్యాన్ని ఖర్చు చేయడానికి అనుమతిస్తుంది.
+
+```solidity
+
+    function safeTransferETH(address to, uint256 value) internal {
+        (bool success, ) = to.call{value: value}(new bytes(0));
+        require(success, 'TransferHelper::safeTransferETH: ETH transfer failed');
+    }
+}
+```
+
+ఈ ఫంక్షన్ ఒక ఖాతాకు ఈథర్‌ను బదిలీ చేస్తుంది. వేరే కాంట్రాక్ట్‌కు ఏదైనా కాల్ ఈథర్‌ను పంపడానికి ప్రయత్నించవచ్చు. మనకు ఏ ఫంక్షన్‌ను కాల్ చేయవలసిన అవసరం లేదు కాబట్టి, మనం కాల్‌తో ఏ డేటాను పంపము.
+
+## ముగింపు {#conclusion}
+
+ఇది సుమారు 50 పేజీల పొడవైన కథనం. మీరు ఇక్కడికి చేరుకున్నట్లయితే, అభినందనలు! ఇప్పటికి మీరు నిజ-జీవిత అప్లికేషన్‌ను వ్రాయడంలో (చిన్న నమూనా ప్రోగ్రామ్‌లకు విరుద్ధంగా) పరిగణనలను అర్థం చేసుకున్నారని మరియు మీ స్వంత వినియోగ కేసుల కోసం కాంట్రాక్టులను వ్రాయగలుగుతున్నారని ఆశిస్తున్నాము.
+
+ఇప్పుడు వెళ్లి ఉపయోగకరమైనది ఏదైనా వ్రాసి మమ్మల్ని ఆశ్చర్యపరచండి.
+
+[నా మరిన్ని పనుల కోసం ఇక్కడ చూడండి](https://cryptodocguy.pro/).
diff --git a/public/content/translations/te/developers/tutorials/using-websockets/index.md b/public/content/translations/te/developers/tutorials/using-websockets/index.md
new file mode 100644
index 00000000000..91377b966ac
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/using-websockets/index.md
@@ -0,0 +1,251 @@
+---
+title: "వెబ్ సాకెట్‌లను ఉపయోగించడం"
+description: "JSON-RPC అభ్యర్థనలు చేయడానికి మరియు ఈవెంట్‌లకు సబ్‌స్క్రయిబ్ చేయడానికి వెబ్‌సాకెట్‌లు మరియు Alchemyను ఉపయోగించడానికి మార్గదర్శకం."
+author: "Elan Halpern"
+lang: te
+tags:
+  [
+    "alchemy",
+    "వెబ్‌సాకెట్‌లు",
+    "ప్రశ్నించడం",
+    "జావాస్క్రిప్ట్"
+  ]
+skill: beginner
+source: Alchemy docs
+sourceUrl: https://www.alchemy.com/docs/reference/best-practices-for-using-websockets-in-web3
+published: 2020-12-01
+---
+
+ఇది ఇతీరియము బ్లాక్ చైనుకు అభ్యర్థనలు చేయడానికి వెబ్‌సాకెట్‌లు మరియు Alchemyను ఉపయోగించడానికి ఒక ఎంట్రీ లెవల్ గైడ్.
+
+## వెబ్ సాకెట్‌లు వర్సెస్ HTTP {#websockets-vs-http}
+
+HTTP వలె కాకుండా, వెబ్‌సాకెట్‌లతో, మీకు నిర్దిష్ట సమాచారం కావాలనుకున్నప్పుడు మీరు నిరంతరం అభ్యర్థనలు చేయనవసరం లేదు. వెబ్ సాకెట్‌లు మీ కోసం నెట్‌వర్క్ కనెక్షన్‌ను (సరిగ్గా చేస్తే) నిర్వహిస్తాయి మరియు మార్పుల కోసం వేచి ఉంటాయి.
+
+ఏదైనా నెట్‌వర్క్ కనెక్షన్‌తో వలె, ఒక వెబ్‌సాకెట్ అంతరాయం లేకుండా ఎప్పటికీ తెరిచి ఉంటుందని మీరు భావించకూడదు, కానీ డ్రాప్ చేయబడిన కనెక్షన్‌లను మరియు పునఃకనెక్షన్‌ను సరిగ్గా చేతితో నిర్వహించడం సరిగ్గా పొందడం సవాలుగా ఉంటుంది. వెబ్‌సాకెట్‌ల యొక్క మరో ప్రతికూలత ఏమిటంటే, మీరు ప్రతిస్పందనలో HTTP స్థితి కోడ్‌లను పొందరు, కానీ కేవలం దోష సందేశాన్ని మాత్రమే పొందుతారు.
+
+[Alchemy Web3](https://docs.alchemy.com/reference/api-overview) ఎటువంటి కాన్ఫిగరేషన్ అవసరం లేకుండా వెబ్‌సాకెట్ వైఫల్యాలు మరియు పునఃప్రయత్నాల కోసం హ్యాండ్లింగ్‌ను స్వయంచాలకంగా జోడిస్తుంది.
+
+## దీన్ని ప్రయత్నించండి {#try-it-out}
+
+వెబ్‌సాకెట్‌లను పరీక్షించడానికి సులభమైన మార్గం [wscat](https://github.com/websockets/wscat) వంటి వెబ్‌సాకెట్ అభ్యర్థనలు చేయడానికి కమాండ్ లైన్ సాధనాన్ని ఇన్‌స్టాల్ చేయడం. wscat ఉపయోగించి, మీరు ఈ క్రింది విధంగా అభ్యర్థనలను పంపవచ్చు:
+
+_గమనిక: మీకు Alchemy ఖాతా ఉంటే మీరు `demo` ను మీ స్వంత API కీతో భర్తీ చేయవచ్చు._ [ఇక్కడ ఉచిత Alchemy ఖాతా కోసం సైన్ అప్ చేయండి!](https://auth.alchemy.com/signup)_
+
+```
+wscat -c wss://eth-mainnet.ws.alchemyapi.io/ws/demo
+
+>  {"jsonrpc":  "2.0", "id": 0, "method":  "eth_gasPrice"}
+
+<  {"jsonrpc":  "2.0", "result":  "0xb2d05e00", "id": 0}
+
+```
+
+## వెబ్‌సాకెట్‌లను ఎలా ఉపయోగించాలి {#how-to-use-websockets}
+
+ప్రారంభించడానికి, మీ యాప్ కోసం వెబ్‌సాకెట్ URLను ఉపయోగించి ఒక వెబ్‌సాకెట్‌ను తెరవండి. మీరు [మీ డాష్‌బోర్డ్](https://dashboard.alchemy.com/)లో మీ యాప్ పేజీని తెరిచి, "కీని వీక్షించు" పై క్లిక్ చేయడం ద్వారా మీ యాప్ యొక్క వెబ్‌సాకెట్ URLను కనుగొనవచ్చు. మీ యాప్ యొక్క వెబ్‌సాకెట్‌ల కోసం URL దాని HTTP అభ్యర్థనల కోసం URL కంటే భిన్నంగా ఉంటుందని గమనించండి, కానీ రెండింటినీ "కీని వీక్షించు" పై క్లిక్ చేయడం ద్వారా కనుగొనవచ్చు.
+
+![మీ Alchemy డ్యాష్‌బోర్డ్‌లో మీ వెబ్‌సాకెట్ URLను ఎక్కడ కనుగొనాలి](./use-websockets.gif)
+
+[Alchemy API Reference](https://www.alchemy.com/docs/reference/api-overview)లో జాబితా చేయబడిన ఏవైనా APIలను వెబ్‌సాకెట్ ద్వారా ఉపయోగించవచ్చు. అలా చేయడానికి, HTTP POST అభ్యర్థన యొక్క బాడీగా పంపబడే అదే పేలోడ్‌ను ఉపయోగించండి, కానీ బదులుగా ఆ పేలోడ్‌ను వెబ్‌సాకెట్ ద్వారా పంపండి.
+
+## Web3తో {#with-web3}
+
+Web3 వంటి క్లయింట్ లైబ్రరీని ఉపయోగిస్తున్నప్పుడు వెబ్‌సాకెట్‌లకు మారడం చాలా సులభం. మీ Web3 క్లయింట్‌ను ప్రారంభించేటప్పుడు HTTP URLకు బదులుగా వెబ్‌సాకెట్ URLను పంపండి. ఉదాహరణకి:
+
+```js
+const web3 = new Web3("wss://eth-mainnet.ws.alchemyapi.io/ws/your-api-key")
+
+web3.eth.getBlockNumber().then(console.log) // -> 7946893
+```
+
+## చందా API {#subscription-api}
+
+వెబ్‌సాకెట్ ద్వారా కనెక్ట్ అయినప్పుడు, మీరు రెండు అదనపు పద్ధతులను ఉపయోగించవచ్చు: `eth_subscribe` మరియు `eth_unsubscribe`. ఈ పద్ధతులు మీరు నిర్దిష్ట ఈవెంట్‌ల కోసం వినడానికి మరియు వెంటనే తెలియజేయబడటానికి అనుమతిస్తాయి.
+
+### `eth_subscribe` {#eth-subscribe}
+
+పేర్కొన్న ఈవెంట్‌ల కోసం కొత్త చందాను సృష్టిస్తుంది. [`eth_subscribe` గురించి మరింత తెలుసుకోండి](https://docs.alchemy.com/reference/eth-subscribe).
+
+#### పారామితులు {#parameters}
+
+1. చందా రకాలు
+2. ఐచ్ఛిక పారామీటర్లు
+
+మొదటి వాదన వినవలసిన ఈవెంట్ రకాన్ని నిర్దేశిస్తుంది. రెండవ వాదనలో మొదటి వాదనపై ఆధారపడి ఉండే అదనపు ఎంపికలు ఉంటాయి. వివిధ వివరణ రకాలు, వాటి ఎంపికలు, మరియు వాటి ఈవెంట్ పేలోడ్‌లు క్రింద వివరించబడ్డాయి.
+
+#### తిరిగి వస్తుంది {#returns}
+
+చందా ID: ఈ ID అందుకున్న ఏవైనా ఈవెంట్‌లకు జోడించబడుతుంది, మరియు `eth_unsubscribe` ఉపయోగించి చందాను రద్దు చేయడానికి కూడా ఉపయోగించవచ్చు.
+
+#### చందా ఈవెంట్‌లు {#subscription-events}
+
+చందా యాక్టివ్‌గా ఉన్నప్పుడు, మీరు ఈ క్రింది ఫీల్డ్‌లతో వస్తువులైన ఈవెంట్‌లను అందుకుంటారు:
+
+- `jsonrpc`: ఎల్లప్పుడూ "2.0"
+- `విధానం`: ఎల్లప్పుడూ "eth_subscription"
+- `పారామీటర్లు`: కింది ఫీల్డ్‌లతో కూడిన ఒక వస్తువు:
+  - `subscription`: ఈ చందాను సృష్టించిన `eth_subscribe` కాల్ ద్వారా తిరిగి ఇవ్వబడిన చందా ID.
+  - `ఫలితం`: చందా రకంపై ఆధారపడి కంటెంట్‌లు మారే ఒక వస్తువు.
+
+#### చందా రకాలు {#subscription-types}
+
+1. `alchemy_newFullPendingTransactions`
+
+పెండింగ్ స్థితికి జోడించబడిన అన్ని లావాదేవీల కోసం లావాదేవీ సమాచారాన్ని తిరిగి ఇస్తుంది. ఈ చందా రకం పెండింగ్‌లో ఉన్న లావాదేవీలకు చందా చేస్తుంది, ఇది ప్రామాణిక Web3 కాల్ `web3.eth.subscribe("pendingTransactions")` ను పోలి ఉంటుంది, కానీ ఇది లావాదేవీ హాష్‌లకు బదులుగా _పూర్తి లావాదేవీ సమాచారాన్ని_ విడుదల చేస్తుంది.
+
+ఉదాహరణ:
+
+```json
+>  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["alchemy_newFullPendingTransactions"]}
+
+<  {"id":1,"result":"0x9a52eeddc2b289f985c0e23a7d8427c8","jsonrpc":"2.0"}
+<  {
+      "jsonrpc":"2.0",
+      "method":"eth_subscription",
+      "params":{
+          "result":{
+          "blockHash":null,
+          "blockNumber":null,
+          "from":"0xa36452fc31f6f482ad823cd1cf5515177d57667f",
+          "gas":"0x1adb0",
+          "gasPrice":"0x7735c4d40",
+          "hash":"0x50bff0736c713458c92dd1848d12f3354149be1363123dae35e94e0f2a9d56bf",
+"input":"0xa9059cbb0000000000000000000000000d0707963952f2fba59dd06f2b425ace40b492fe0000000000000000000000000000000000000000000015b1111266cfca100000",
+          "nonce":"0x0",
+          "to":"0xea38eaa3c86c8f9b751533ba2e562deb9acded40",
+          "transactionIndex":null,
+          "value":"0x0",
+          "v":"0x26",
+          "r":"0x195c2c1ed126088e12d290aa93541677d3e3b1d10f137e11f86b1b9227f01e3b",
+          "s":"0x60fc4edbf1527832a2a36dbc1e63ed6193a6eee654472fbebbf88ef1750b5344"},
+          "subscription":"0x9a52eeddc2b289f985c0e23a7d8427c8"
+      }
+  }
+
+```
+
+2. `newHeads`
+
+చైన్ పునర్వ్యవస్థీకరణ సమయంలో సహా, చైన్‌కు కొత్త హెడర్ జోడించబడిన ఏ సమయంలోనైనా ఒక ఈవెంట్‌ను విడుదల చేస్తుంది.
+
+ఒక చైన్ పునర్వ్యవస్థీకరణ జరిగినప్పుడు, ఈ చందా కొత్త చైన్ కోసం అన్ని కొత్త హెడర్‌లను కలిగి ఉన్న ఒక ఈవెంట్‌ను విడుదల చేస్తుంది. ప్రత్యేకించి, దీని అర్థం మీరు ఒకే ఎత్తుతో బహుళ హెడర్‌లను విడుదల చేయడాన్ని చూడవచ్చు, మరియు ఇది జరిగినప్పుడు పునర్వ్యవస్థీకరణ తర్వాత తర్వాత వచ్చే హెడర్‌ను సరైనదిగా తీసుకోవాలి.
+
+ఉదాహరణ:
+
+```json
+>  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["newHeads"]}
+
+<  {"jsonrpc":"2.0","id":2,"result":"0x9ce59a13059e417087c02d3236a0b1cc"}
+<  {
+  "jsonrpc":  "2.0",
+  "method":  "eth_subscription",
+  "params":  {
+      "result":  {
+          "extraData":  "0xd983010305844765746887676f312e342e328777696e646f7773",
+          "gasLimit":  "0x47e7c4",
+          "gasUsed":  "0x38658",
+          "logsBloom":
+"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+          "nonce":  "0x084149998194cc5f",
+          "number":  "0x1348c9",
+          "parentHash":  "0x7736fab79e05dc611604d22470dadad26f56fe494421b5b333de816ce1f25701",
+          "receiptRoot":  "0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36",
+          "sha3Uncles":  "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+          "stateRoot":  "0xb3346685172db67de536d8765c43c31009d0eb3bd9c501c9be3229203f15f378",
+          "timestamp":  "0x56ffeff8",
+          "transactionsRoot":  "0x0167ffa60e3ebc0b080cdb95f7c0087dd6c0e61413140e39d94d3468d7c9689f"
+      },
+  "subscription":  "0x9ce59a13059e417087c02d3236a0b1cc"
+  }
+}
+
+```
+
+3. `logs`
+
+పేర్కొన్న ఫిల్టర్ ప్రమాణాలకు సరిపోయే కొత్తగా జోడించిన బ్లాక్‌లలో భాగమైన లాగ్‌లను విడుదల చేస్తుంది.
+
+ఒక చైన్ పునర్వ్యవస్థీకరణ జరిగినప్పుడు, పాత చైన్‌లోని బ్లాక్‌లలో భాగమైన లాగ్‌లు `removed` ప్రాపర్టీని `true` కి సెట్ చేసి మళ్లీ విడుదల చేయబడతాయి. ఇంకా, కొత్త చైన్‌లోని బ్లాక్‌లలో భాగమైన లాగ్‌లు విడుదల చేయబడతాయి, దీని అర్థం పునర్వ్యవస్థీకరణ సందర్భంలో ఒకే లావాదేవీ కోసం లాగ్‌లను బహుళ సార్లు చూడటం సాధ్యమవుతుంది.
+
+పరామితులు
+
+1. ఈ క్రింది ఫీల్డ్‌లతో ఒక వస్తువు:
+   - `చిరునామా` (ఐచ్ఛికం): ఒక చిరునామాను సూచించే స్ట్రింగ్ లేదా అటువంటి స్ట్రింగ్‌ల శ్రేణి.
+     - ఈ చిరునామాలలో ఒకదాని నుండి సృష్టించబడిన లాగ్‌లు మాత్రమే విడుదల చేయబడతాయి.
+   - `topics`: టాపిక్ స్పెసిఫైయర్‌ల శ్రేణి.
+     - ప్రతి టాపిక్ స్పెసిఫైయర్ `null`, ఒక టాపిక్‌ను సూచించే స్ట్రింగ్ లేదా స్ట్రింగ్‌ల శ్రేణి.
+     - శ్రేణిలో `null` కాని ప్రతి స్థానం విడుదల చేయబడిన లాగ్‌లను ఆ స్థానంలో ఇచ్చిన టాపిక్‌లలో ఒకటి ఉన్న వాటికి మాత్రమే పరిమితం చేస్తుంది.
+
+టాపిక్ నిర్దేశాలకు కొన్ని ఉదాహరణలు:
+
+- `[]`: ఏ టాపిక్‌లైనా అనుమతించబడతాయి.
+- `[A]`: మొదటి స్థానంలో A (మరియు తర్వాత ఏదైనా).
+- `[null, B]`: మొదటి స్థానంలో ఏదైనా మరియు రెండవ స్థానంలో B (మరియు తర్వాత ఏదైనా).
+- `[A, B]`: మొదటి స్థానంలో A మరియు రెండవ స్థానంలో B (మరియు తర్వాత ఏదైనా).
+- `[[A, B], [A, B]]`: మొదటి స్థానంలో (A లేదా B) మరియు రెండవ స్థానంలో (A లేదా B) (మరియు తర్వాత ఏదైనా).
+
+ఉదాహరణ:
+
+```json
+>  {"jsonrpc":  "2.0",  "id":  1,  "method":  "eth_subscribe",  "params":  ["logs",  {"address":  "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd",  "topics":  ["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}
+
+<  {"jsonrpc":"2.0","id":2,"result":"0x4a8a4c0517381924f9838102c5a4dcb7"}
+<  {
+  "jsonrpc":  "2.0",
+  "method":  "eth_subscription",
+  "params":  {
+      "subscription":  "0x4a8a4c0517381924f9838102c5a4dcb7",
+      "result":  {
+          "address":  "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd",
+          "blockHash":  "0x61cdb2a09ab99abf791d474f20c2ea89bf8de2923a2d42bb49944c8c993cbf04",
+          "blockNumber":  "0x29e87",
+          "data": "0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000003",
+          "logIndex":"0x0",
+          "topics":["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"],
+          "transactionHash":  "0xe044554a0a55067caafd07f8020ab9f2af60bdfe337e395ecd84b4877a3d1ab4",
+          "transactionIndex":  "0x0"
+      }
+  }
+}
+
+```
+
+### `eth_unsubscribe` {#eth-unsubscribe}
+
+ఇప్పటికే ఉన్న చందాను రద్దు చేస్తుంది, తద్వారా తదుపరి ఈవెంట్‌లు పంపబడవు.
+
+పరామితులు
+
+1. చందా ID, ఇది గతంలో `eth_subscribe` కాల్ నుండి తిరిగి ఇవ్వబడింది.
+
+తిరిగి ఇస్తుంది
+
+ఒక చందా విజయవంతంగా రద్దు చేయబడితే `true` అని లేదా ఇచ్చిన IDతో ఏ చందా లేకపోతే `false` అని తిరిగి ఇస్తుంది.
+
+ఉదాహరణ:
+
+**అభ్యర్థన**
+
+```
+curl https://eth-mainnet.alchemyapi.io/v2/your-api-key
+-X POST
+-H "Content-Type: application/json"
+-d '{"id": 1, "method": "eth_unsubscribe", "params": ["0x9cef478923ff08bf67fde6c64013158d"]}'
+
+
+```
+
+**ఫలితం**
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": true
+}
+```
+
+---
+
+[Alchemy](https://auth.alchemy.com)తో ఉచితంగా సైన్ అప్ చేయండి, మా [డాక్యుమెంటేషన్‌ను](https://www.alchemy.com/docs/) తనిఖీ చేయండి, మరియు తాజా వార్తల కోసం, మమ్మల్ని [Twitter](https://x.com/AlchemyPlatform)లో అనుసరించండి.
diff --git a/public/content/translations/te/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md b/public/content/translations/te/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
new file mode 100644
index 00000000000..f66de418ddd
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/waffle-dynamic-mocking-and-testing-calls/index.md
@@ -0,0 +1,300 @@
+---
+title: "వాఫిల్: డైనమిక్ మాకింగ్ మరియు కాంట్రాక్ట్ కాల్స్‌ను పరీక్షించడం"
+description: "డైనమిక్ మాకింగ్ మరియు కాంట్రాక్ట్ కాల్స్ పరీక్షించడం కోసం అధునాతన వాఫిల్ ట్యుటోరియల్"
+author: "Daniel Izdebski"
+tags:
+  [
+    "waffle",
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "దృఢత్వం",
+    "పరీక్షించడం",
+    "మాకింగ్"
+  ]
+skill: intermediate
+lang: te
+published: 2020-11-14
+---
+
+## ఈ ట్యుటోరియల్ దేని గురించి? {#what-is-this-tutorial-about}
+
+ఈ ట్యుటోరియల్‌లో మీరు వీటిని ఎలా చేయాలో నేర్చుకుంటారు:
+
+- డైనమిక్ మాకింగ్‌ను ఉపయోగించండి
+- స్మార్ట్ కాంట్రాక్టుల మధ్య పరస్పర చర్యలను పరీక్షించండి
+
+అంచనాలు:
+
+- `Solidity`లో ఒక సాధారణ స్మార్ట్ కాంట్రాక్ట్‌ను ఎలా వ్రాయాలో మీకు ఇప్పటికే తెలుసు
+- `JavaScript` మరియు `TypeScript` గురించి మీకు బాగా తెలుసు
+- మీరు ఇతర `Waffle` ట్యుటోరియల్స్ చేసారు లేదా దాని గురించి ఒకటి రెండు విషయాలు తెలుసు
+
+## డైనమిక్ మాకింగ్ {#dynamic-mocking}
+
+డైనమిక్ మాకింగ్ ఎందుకు ఉపయోగపడుతుంది? సరే, ఇది ఇంటిగ్రేషన్ టెస్ట్‌లకు బదులుగా యూనిట్ టెస్ట్‌లను వ్రాయడానికి మమ్మల్ని అనుమతిస్తుంది. దాని అర్థం ఏమిటి? దీని అర్థం మనం స్మార్ట్ కాంట్రాక్టుల డిపెండెన్సీల గురించి ఆందోళన చెందాల్సిన అవసరం లేదు, తద్వారా వాటన్నింటినీ పూర్తి ఏకాంతంలో పరీక్షించవచ్చు. మీరు దానిని ఖచ్చితంగా ఎలా చేయగలరో నేను మీకు చూపిస్తాను.
+
+### **1.  ప్రాజెక్ట్** {#1-project}
+
+మేము ప్రారంభించడానికి ముందు ఒక సాధారణ node.js ప్రాజెక్ట్‌ను సిద్ధం చేయాలి:
+
+```bash
+mkdir dynamic-mocking
+cd dynamic-mocking
+mkdir contracts src
+
+yarn init
+# లేదా మీరు npm వాడుతుంటే
+npm init
+```
+
+టైప్‌స్క్రిప్ట్ మరియు టెస్ట్ డిపెండెన్సీలను జోడించడంతో ప్రారంభిద్దాం - మోచా & చాయ్:
+
+```bash
+yarn add --dev @types/chai @types/mocha chai mocha ts-node typescript
+# లేదా మీరు npm వాడుతుంటే
+npm install @types/chai @types/mocha chai mocha ts-node typescript --save-dev
+```
+
+ఇప్పుడు `Waffle` మరియు `ethers` ని జోడిద్దాం:
+
+```bash
+yarn add --dev ethereum-waffle ethers
+# లేదా మీరు npm వాడుతుంటే
+npm install ethereum-waffle ethers --save-dev
+```
+
+మీ ప్రాజెక్ట్ నిర్మాణం ఇప్పుడు ఇలా ఉండాలి:
+
+```
+.
+├── contracts
+├── package.json
+└── test
+```
+
+### **2.  స్మార్ట్ కాంట్రాక్ట్** {#2-smart-contract}
+
+డైనమిక్ మాకింగ్ ప్రారంభించడానికి, మనకు డిపెండెన్సీలతో కూడిన స్మార్ట్ కాంట్రాక్ట్ అవసరం. చింతించకండి, నేను మీకు సహాయం చేస్తాను!
+
+ఇక్కడ `Solidity`లో వ్రాసిన ఒక సాధారణ స్మార్ట్ కాంట్రాక్ట్ ఉంది, దీని ఏకైక ఉద్దేశ్యం మనం ధనవంతులమా కాదా అని తనిఖీ చేయడం. మన దగ్గర తగినన్ని టోకెన్లు ఉన్నాయో లేదో తనిఖీ చేయడానికి ఇది ERC20 టోకెన్‌ను ఉపయోగిస్తుంది. దీన్ని `./contracts/AmIRichAlready.sol`లో ఉంచండి.
+
+```solidity
+pragma solidity ^0.6.2;
+
+interface IERC20 {
+    function balanceOf(address account) external view returns (uint256);
+}
+
+contract AmIRichAlready {
+    IERC20 private tokenContract;
+    uint public richness = 1000000 * 10 ** 18;
+
+    constructor (IERC20 _tokenContract) public {
+        tokenContract = _tokenContract;
+    }
+
+    function check() public view returns (bool) {
+        uint balance = tokenContract.balanceOf(msg.sender);
+        return balance > richness;
+    }
+}
+```
+
+మేము డైనమిక్ మాకింగ్ ఉపయోగించాలనుకుంటున్నాము కాబట్టి మాకు పూర్తి ERC20 అవసరం లేదు, అందుకే మేము కేవలం ఒక ఫంక్షన్‌తో IERC20 ఇంటర్‌ఫేస్‌ను ఉపయోగిస్తున్నాము.
+
+ఈ కాంట్రాక్ట్‌ను రూపొందించడానికి సమయం ఆసన్నమైంది! దాని కోసం మేము `Waffle`ని ఉపయోగిస్తాము. మొదట, మేము కంపైలేషన్ ఎంపికలను పేర్కొనే ఒక సాధారణ `waffle.json` కాన్ఫిగ్ ఫైల్‌ను సృష్టించబోతున్నాము.
+
+```json
+{
+  "compilerType": "solcjs",
+  "compilerVersion": "0.6.2",
+  "sourceDirectory": "./contracts",
+  "outputDirectory": "./build"
+}
+```
+
+ఇప్పుడు మనం వాఫిల్‌తో కాంట్రాక్ట్‌ను నిర్మించడానికి సిద్ధంగా ఉన్నాము:
+
+```bash
+npx waffle
+```
+
+సులభం, కదా? `build/` ఫోల్డర్‌లో కాంట్రాక్ట్ మరియు ఇంటర్‌ఫేస్‌కు సంబంధించిన రెండు ఫైల్‌లు కనిపించాయి. పరీక్ష కోసం మేము వాటిని తర్వాత ఉపయోగిస్తాము.
+
+### **3.  పరీక్షించడం** {#3-testing}
+
+వాస్తవ పరీక్ష కోసం `AmIRichAlready.test.ts` అనే ఫైల్‌ను సృష్టిద్దాం. అన్నింటికంటే ముందు, మనం దిగుమతులను నిర్వహించాలి. తర్వాత మనకు అవి అవసరం:
+
+```typescript
+import { expect, use } from "chai"
+import { Contract, utils, Wallet } from "ethers"
+import {
+  deployContract,
+  deployMockContract,
+  MockProvider,
+  solidity,
+} from "ethereum-waffle"
+```
+
+JS డిపెండెన్సీలు మినహా, మనము నిర్మించిన కాంట్రాక్ట్ మరియు ఇంటర్‌ఫేస్‌ను దిగుమతి చేసుకోవాలి:
+
+```typescript
+import IERC20 from "../build/IERC20.json"
+import AmIRichAlready from "../build/AmIRichAlready.json"
+```
+
+పరీక్షించడానికి `Waffle` `chai`ని ఉపయోగిస్తుంది. అయితే, మనం దానిని ఉపయోగించే ముందు, `Waffle` యొక్క మ్యాచ్‌లను `chai`లోకే ఇంజెక్ట్ చేయాలి:
+
+```typescript
+use(solidity)
+```
+
+ప్రతి పరీక్షకు ముందు కాంట్రాక్ట్ స్థితిని రీసెట్ చేసే `beforeEach()` ఫంక్షన్‌ను మనం అమలు చేయాలి. అక్కడ మనకేం కావాలో ముందు ఆలోచిద్దాం. ఒక కాంట్రాక్ట్‌ను అమలు చేయడానికి మాకు రెండు విషయాలు కావాలి: ఒక వాలెట్ మరియు `AmIRichAlready` కాంట్రాక్ట్ కోసం ఒక ఆర్గ్యుమెంట్‌గా పాస్ చేయడానికి ఒక అమలు చేయబడిన ERC20 కాంట్రాక్ట్.
+
+ముందుగా మనం ఒక వాలెట్‌ను సృష్టిస్తాము:
+
+```typescript
+const [wallet] = new MockProvider().getWallets()
+```
+
+అప్పుడు మనం ఒక ERC20 కాంట్రాక్ట్‌ను అమలు చేయాలి. ఇక్కడే క్లిష్టమైన భాగం ఉంది - మన దగ్గర ఒక ఇంటర్‌ఫేస్ మాత్రమే ఉంది. ఇక్కడే `Waffle` మనల్ని రక్షించడానికి వస్తుంది. `Waffle`లో ఒక మ్యాజికల్ `deployMockContract()` ఫంక్షన్ ఉంది, ఇది ఇంటర్‌ఫేస్ యొక్క _abi_ని మాత్రమే ఉపయోగించి కాంట్రాక్ట్‌ను సృష్టిస్తుంది:
+
+```typescript
+const mockERC20 = await deployMockContract(wallet, IERC20.abi)
+```
+
+ఇప్పుడు వాలెట్ మరియు అమలు చేయబడిన ERC20 రెండింటితో, మనం ముందుకు వెళ్లి `AmIRichAlready` కాంట్రాక్ట్‌ను అమలు చేయవచ్చు:
+
+```typescript
+const contract = await deployContract(wallet, AmIRichAlready, [
+  mockERC20.address,
+])
+```
+
+వీటన్నింటితో, మా `beforeEach()` ఫంక్షన్ పూర్తయింది. ఇప్పటివరకు మీ `AmIRichAlready.test.ts` ఫైల్ ఇలా ఉండాలి:
+
+```typescript
+import { expect, use } from "chai"
+import { Contract, utils, Wallet } from "ethers"
+import {
+  deployContract,
+  deployMockContract,
+  MockProvider,
+  solidity,
+} from "ethereum-waffle"
+
+import IERC20 from "../build/IERC20.json"
+import AmIRichAlready from "../build/AmIRichAlready.json"
+
+use(solidity)
+
+describe("Am I Rich Already", () => {
+  let mockERC20: Contract
+  let contract: Contract
+  let wallet: Wallet
+
+  beforeEach(async () => {
+    ;[wallet] = new MockProvider().getWallets()
+    mockERC20 = await deployMockContract(wallet, IERC20.abi)
+    contract = await deployContract(wallet, AmIRichAlready, [mockERC20.address])
+  })
+})
+```
+
+`AmIRichAlready` కాంట్రాక్ట్ కోసం మొదటి టెస్ట్ వ్రాద్దాం. మన టెస్ట్ దేని గురించి ఉండాలని మీరు అనుకుంటున్నారు? అవును, మీరు చెప్పింది నిజమే! మనం ఇప్పటికే ధనవంతులమా కాదా అని తనిఖీ చేయాలి :)
+
+కానీ ఒక్క నిమిషం ఆగండి. మన మాక్డ్ కాంట్రాక్ట్‌కు ఏ విలువలు తిరిగి ఇవ్వాలో ఎలా తెలుస్తుంది? `balanceOf()` ఫంక్షన్ కోసం మేము ఏ లాజిక్‌ను అమలు చేయలేదు. మళ్ళీ, వాఫిల్ ఇక్కడ సహాయపడుతుంది. మా మాక్డ్ కాంట్రాక్ట్‌లో ఇప్పుడు కొన్ని కొత్త ఫ్యాన్సీ విషయాలు ఉన్నాయి:
+
+```typescript
+await mockERC20.mock.<nameOfMethod>.returns(<value>)
+await mockERC20.mock.<nameOfMethod>.withArgs(<arguments>).returns(<value>)
+```
+
+ఈ జ్ఞానంతో మనం చివరకు మన మొదటి పరీక్షను వ్రాయగలము:
+
+```typescript
+it("వాలెట్‌లో 1000000 టోకెన్‌ల కంటే తక్కువ ఉంటే ఫాల్స్‌ని అందిస్తుంది", async () => {
+  await mockERC20.mock.balanceOf.returns(utils.parseEther("999999"))
+  expect(await contract.check()).to.be.equal(false)
+})
+```
+
+ఈ పరీక్షను భాగాలుగా విభజిద్దాం:
+
+1. మేము మా మాక్ ERC20 కాంట్రాక్ట్‌ను ఎల్లప్పుడూ 999999 టోకెన్‌ల బ్యాలెన్స్‌ను తిరిగి ఇచ్చేలా సెట్ చేసాము.
+2. `contract.check()` పద్ధతి `false`ని తిరిగి ఇస్తుందో లేదో తనిఖీ చేయండి.
+
+మేము దీన్ని ప్రారంభించడానికి సిద్ధంగా ఉన్నాము:
+
+![ఒక పరీక్ష పాస్ అవుతోంది](./test-one.png)
+
+కాబట్టి పరీక్ష పనిచేస్తుంది, కానీ... ఇంకా మెరుగుపరచడానికి కొంత ఆస్కారం ఉంది. `balanceOf()` ఫంక్షన్ ఎల్లప్పుడూ 999999ని తిరిగి ఇస్తుంది. ఫంక్షన్ ఏదైనా తిరిగి ఇవ్వాల్సిన వాలెట్‌ను పేర్కొనడం ద్వారా మనం దానిని మెరుగుపరచవచ్చు - నిజమైన కాంట్రాక్ట్ లాగానే:
+
+```typescript
+it("వాలెట్‌లో 1000001 టోకెన్‌ల కంటే తక్కువ ఉంటే ఫాల్స్‌ని అందిస్తుంది", async () => {
+  await mockERC20.mock.balanceOf
+    .withArgs(wallet.address)
+    .returns(utils.parseEther("999999"))
+  expect(await contract.check()).to.be.equal(false)
+})
+```
+
+ఇప్పటివరకు, మనం తగినంత ధనవంతులు కానప్పుడు మాత్రమే పరీక్షించాము. దానికి బదులుగా వ్యతిరేకతను పరీక్షిద్దాం:
+
+```typescript
+it("వాలెట్‌లో కనీసం 1000001 టోకెన్లు ఉంటే ట్రూని అందిస్తుంది", async () => {
+  await mockERC20.mock.balanceOf
+    .withArgs(wallet.address)
+    .returns(utils.parseEther("1000001"))
+  expect(await contract.check()).to.be.equal(true)
+})
+```
+
+మీరు పరీక్షలను నడుపుతారు...
+
+![రెండు పరీక్షలు పాస్ అవుతున్నాయి](test-two.png)
+
+...మరియు ఇక్కడ మీరు ఉన్నారు! మా కాంట్రాక్ట్ ఉద్దేశించిన విధంగా పనిచేస్తున్నట్లు అనిపిస్తుంది :)
+
+## కాంట్రాక్ట్ కాల్స్‌ను పరీక్షించడం {#testing-contract-calls}
+
+ఇప్పటివరకు ఏమి చేసామో సంగ్రహిద్దాం. మేము మా `AmIRichAlready` కాంట్రాక్ట్ యొక్క కార్యాచరణను పరీక్షించాము మరియు ఇది సరిగ్గా పనిచేస్తున్నట్లు అనిపిస్తుంది. అంటే మనం పూర్తి చేసాము, కదా? ఖచ్చితంగా కాదు! వాఫిల్ మన కాంట్రాక్ట్‌ను మరింత పరీక్షించడానికి అనుమతిస్తుంది. కానీ సరిగ్గా ఎలా? సరే, వాఫిల్ యొక్క ఆయుధశాలలో `calledOnContract()` మరియు `calledOnContractWith()` మ్యాచ్‌చర్‌లు ఉన్నాయి. మా కాంట్రాక్ట్ ERC20 మాక్ కాంట్రాక్ట్‌ను పిలిచిందో లేదో తనిఖీ చేయడానికి అవి మమ్మల్ని అనుమతిస్తాయి. ఈ మ్యాచ్‌చర్‌లలో ఒకదానితో ఇక్కడ ఒక ప్రాథమిక పరీక్ష ఉంది:
+
+```typescript
+it("ERC20 టోకెన్‌పై కాంట్రాక్ట్ బ్యాలెన్స్‌ఆఫ్‌ను పిలిచిందో లేదో తనిఖీ చేస్తుంది", async () => {
+  await mockERC20.mock.balanceOf.returns(utils.parseEther("999999"))
+  await contract.check()
+  expect("balanceOf").to.be.calledOnContract(mockERC20)
+})
+```
+
+మనం ఇంకా ముందుకు వెళ్లి, నేను మీకు చెప్పిన ఇతర మ్యాచ్‌చర్‌తో ఈ పరీక్షను మెరుగుపరచవచ్చు:
+
+```typescript
+it("ERC20 టోకెన్‌పై నిర్దిష్ట వాలెట్‌తో కాంట్రాక్ట్ బ్యాలెన్స్‌ఆఫ్‌ను పిలిచిందో లేదో తనిఖీ చేస్తుంది", async () => {
+  await mockERC20.mock.balanceOf
+    .withArgs(wallet.address)
+    .returns(utils.parseEther("999999"))
+  await contract.check()
+  expect("balanceOf").to.be.calledOnContractWith(mockERC20, [wallet.address])
+})
+```
+
+పరీక్షలు సరైనవో కాదో తనిఖీ చేద్దాం:
+
+![మూడు పరీక్షలు పాస్ అవుతున్నాయి](test-three.png)
+
+గొప్పది, అన్ని పరీక్షలు ఆకుపచ్చగా ఉన్నాయి.
+
+వాఫిల్‌తో కాంట్రాక్ట్ కాల్స్‌ను పరీక్షించడం చాలా సులభం. మరియు ఇక్కడ ఉత్తమ భాగం ఉంది. ఈ మ్యాచ్‌చర్‌లు సాధారణ మరియు మాక్డ్ కాంట్రాక్టులు రెండింటితోనూ పనిచేస్తాయి! ఇతర సాంకేతికతల కోసం ప్రసిద్ధ టెస్టింగ్ లైబ్రరీల విషయంలో లాగా, కోడ్‌ను ఇంజెక్ట్ చేయడం కంటే వాఫిల్ EVM కాల్స్‌ను రికార్డ్ చేసి ఫిల్టర్ చేయడం దీనికి కారణం.
+
+## ముగింపు రేఖ {#the-finish-line}
+
+అభినందనలు! ఇప్పుడు కాంట్రాక్ట్ కాల్స్‌ను పరీక్షించడానికి మరియు కాంట్రాక్టులను డైనమిక్‌గా మాక్ చేయడానికి వాఫిల్‌ను ఎలా ఉపయోగించాలో మీకు తెలుసు. కనుగొనడానికి ఇంకా చాలా ఆసక్తికరమైన ఫీచర్లు ఉన్నాయి. నేను వాఫిల్ డాక్యుమెంటేషన్‌లోకి ప్రవేశించమని సిఫార్సు చేస్తున్నాను.
+
+వాఫిల్ డాక్యుమెంటేషన్ [ఇక్కడ](https://ethereum-waffle.readthedocs.io/) అందుబాటులో ఉంది.
+
+ఈ ట్యుటోరియల్ కోసం సోర్స్ కోడ్‌ను [ఇక్కడ](https://github.com/EthWorks/Waffle/tree/master/examples/dynamic-mocking-and-testing-calls) కనుగొనవచ్చు.
+
+మీరు ఆసక్తి చూపే ట్యుటోరియల్స్:
+
+- [వాఫిల్‌తో స్మార్ట్ కాంట్రాక్టులను పరీక్షించడం](/developers/tutorials/waffle-test-simple-smart-contract/)
diff --git a/public/content/translations/te/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md b/public/content/translations/te/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
new file mode 100644
index 00000000000..57baa869cf0
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/waffle-say-hello-world-with-hardhat-and-ethers/index.md
@@ -0,0 +1,204 @@
+---
+title: "హార్డ్‌హ్యాట్ మరియు ఇథర్స్‌తో వాఫిల్ హలో వరల్డ్ ట్యుటోరియల్"
+description: "హార్డ్‌హ్యాట్ మరియు ఇథర్స్.js తో మీ మొదటి వాఫిల్ ప్రాజెక్ట్ ను తయారు చేయండి"
+author: "MiZiet"
+tags:
+  [
+    "waffle",
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "దృఢత్వం",
+    "పరీక్షించడం",
+    "hardhat",
+    "ethers.js"
+  ]
+skill: beginner
+lang: te
+published: 2020-10-16
+---
+
+ఈ [వాఫిల్](https://ethereum-waffle.readthedocs.io) ట్యుటోరియల్‌లో, మనం [హార్డ్‌హ్యాట్](https://hardhat.org/) మరియు [ethers.js](https://docs.ethers.io/v5/) ఉపయోగించి ఒక సాధారణ "హలో వరల్డ్" స్మార్ట్ కాంట్రాక్ట్ ప్రాజెక్ట్‌ను ఎలా సెటప్ చేయాలో నేర్చుకుంటాం. ఆ తర్వాత మన స్మార్ట్ కాంట్రాక్ట్‌కు కొత్త కార్యాచరణను ఎలా జోడించాలో మరియు దానిని వాఫిల్‌తో ఎలా పరీక్షించాలో మనం నేర్చుకుంటాం.
+
+కొత్త ప్రాజెక్ట్‌ను సృష్టించడం ద్వారా ప్రారంభిద్దాం:
+
+```bash
+yarn init
+```
+
+లేదా
+
+```bash
+npm init
+```
+
+మరియు అవసరమైన ప్యాకేజీలను ఇన్‌స్టాల్ చేయడం:
+
+```bash
+yarn add -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
+```
+
+లేదా
+
+```bash
+npm install -D hardhat @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai
+```
+
+`npx hardhat` రన్ చేయడం ద్వారా ఒక నమూనా హార్డ్‌హ్యాట్ ప్రాజెక్ట్‌ను సృష్టించడం తదుపరి దశ.
+
+```bash
+888    888                      888 888               888
+888    888                      888 888               888
+888    888                      888 888               888
+8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
+888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
+888    888 .d888888 888    888  888 888  888 .d888888 888
+888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
+888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888
+
+👷 హార్డ్‌హ్యాట్ v2.0.3కి స్వాగతం 👷‍
+
+? మీరు ఏమి చేయాలనుకుంటున్నారు? …
+❯ ఒక నమూనా ప్రాజెక్ట్‌ను సృష్టించండి
+ఖాళీ hardhat.config.jsని సృష్టించండి
+నిష్క్రమించండి
+```
+
+`Create a sample project`ని ఎంచుకోండి
+
+మన ప్రాజెక్ట్ నిర్మాణం ఈ విధంగా ఉండాలి:
+
+```
+MyWaffleProject
+├── contracts
+│   └── Greeter.sol
+├── node_modules
+├── scripts
+│   └── sample-script.js
+├── test
+│   └── sample-test.js
+├── .gitattributes
+├── .gitignore
+├── hardhat.config.js
+└── package.json
+```
+
+### ఇప్పుడు ఈ ఫైల్‌లలో కొన్నింటి గురించి మాట్లాడుకుందాం: {#now-lets-talk}
+
+- Greeter.sol - సాలిడిటీలో వ్రాసిన మన స్మార్ట్ కాంట్రాక్ట్;
+
+```solidity
+contract Greeter {
+string greeting;
+
+constructor(string memory _greeting) public {
+console.log("గ్రీటింగ్‌తో గ్రీటర్‌ను డిప్లాయ్ చేస్తోంది:", _greeting);
+greeting = _greeting;
+}
+
+function greet() public view returns (string memory) {
+return greeting;
+}
+
+function setGreeting(string memory _greeting) public {
+console.log("గ్రీటింగ్‌ను '%s' నుండి '%s'కి మారుస్తోంది", greeting, _greeting);
+greeting = _greeting;
+}
+}
+```
+
+మన స్మార్ట్ కాంట్రాక్ట్‌ను మూడు భాగాలుగా విభజించవచ్చు:
+
+1. కన్స్ట్రక్టర్ - ఇక్కడ మనం `greeting` అనే స్ట్రింగ్ రకం వేరియబుల్‌ను ప్రకటిస్తాము,
+2. ఫంక్షన్ గ్రీట్ - పిలిచినప్పుడు `greeting`ను తిరిగి ఇచ్చే ఫంక్షన్,
+3. ఫంక్షన్ సెట్‌గ్రీటింగ్ - `greeting` విలువను మార్చడానికి మనకు అనుమతించే ఫంక్షన్.
+
+- sample-test.js - మన పరీక్షల ఫైల్
+
+```js
+describe("గ్రీటర్", function () {
+  it("ఒకసారి మార్చిన తర్వాత కొత్త గ్రీటింగ్‌ను తిరిగి ఇవ్వాలి", async function () {
+    const Greeter = await ethers.getContractFactory("Greeter")
+    const greeter = await Greeter.deploy("హలో, వరల్డ్!")
+
+    await greeter.deployed()
+    expect(await greeter.greet()).to.equal("హలో, వరల్డ్!")
+
+    await greeter.setGreeting("Hola, mundo!")
+    expect(await greeter.greet()).to.equal("Hola, mundo!")
+  })
+})
+```
+
+### తదుపరి దశలో మన కాంట్రాక్ట్‌ను కంపైల్ చేయడం మరియు పరీక్షలను అమలు చేయడం ఉంటాయి: {#compiling-and-testing}
+
+వాఫిల్ పరీక్షలు మోచా (ఒక టెస్ట్ ఫ్రేమ్‌వర్క్)ను చాయ్ (ఒక అస్సర్షన్ లైబ్రరీ)తో కలిపి ఉపయోగిస్తాయి. మీరు చేయాల్సిందల్లా `npx hardhat test`ను అమలు చేసి, కింది సందేశం కనిపించే వరకు వేచి ఉండటమే.
+
+```bash
+✓ ఒకసారి మార్చిన తర్వాత కొత్త గ్రీటింగ్‌ను తిరిగి ఇవ్వాలి
+```
+
+### ఇప్పటివరకు అంతా బాగానే ఉంది, మన ప్రాజెక్ట్‌కు మరికొంత సంక్లిష్టతను జోడిద్దాం <Emoji text=":slightly_smiling_face:" size={1}/> {#adding-complexity}
+
+ఎవరైనా గ్రీటింగ్‌గా ఖాళీ స్ట్రింగ్‌ను జోడించే పరిస్థితిని ఊహించుకోండి. అది ఆత్మీయమైన పలకరింపు కాదు, కదా?  
+అలా జరగకుండా చూసుకుందాం:
+
+ఎవరైనా ఖాళీ స్ట్రింగ్‌ను పంపినప్పుడు సాలిడిటీ యొక్క `revert`ని ఉపయోగించాలనుకుంటున్నాము. మంచి విషయం ఏమిటంటే, వాఫిల్ యొక్క చాయ్ మ్యాచర్ `to.be.revertedWith()`తో మనం ఈ కార్యాచరణను సులభంగా పరీక్షించవచ్చు.
+
+```js
+it("ఖాళీ స్ట్రింగ్‌ను పంపినప్పుడు తిరిగి పంపాలి", async () => {
+  const Greeter = await ethers.getContractFactory("Greeter")
+  const greeter = await Greeter.deploy("హలో, వరల్డ్!")
+
+  await greeter.deployed()
+  await expect(greeter.setGreeting("")).to.be.revertedWith(
+    "గ్రీటింగ్ ఖాళీగా ఉండకూడదు"
+  )
+})
+```
+
+మన కొత్త పరీక్ష పాస్ కాలేదని తెలుస్తోంది:
+
+```bash
+గ్రీటింగ్‌తో గ్రీటర్‌ను డిప్లాయ్ చేస్తోంది: హలో, వరల్డ్!
+'హలో, వరల్డ్!' నుండి 'Hola, mundo!'కి గ్రీటింగ్‌ను మారుస్తోంది
+    ✓ ఒకసారి మార్చిన తర్వాత కొత్త గ్రీటింగ్‌ను తిరిగి ఇవ్వాలి (1514ms)
+గ్రీటింగ్‌తో గ్రీటర్‌ను డిప్లాయ్ చేస్తోంది: హలో, వరల్డ్!
+'హలో, వరల్డ్!' నుండి ''కి గ్రీటింగ్‌ను మారుస్తోంది
+    1) ఖాళీ స్ట్రింగ్‌ను పంపినప్పుడు తిరిగి పంపాలి
+
+
+  1 ఉత్తీర్ణం (2s)
+  1 విఫలం
+```
+
+ఈ కార్యాచరణను మన స్మార్ట్ కాంట్రాక్ట్‌లో అమలు చేద్దాం:
+
+```solidity
+require(bytes(_greeting).length > 0, "గ్రీటింగ్ ఖాళీగా ఉండకూడదు");
+```
+
+ఇప్పుడు, మన సెట్ గ్రీటింగ్ ఫంక్షన్ ఈ విధంగా కనిపిస్తుంది:
+
+```solidity
+function setGreeting(string memory _greeting) public {
+require(bytes(_greeting).length > 0, "గ్రీటింగ్ ఖాళీగా ఉండకూడదు");
+console.log("గ్రీటింగ్‌ను '%s' నుండి '%s'కి మారుస్తోంది", greeting, _greeting);
+greeting = _greeting;
+}
+```
+
+పరీక్షలను మళ్ళీ అమలు చేద్దాం:
+
+```bash
+✓ ఒకసారి మార్చిన తర్వాత కొత్త గ్రీటింగ్‌ను తిరిగి ఇవ్వాలి (1467ms)
+✓ ఖాళీ స్ట్రింగ్‌ను పంపినప్పుడు తిరిగి పంపాలి (276ms)
+
+2 ఉత్తీర్ణం (2s)
+```
+
+అభినందనలు! మీరు సాధించారు :)
+
+### ముగింపు {#conclusion}
+
+మేము వాఫిల్, హార్డ్‌హ్యాట్ మరియు ఇథర్స్.jsలతో ఒక సాధారణ ప్రాజెక్ట్‌ను రూపొందించాము. ప్రాజెక్ట్‌ను ఎలా సెటప్ చేయాలో, పరీక్షను జోడించడం మరియు కొత్త కార్యాచరణను ఎలా అమలు చేయాలో మనం నేర్చుకున్నాము.
+
+మీ స్మార్ట్ కాంట్రాక్ట్‌లను పరీక్షించడానికి మరిన్ని గొప్ప చాయ్ మ్యాచర్‌ల కోసం, [అధికారిక వాఫిల్ డాక్స్](https://ethereum-waffle.readthedocs.io/en/latest/matchers.html)ను చూడండి.
diff --git a/public/content/translations/te/developers/tutorials/waffle-test-simple-smart-contract/index.md b/public/content/translations/te/developers/tutorials/waffle-test-simple-smart-contract/index.md
new file mode 100644
index 00000000000..97e4aaef8b7
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/waffle-test-simple-smart-contract/index.md
@@ -0,0 +1,205 @@
+---
+title: "Waffle లైబ్రరీతో సులభమైన స్మార్ట్ కాంట్రాక్టును పరీక్షిస్తోంది"
+description: "ప్రారంభకులకు ట్యుటోరియల్"
+author: Ewa Kowalska
+tags:
+  [
+    "స్మార్ట్ కాంట్రాక్టులు",
+    "దృఢత్వం",
+    "Waffle",
+    "పరీక్షించడం"
+  ]
+skill: beginner
+lang: te
+published: 2021-02-26
+---
+
+## ఈ ట్యుటోరియల్‌లో మీరు ఎలా చేయాలో నేర్చుకుంటారు {#in-this-tutorial-youll-learn-how-to}
+
+- వాలెట్ బ్యాలెన్స్ మార్పులను పరీక్షించండి
+- పేర్కొన్న ఆర్గ్యుమెంట్‌లతో ఈవెంట్‌ల ఉద్గారాలను పరీక్షించండి
+- ఒక లావాదేవీని తిరిగి పంపినట్లు నిర్ధారించండి
+
+## అనుమానాలు {#assumptions}
+
+- మీరు కొత్త జావాస్క్రిప్ట్ లేదా టైప్‌స్క్రిప్ట్ ప్రాజెక్ట్‌ను సృష్టించవచ్చు
+- జావాస్క్రిప్ట్‌లో పరీక్షలతో మీకు కొంత ప్రాథమిక అనుభవం ఉంది
+- మీరు యార్న్ లేదా ఎన్‌పిఎమ్ వంటి కొన్ని ప్యాకేజీ మేనేజర్‌లను ఉపయోగించారు
+- మీకు స్మార్ట్ కాంట్రాక్టులు మరియు సాలిడిటీ గురించి చాలా ప్రాథమిక పరిజ్ఞానం ఉంది
+
+## ప్రారంభించడం {#getting-started}
+
+ట్యుటోరియల్ యార్న్‌ను ఉపయోగించి టెస్ట్ సెటప్ మరియు రన్‌ను ప్రదర్శిస్తుంది, కానీ మీరు ఎన్‌పిఎమ్‌ను ఇష్టపడితే ఎటువంటి సమస్య లేదు - నేను అధికారిక Waffle [డాక్యుమెంటేషన్](https://ethereum-waffle.readthedocs.io/en/latest/index.html) కు సరైన రిఫరెన్స్‌లను అందిస్తాను.
+
+## డిపెండెన్సీలను ఇన్‌స్టాల్ చేయండి {#install-dependencies}
+
+మీ ప్రాజెక్ట్ యొక్క డెవ్ డిపెండెన్సీలకు [జోడించు](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#installation) ethereum-waffle మరియు టైప్‌స్క్రిప్ట్ డిపెండెన్సీలను.
+
+```bash
+yarn add --dev ethereum-waffle ts-node typescript @types/jest
+```
+
+## ఉదాహరణ స్మార్ట్ కాంట్రాక్ట్ {#example-smart-contract}
+
+ట్యుటోరియల్ సమయంలో మేము ఒక సాధారణ స్మార్ట్ కాంట్రాక్ట్ ఉదాహరణ - EtherSplitter పై పని చేస్తాము. ఎవరినైనా కొంత wei పంపడానికి మరియు ఇద్దరు ముందుగా నిర్వచించిన రిసీవర్ల మధ్య సమానంగా విభజించడానికి అనుమతించడం తప్ప ఇది పెద్దగా ఏమీ చేయదు.
+స్ప్లిట్ ఫంక్షన్‌కు wei సంఖ్య సరిగా ఉండాలి, లేకపోతే అది తిరిగి వస్తుంది. ఇద్దరు రిసీవర్ల కోసం ఇది wei బదిలీని నిర్వహిస్తుంది, దాని తరువాత బదిలీ ఈవెంట్ యొక్క ఉద్గారం ఉంటుంది.
+
+`src/EtherSplitter.sol` లో EtherSplitter కోడ్ యొక్క స్నిప్పెట్‌ను ఉంచండి.
+
+```solidity
+pragma solidity ^0.6.0;
+
+contract EtherSplitter {
+    address payable receiver1;
+    address payable receiver2;
+
+    event Transfer(address from, address to, uint256 amount);
+
+    constructor(address payable _address1, address payable _address2) public {
+        receiver1 = _address1;
+        receiver2 = _address2;
+    }
+
+    function split() public payable {
+        require(msg.value % 2 == 0, 'సరిగా లేని wei మొత్తం అనుమతించబడదు');
+        receiver1.transfer(msg.value / 2);
+        emit Transfer(msg.sender, receiver1, msg.value / 2);
+        receiver2.transfer(msg.value / 2);
+        emit Transfer(msg.sender, receiver2, msg.value / 2);
+    }
+}
+```
+
+## కాంట్రాక్ట్‌ను కంపైల్ చేయండి {#compile-the-contract}
+
+కాంట్రాక్ట్‌ను [కంపైల్ చేయడానికి](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#compiling-the-contract) package.json ఫైల్‌కు కింది ఎంట్రీని జోడించండి:
+
+```json
+"scripts": {
+    "build": "waffle"
+  }
+```
+
+తరువాత, ప్రాజెక్ట్ రూట్ డైరెక్టరీలో Waffle కాన్ఫిగరేషన్ ఫైల్‌ను సృష్టించండి - `waffle.json` - ఆపై కింది కాన్ఫిగరేషన్‌ను అక్కడ అతికించండి:
+
+```json
+{
+  "compilerType": "solcjs",
+  "compilerVersion": "0.6.2",
+  "sourceDirectory": "./src",
+  "outputDirectory": "./build"
+}
+```
+
+`yarn build` ను అమలు చేయండి. ఫలితంగా, `build` డైరెక్టరీ JSON ఫార్మాట్‌లో EtherSplitter కంపైల్ చేయబడిన కాంట్రాక్ట్‌తో కనిపిస్తుంది.
+
+## టెస్ట్ సెటప్ {#test-setup}
+
+Waffle తో పరీక్షించడానికి చాయ్ మ్యాచర్‌లు మరియు మోచాను ఉపయోగించడం అవసరం, కాబట్టి మీరు వాటిని మీ ప్రాజెక్ట్‌కు [జోడించాలి](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#writing-tests). మీ package.json ఫైల్‌ను అప్‌డేట్ చేయండి మరియు స్క్రిప్ట్స్ భాగంలో `test` ఎంట్రీని జోడించండి:
+
+```json
+"scripts": {
+    "build": "waffle",
+    "test": "export NODE_ENV=test && mocha -r ts-node/register 'test/**/*.test.ts'"
+  }
+```
+
+మీరు మీ పరీక్షలను [అమలు చేయాలనుకుంటే](https://ethereum-waffle.readthedocs.io/en/latest/getting-started.html#running-tests), కేవలం `yarn test` ను అమలు చేయండి.
+
+## పరీక్షించడం {#testing}
+
+ఇప్పుడు `test` డైరెక్టరీని సృష్టించండి మరియు కొత్త ఫైల్ `test\EtherSplitter.test.ts` ను సృష్టించండి.
+కింది స్నిప్పెట్‌ను కాపీ చేసి, దాన్ని మా టెస్ట్ ఫైల్‌లో అతికించండి.
+
+```ts
+import { expect, use } from "chai"
+import { Contract } from "ethers"
+import { deployContract, MockProvider, solidity } from "ethereum-waffle"
+import EtherSplitter from "../build/EtherSplitter.json"
+
+use(solidity)
+
+describe("ఈథర్ స్ప్లిట్టర్", () => {
+  const [sender, receiver1, receiver2] = new MockProvider().getWallets()
+  let splitter: Contract
+
+  beforeEach(async () => {
+    splitter = await deployContract(sender, EtherSplitter, [
+      receiver1.address,
+      receiver2.address,
+    ])
+  })
+
+  // ఇక్కడ పరీక్షలను జోడించండి
+})
+```
+
+మేము ప్రారంభించడానికి ముందు కొన్ని మాటలు.
+`MockProvider` బ్లాక్‌చెయిన్ యొక్క మాక్ వెర్షన్‌తో వస్తుంది. ఇది EtherSplitter కాంట్రాక్ట్‌ను పరీక్షించడానికి మాకు ఉపయోగపడే మాక్ వాలెట్లను కూడా అందిస్తుంది. ప్రొవైడర్‌పై `getWallets()` పద్ధతిని కాల్ చేయడం ద్వారా మనం పది వాలెట్లను పొందవచ్చు. ఉదాహరణలో, మేము మూడు వాలెట్లను పొందుతాము - పంపినవారికి మరియు ఇద్దరు రిసీవర్ల కోసం.
+
+తరువాత, మేము 'స్ప్లిట్టర్' అనే వేరియబుల్‌ను ప్రకటిస్తాము - ఇది మా మాక్ EtherSplitter కాంట్రాక్ట్. `deployContract` పద్ధతి ద్వారా ప్రతి ఒక్క పరీక్ష అమలుకు ముందు ఇది సృష్టించబడుతుంది. ఈ పద్ధతి మొదటి పరామీటర్‌గా పంపబడిన వాలెట్ నుండి (మా విషయంలో పంపినవారి వాలెట్) ఒక కాంట్రాక్ట్ యొక్క విస్తరణను అనుకరిస్తుంది. రెండవ పరామీటర్ పరీక్షించబడిన కాంట్రాక్ట్ యొక్క ABI మరియు బైట్‌కోడ్ - మేము `build` డైరెక్టరీ నుండి కంపైల్ చేయబడిన EtherSplitter కాంట్రాక్ట్ యొక్క json ఫైల్‌ను అక్కడ పంపుతాము. మూడవ పరామీటర్ కాంట్రాక్ట్ యొక్క కన్‌స్ట్రక్టర్ ఆర్గ్యుమెంట్‌లతో కూడిన ఒక శ్రేణి, ఇది మా విషయంలో, రిసీవర్ల యొక్క రెండు చిరునామాలు.
+
+## బ్యాలెన్స్‌లను మార్చండి {#changebalances}
+
+మొదట, స్ప్లిట్ పద్ధతి వాస్తవానికి రిసీవర్ల వాలెట్ల బ్యాలెన్స్‌లను మారుస్తుందో లేదో తనిఖీ చేస్తాము. మేము పంపినవారి ఖాతా నుండి 50 wei విభజిస్తే, ఇద్దరు రిసీవర్ల బ్యాలెన్స్‌లు 25 wei పెరగాలని మేము ఆశిస్తాము. మేము Waffle యొక్క `changeBalances` మ్యాచర్‌ను ఉపయోగిస్తాము:
+
+```ts
+it("ఖాతాల బ్యాలెన్స్‌లను మారుస్తుంది", async () => {
+  await expect(() => splitter.split({ value: 50 })).to.changeBalances(
+    [receiver1, receiver2],
+    [25, 25]
+  )
+})
+```
+
+మ్యాచర్ యొక్క మొదటి పరామీటర్‌గా, మేము రిసీవర్ల వాలెట్ల శ్రేణిని పంపుతాము, మరియు రెండవదిగా - సంబంధిత ఖాతాలపై ఆశించిన పెరుగుదలల శ్రేణి.
+ఒక నిర్దిష్ట వాలెట్ యొక్క బ్యాలెన్స్‌ను తనిఖీ చేయాలనుకుంటే, మేము `changeBalance` మ్యాచర్‌ను కూడా ఉపయోగించవచ్చు, దీనికి క్రింది ఉదాహరణలో వలె శ్రేణులను పంపడం అవసరం లేదు:
+
+```ts
+it("ఖాతా బ్యాలెన్స్‌ను మారుస్తుంది", async () => {
+  await expect(() => splitter.split({ value: 50 })).to.changeBalance(
+    receiver1,
+    25
+  )
+})
+```
+
+`changeBalance` మరియు `changeBalances` రెండింటి సందర్భాల్లోనూ మేము స్ప్లిట్ ఫంక్షన్‌ను కాల్‌బ్యాక్‌గా పంపుతామని గమనించండి, ఎందుకంటే మ్యాచర్‌కు కాల్‌కు ముందు మరియు తరువాత బ్యాలెన్స్‌ల స్థితిని యాక్సెస్ చేయాలి.
+
+తరువాత, ప్రతి wei బదిలీ తర్వాత బదిలీ ఈవెంట్ జారీ చేయబడిందా అని మేము పరీక్షిస్తాము. మేము Waffle నుండి మరొక మ్యాచర్‌కు వెళ్తాము:
+
+## జారీ చేయి {#emit}
+
+```ts
+it("మొదటి రిసీవర్‌కు బదిలీపై ఈవెంట్‌ను జారీ చేస్తుంది", async () => {
+  await expect(splitter.split({ value: 50 }))
+    .to.emit(splitter, "Transfer")
+    .withArgs(sender.address, receiver1.address, 25)
+})
+
+it("రెండవ రిసీవర్‌కు బదిలీపై ఈవెంట్‌ను జారీ చేస్తుంది", async () => {
+  await expect(splitter.split({ value: 50 }))
+    .to.emit(splitter, "Transfer")
+    .withArgs(sender.address, receiver2.address, 25)
+})
+```
+
+`emit` మ్యాచర్ ఒక పద్ధతిని కాల్ చేసినప్పుడు కాంట్రాక్ట్ ఒక ఈవెంట్‌ను జారీ చేసిందో లేదో తనిఖీ చేయడానికి మాకు అనుమతిస్తుంది. `emit` మ్యాచర్‌కు పరామీటర్లుగా, ఈవెంట్‌ను జారీ చేస్తుందని మేము ఊహించిన మాక్ కాంట్రాక్ట్‌ను, ఆ ఈవెంట్ పేరుతో పాటు అందిస్తాము. మా విషయంలో, మాక్ కాంట్రాక్ట్ `స్ప్లిట్టర్` మరియు ఈవెంట్ పేరు - `Transfer`. ఈవెంట్ జారీ చేయబడిన ఆర్గ్యుమెంట్‌ల యొక్క ఖచ్చితమైన విలువలను కూడా మేము ధృవీకరించవచ్చు - మా ఈవెంట్ డిక్లరేషన్ ఆశించినన్ని ఆర్గ్యుమెంట్‌లను `withArgs` మ్యాచర్‌కు పంపుతాము. EtherSplitter కాంట్రాక్ట్ విషయంలో, మేము పంపినవారు మరియు రిసీవర్ యొక్క చిరునామాలను బదిలీ చేయబడిన wei మొత్తంతో పాటు పంపుతాము.
+
+## తో వెనక్కు తిరిగింది {#revertedwith}
+
+చివరి ఉదాహరణగా, సరిగా లేని wei సంఖ్య విషయంలో లావాదేవీ వెనక్కి తిరిగిందో లేదో తనిఖీ చేస్తాము. మేము `revertedWith` మ్యాచర్‌ను ఉపయోగిస్తాము:
+
+```ts
+it("Vei మొత్తం సరిగా లేనప్పుడు తిరిగి వస్తుంది", async () => {
+  await expect(splitter.split({ value: 51 })).to.be.revertedWith(
+    "సరిగా లేని wei మొత్తం అనుమతించబడదు"
+  )
+})
+```
+
+పరీక్ష, ఉత్తీర్ణత సాధిస్తే, లావాదేవీ వాస్తవంగా వెనక్కి తిరిగిందని మాకు హామీ ఇస్తుంది. అయితే, మేము `require` స్టేట్‌మెంట్‌లో పంపిన సందేశాలు మరియు `revertedWith` లో మనం ఆశించే సందేశం మధ్య ఖచ్చితమైన సరిపోలిక కూడా ఉండాలి. మేము EtherSplitter కాంట్రాక్ట్ కోడ్‌కు తిరిగి వెళితే, wei మొత్తం కోసం `require` స్టేట్‌మెంట్‌లో, మేము ఈ సందేశాన్ని అందిస్తాము: 'సరిగా లేని wei మొత్తం అనుమతించబడదు'. ఇది మా పరీక్షలో మేము ఆశించే సందేశంతో సరిపోలుతుంది. అవి సమానంగా లేకపోతే, పరీక్ష విఫలమవుతుంది.
+
+## అభినందనలు! {#congratulations}
+
+మీరు Waffleతో స్మార్ట్ కాంట్రాక్టులను పరీక్షించడం వైపు మీ మొదటి పెద్ద అడుగు వేశారు!
diff --git a/public/content/translations/te/developers/tutorials/yellow-paper-evm/index.md b/public/content/translations/te/developers/tutorials/yellow-paper-evm/index.md
new file mode 100644
index 00000000000..78e45dc3d97
--- /dev/null
+++ b/public/content/translations/te/developers/tutorials/yellow-paper-evm/index.md
@@ -0,0 +1,278 @@
+---
+title: "ఎల్లో పేపర్ యొక్క EVM స్పెసిఫికేషన్లను అర్థం చేసుకోవడం"
+description: "ఇతీరియము కోసం అధికారిక స్పెసిఫికేషన్‌లు అయిన ఎల్లో పేపర్‌లోని, ఇతీరియము వర్చువల్ మెషీన్ (EVM)ను వివరించే భాగాన్ని అర్థం చేసుకోవడం."
+author: "qbzzt"
+tags: [ "evm" ]
+skill: intermediate
+lang: te
+published: 2022-05-15
+---
+
+[ఎల్లో పేపర్](https://ethereum.github.io/yellowpaper/paper.pdf) అనేది ఇతీరియము కోసం అధికారిక స్పెసిఫికేషన్. [EIP ప్రక్రియ](/eips/) ద్వారా సవరించబడిన చోట తప్ప, ప్రతిదీ ఎలా పనిచేస్తుందో దాని యొక్క ఖచ్చితమైన వివరణను ఇది కలిగి ఉంటుంది. ఇది ఒక గణిత పేపర్‌గా వ్రాయబడింది, ఇందులో ప్రోగ్రామర్‌లకు సుపరిచితం కాని పరిభాష ఉంటుంది. ఈ పేపర్‌లో మీరు దానిని ఎలా చదవాలో నేర్చుకుంటారు, మరియు తద్వారా ఇతర సంబంధిత గణిత పత్రాలను కూడా.
+
+## ఏ ఎల్లో పేపర్? {#which-yellow-paper}
+
+ఇతీరియములోని దాదాపు అన్ని ఇతర విషయాల వలె, ఎల్లో పేపర్ కూడా కాలక్రమేణా అభివృద్ధి చెందుతుంది. ఒక నిర్దిష్ట వెర్షన్‌ను సూచించగలగడానికి, నేను [వ్రాసే సమయంలో ఉన్న ప్రస్తుత వెర్షన్‌ను](yellow-paper-berlin.pdf) అప్‌లోడ్ చేసాను. నేను ఉపయోగించే విభాగం, పేజీ మరియు సమీకరణ సంఖ్యలు ఆ వెర్షన్‌ను సూచిస్తాయి. ఈ పత్రాన్ని చదివేటప్పుడు దానిని వేరొక విండోలో తెరిచి ఉంచడం మంచిది.
+
+### EVM ఎందుకు? {#why-the-evm}
+
+అసలైన ఎల్లో పేపర్ ఇతీరియము అభివృద్ధి ప్రారంభంలోనే వ్రాయబడింది. నెట్‌వర్క్‌ను భద్రపరచడానికి వాస్తవానికి ఉపయోగించిన అసలు ప్రూఫ్-ఆఫ్-వర్క్ ఆధారిత ఏకాభిప్రాయ యంత్రాంగాన్ని ఇది వివరిస్తుంది. అయితే, ఇతీరియము ప్రూఫ్-ఆఫ్-వర్క్‌ను నిలిపివేసి, సెప్టెంబర్ 2022లో ప్రూఫ్-ఆఫ్-స్టేక్ ఆధారిత ఏకాభిప్రాయాన్ని ఉపయోగించడం ప్రారంభించింది. ఈ ట్యుటోరియల్ ఎథేరియం వర్చువల్ మషీన్‌ను నిర్వచించే ఎల్లో పేపర్ భాగాలపై దృష్టి సారిస్తుంది. ప్రూఫ్-ఆఫ్-స్టేక్‌కు మారడం వల్ల EVM మారలేదు (DIFFICULTY ఆప్‌కోడ్ యొక్క రిటర్న్ విలువ మినహా).
+
+## 9 ఎగ్జిక్యూషన్ మోడల్ {#9-execution-model}
+
+ఈ విభాగం (p. 12-14) EVM యొక్క చాలా నిర్వచనాన్ని కలిగి ఉంటుంది.
+
+_సిస్టమ్ స్థితి_ అనే పదంలో సిస్టమ్‌ను అమలు చేయడానికి దాని గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ ఉంటుంది. ఒక సాధారణ కంప్యూటర్‌లో, దీని అర్థం మెమరీ, రిజిస్టర్‌ల కంటెంట్, మొదలైనవి.
+
+[ట్యూరింగ్ మెషీన్](https://en.wikipedia.org/wiki/Turing_machine) అనేది గణన నమూనా. ముఖ్యంగా, ఇది కంప్యూటర్ యొక్క సరళీకృత వెర్షన్, ఇది సాధారణ కంప్యూటర్ చేయగల గణనలను అమలు చేసే సామర్థ్యాన్ని కలిగి ఉందని నిరూపించబడింది (కంప్యూటర్ లెక్కించగల ప్రతిదీ ట్యూరింగ్ మెషీన్ లెక్కించగలదు మరియు దీనికి విరుద్ధంగా కూడా). ఈ మోడల్ గణన సాధ్యమయ్యేవి మరియు కానివి అనే దాని గురించి వివిధ సిద్ధాంతాలను నిరూపించడాన్ని సులభతరం చేస్తుంది.
+
+[ట్యూరింగ్-కంప్లీట్](https://en.wikipedia.org/wiki/Turing_completeness) అనే పదం ట్యూరింగ్ మెషీన్ వలె అదే గణనలను అమలు చేయగల కంప్యూటర్‌ను సూచిస్తుంది. ట్యూరింగ్ మెషీన్లు అనంత లూప్‌లలోకి వెళ్ళగలవు, మరియు EVM వెళ్ళలేదు ఎందుకంటే దానికి గ్యాస్ అయిపోతుంది, కాబట్టి ఇది కేవలం పాక్షిక-ట్యూరింగ్-కంప్లీట్.
+
+## 9.1 ప్రాథమిక అంశాలు {#91-basics}
+
+ఈ విభాగం EVM యొక్క ప్రాథమిక అంశాలను మరియు ఇది ఇతర గణన నమూనాలతో ఎలా పోలుస్తుందో వివరిస్తుంది.
+
+[స్టాక్ మెషీన్](https://en.wikipedia.org/wiki/Stack_machine) అనేది ఒక కంప్యూటర్, ఇది మధ్యంతర డేటాను రిజిస్టర్లలో కాకుండా, ఒక [**స్టాక్**](https://en.wikipedia.org/wiki/Stack_\(abstract_data_type\))లో నిల్వ చేస్తుంది. వర్చువల్ మెషీన్‌లకు ఇది ప్రాధాన్యత కలిగిన ఆర్కిటెక్చర్, ఎందుకంటే దీనిని అమలు చేయడం సులభం, అంటే బగ్‌లు మరియు భద్రతా బలహీనతలు చాలా తక్కువగా ఉంటాయి. స్టాక్‌లోని మెమరీ 256-బిట్ పదాలుగా విభజించబడింది. ఇది ఇతీరియము యొక్క కోర్ క్రిప్టోగ్రాఫిక్ ఆపరేషన్‌లైన కీకాక్-256 హాషింగ్ మరియు ఎలిప్టిక్ కర్వ్ గణనలకు సౌకర్యవంతంగా ఉండటం వల్ల ఎంచుకోబడింది. స్టాక్ యొక్క గరిష్ట పరిమాణం 1024 అంశాలు (1024 x 256 బిట్స్). ఆప్‌కోడ్‌లను అమలు చేసినప్పుడు, అవి సాధారణంగా స్టాక్ నుండి వాటి పారామీటర్‌లను పొందుతాయి. స్టాక్‌లోని మూలకాలను పునఃసంఘటించడానికి ప్రత్యేకంగా ఆప్‌కోడ్‌లు ఉన్నాయి, అవి `POP` (స్టాక్ పై నుండి అంశాన్ని తొలగిస్తుంది), `DUP_N` (స్టాక్‌లోని N'వ అంశాన్ని డూప్లికేట్ చేస్తుంది), మొదలైనవి.
+
+EVMలో **మెమరీ** అని పిలువబడే ఒక అస్థిర స్థలం కూడా ఉంది, ఇది అమలు సమయంలో డేటాను నిల్వ చేయడానికి ఉపయోగించబడుతుంది. ఈ మెమరీ 32-బైట్ పదాలుగా నిర్వహించబడింది. అన్ని మెమరీ స్థానాలు సున్నాకు ప్రారంభించబడ్డాయి. మెమరీకి ఒక పదాన్ని జోడించడానికి మీరు ఈ [Yul](https://docs.soliditylang.org/en/latest/yul.html) కోడ్‌ను అమలు చేస్తే, అది పదంలోని ఖాళీ స్థలాన్ని సున్నాలతో పూరించడం ద్వారా 32 బైట్ల మెమరీని నింపుతుంది, అనగా, ఇది ఒక పదాన్ని సృష్టిస్తుంది - 0-29 స్థానాల్లో సున్నాలు, 30వ స్థానంలో 0x60, మరియు 31వ స్థానంలో 0xA7తో.
+
+```yul
+mstore(0, 0x60A7)
+```
+
+`mstore` అనేది మెమరీతో ఇంటరాక్ట్ అవ్వడానికి EVM అందించే మూడు ఆప్‌కోడ్‌లలో ఒకటి - ఇది మెమరీలోకి ఒక పదాన్ని లోడ్ చేస్తుంది. మిగతా రెండు `mstore8`, ఇది ఒకే బైట్‌ను మెమరీలోకి లోడ్ చేస్తుంది, మరియు `mload` ఇది మెమరీ నుండి స్టాక్‌కు ఒక పదాన్ని తరలిస్తుంది.
+
+EVMలో ఒక ప్రత్యేకమైన అస్థిరత లేని **నిల్వ** మోడల్ కూడా ఉంది, ఇది సిస్టమ్ స్థితిలో భాగంగా నిర్వహించబడుతుంది - ఈ మెమరీ వర్డ్ అర్రేలలో నిర్వహించబడుతుంది (స్టాక్‌లోని వర్డ్-అడ్రెస్సబుల్ బైట్ అర్రేలకు విరుద్ధంగా). ఈ నిల్వ స్థలంలో కాంట్రాక్టులు శాశ్వత డేటాను ఉంచుతాయి - ఒక కాంట్రాక్టు దాని స్వంత నిల్వతో మాత్రమే పరస్పర చర్య చేయగలదు. నిల్వ కీ-విలువ మ్యాపింగ్‌లలో నిర్వహించబడుతుంది.
+
+ఎల్లో పేపర్ యొక్క ఈ విభాగంలో పేర్కొననప్పటికీ, నాల్గవ రకం మెమరీ ఉందని కూడా తెలుసుకోవడం ఉపయోగకరంగా ఉంటుంది. **కాల్‌డేటా** అనేది బైట్-అడ్రెస్ చేయగల రీడ్-ఓన్లీ మెమరీ, ఇది లావాదేవీ యొక్క `డేటా` పారామీటర్‌తో పంపిన విలువను నిల్వ చేయడానికి ఉపయోగించబడుతుంది. EVMలో `calldata`ను నిర్వహించడానికి ప్రత్యేక ఆప్‌కోడ్‌లు ఉన్నాయి. `calldatasize` డేటా పరిమాణాన్ని తిరిగి ఇస్తుంది. `calldataload` డేటాను స్టాక్‌లోకి లోడ్ చేస్తుంది. `calldatacopy` డేటాను మెమరీలోకి కాపీ చేస్తుంది.
+
+ప్రామాణిక [వాన్ న్యూమాన్ ఆర్కిటెక్చర్](https://en.wikipedia.org/wiki/Von_Neumann_architecture) సంకేత భాష మరియు డేటాను ఒకే మెమరీలో నిల్వ చేస్తుంది. భద్రతా కారణాల వల్ల EVM ఈ ప్రమాణాన్ని పాటించదు - అస్థిర మెమరీని పంచుకోవడం ప్రోగ్రామ్ సంకేత భాషను మార్చడానికి వీలు కల్పిస్తుంది. బదులుగా, సంకేత భాష నిల్వలో సేవ్ చేయబడుతుంది.
+
+మెమరీ నుండి సంకేత భాష అమలు చేయబడే రెండు సందర్భాలు మాత్రమే ఉన్నాయి:
+
+- ఒక కాంట్రాక్టు మరొక కాంట్రాక్టును సృష్టించినప్పుడు ([`CREATE`](https://www.evm.codes/#f0) లేదా [`CREATE2`](https://www.evm.codes/#f5) ఉపయోగించి), కాంట్రాక్ట్ కన్స్ట్రక్టర్ కోసం సంకేత భాష మెమరీ నుండి వస్తుంది.
+- ఏదైనా కాంట్రాక్టు సృష్టించే సమయంలో, కన్స్ట్రక్టర్ సంకేత భాష రన్ అయి, ఆ తర్వాత అసలు కాంట్రాక్ట్ యొక్క సంకేత భాషతో, మెమరీ నుండే తిరిగి వస్తుంది.
+
+అసాధారణమైన అమలు అనే పదం ప్రస్తుత కాంట్రాక్టు అమలును నిలిపివేయడానికి కారణమయ్యే ఒక మినహాయింపును సూచిస్తుంది.
+
+## 9.2 ఫీజుల అవలోకనం {#92-fees-overview}
+
+ఈ విభాగం గ్యాస్ ఫీజులు ఎలా లెక్కించబడతాయో వివరిస్తుంది. మూడు ఖర్చులు ఉన్నాయి:
+
+### ఆప్‌కోడ్ ఖర్చు {#opcode-cost}
+
+నిర్దిష్ట ఆప్‌కోడ్ యొక్క స్వాభావిక ఖర్చు. ఈ విలువను పొందడానికి, అపెండిక్స్ H (p. 28, సమీకరణం (327) కింద)లో ఆప్‌కోడ్ యొక్క కాస్ట్ గ్రూప్‌ను కనుగొని, సమీకరణం (324)లో కాస్ట్ గ్రూప్‌ను కనుగొనండి. ఇది మీకు కాస్ట్ ఫంక్షన్‌ను ఇస్తుంది, ఇది చాలా సందర్భాలలో అపెండిక్స్ G (p. 27) నుండి పారామీటర్‌లను ఉపయోగిస్తుంది.
+
+ఉదాహరణకు, [`CALLDATACOPY`](https://www.evm.codes/#37) అనే ఆప్‌కోడ్ _W<sub>copy</sub>_ గ్రూప్ సభ్యుడు. ఆ గ్రూప్ కొరకు ఆప్‌కోడ్ ఖర్చు _G<sub>verylow</sub>+G<sub>copy</sub>×⌈μ<sub>s</sub>[2]÷32⌉_. అపెండిక్స్ G ని చూస్తే, రెండు స్థిరాంకాలు 3 అని మనం చూస్తాము, ఇది మనకు _3+3×⌈μ<sub>s</sub>[2]÷32⌉_ ఇస్తుంది.
+
+మనం ఇప్పటికీ _⌈μ<sub>s</sub>[2]÷32⌉_ అనే వ్యక్తీకరణను అర్థం చేసుకోవాలి. వెలుపలి భాగం, _⌈ \<value\> ⌉_ అనేది సీలింగ్ ఫంక్షన్, ఇది ఒక విలువను ఇచ్చినప్పుడు, ఆ విలువ కంటే తక్కువ కాని అతి చిన్న పూర్ణాంకాన్ని తిరిగి ఇస్తుంది. ఉదాహరణకు, _⌈2.5⌉ = ⌈3⌉ = 3_. లోపలి భాగం _μ<sub>s</sub>[2]÷32_. p. 3లోని సెక్షన్ 3 (సంప్రదాయాలు)ని చూస్తే, _μ_ అనేది మెషీన్ స్థితి. మెషీన్ స్థితి p. 13లోని సెక్షన్ 9.4.1లో నిర్వచించబడింది. ఆ విభాగం ప్రకారం, మెషీన్ స్థితి పారామితులలో ఒకటి స్టాక్ కొరకు _s_. అన్నిటినీ కలిపి చూస్తే, _μ<sub>s</sub>[2]_ అనేది స్టాక్‌లోని #2 స్థానం అని అనిపిస్తుంది. [ఆప్‌కోడ్](https://www.evm.codes/#37)ను చూస్తే, స్టాక్‌లోని #2 స్థానం బైట్లలోని డేటా పరిమాణం. W<sub>copy</sub> గ్రూపులోని ఇతర ఆప్‌కోడ్‌లు, [`CODECOPY`](https://www.evm.codes/#39) మరియు [`RETURNDATACOPY`](https://www.evm.codes/#3e)లను చూస్తే, వాటికి కూడా అదే స్థానంలో డేటా పరిమాణం ఉంటుంది. కాబట్టి _⌈μ<sub>s</sub>[2]÷32⌉_ అనేది కాపీ చేయబడుతున్న డేటాను నిల్వ చేయడానికి అవసరమైన 32 బైట్ పదాల సంఖ్య. అన్నింటినీ కలిపి చూస్తే, [`CALLDATACOPY`](https://www.evm.codes/#37) యొక్క అంతర్లీన వ్యయం 3 గ్యాస్ మరియు కాపీ చేయబడుతున్న డేటా యొక్క ప్రతి పదానికి 3.
+
+### రన్నింగ్ ఖర్చు {#running-cost}
+
+మనం కాల్ చేస్తున్న సంకేత భాషను రన్ చేసే ఖర్చు.
+
+- [`CREATE`](https://www.evm.codes/#f0) మరియు [`CREATE2`](https://www.evm.codes/#f5) విషయంలో, కొత్త కాంట్రాక్ట్ కొరకు కన్స్ట్రక్టర్.
+- [`CALL`](https://www.evm.codes/#f1), [`CALLCODE`](https://www.evm.codes/#f2), [`STATICCALL`](https://www.evm.codes/#fa), లేదా [`DELEGATECALL`](https://www.evm.codes/#f4) విషయంలో, మనం కాల్ చేసే కాంట్రాక్ట్.
+
+### మెమరీ ఖర్చును విస్తరించడం {#expanding-memory-cost}
+
+మెమరీని విస్తరించే ఖర్చు (అవసరమైతే).
+
+సమీకరణం 324లో, ఈ విలువ _C<sub>mem</sub>(μ<sub>i</sub>')-C<sub>mem</sub>(μ<sub>i</sub>)_గా వ్రాయబడింది. సెక్షన్ 9.4.1ని మళ్ళీ చూస్తే, _μ<sub>i</sub>_ అనేది మెమరీలోని పదాల సంఖ్య అని మనం చూస్తాము. కాబట్టి _μ<sub>i</sub>_ అనేది ఆప్‌కోడ్‌కు ముందు మెమరీలోని పదాల సంఖ్య మరియు _μ<sub>i</sub>'_ అనేది ఆప్‌కోడ్‌కు తర్వాత మెమరీలోని పదాల సంఖ్య.
+
+_C<sub>mem</sub>_ ఫంక్షన్ సమీకరణం 326లో నిర్వచించబడింది: _C<sub>mem</sub>(a) = G<sub>memory</sub> × a + ⌊a<sup>2</sup> ÷ 512⌋_. _⌊x⌋_ అనేది ఫ్లోర్ ఫంక్షన్, ఇది ఒక విలువను ఇచ్చినప్పుడు, ఆ విలువ కంటే పెద్దది కాని అతి పెద్ద పూర్ణాంకాన్ని తిరిగి ఇస్తుంది. ఉదాహరణకు, _⌊2.5⌋ = ⌊2⌋ = 2._ _a < √512_ అయినప్పుడు, _a<sup>2</sup> < 512_, మరియు ఫ్లోర్ ఫంక్షన్ ఫలితం సున్నా. కాబట్టి మొదటి 22 పదాలకు (704 బైట్లు), ఖర్చు అవసరమైన మెమరీ పదాల సంఖ్యతో సరళంగా పెరుగుతుంది. ఆ స్థానం దాటి _⌊a<sup>2</sup> ÷ 512⌋_ ధనాత్మకంగా ఉంటుంది. అవసరమైన మెమరీ తగినంత ఎక్కువగా ఉన్నప్పుడు గ్యాస్ ఖర్చు మెమరీ మొత్తానికి వర్గానికి అనుపాతంలో ఉంటుంది.
+
+**గమనిక**: ఈ కారకాలు _అంతర్లీన_ గ్యాస్ వ్యయాన్ని మాత్రమే ప్రభావితం చేస్తాయి - తుది వినియోగదారుడు ఎంత చెల్లించాలో నిర్ణయించే ఫీజు మార్కెట్ లేదా వాలిడేటర్‌లకు ఇచ్చే చిట్కాలను ఇది పరిగణనలోకి తీసుకోదు - ఇది కేవలం EVMలో ఒక నిర్దిష్ట ఆపరేషన్‌ను అమలు చేయడానికి అయ్యే అసలు వ్యయం మాత్రమే.
+
+[గ్యాస్ గురించి మరింత చదవండి](/developers/docs/gas/).
+
+## 9.3 ఎగ్జిక్యూషన్ ఎన్విరాన్మెంట్ {#93-execution-env}
+
+ఎగ్జిక్యూషన్ ఎన్విరాన్మెంట్ అనేది ఒక టపుల్, _I_, ఇది బ్లాక్‌చైన్ స్థితిలో లేదా EVMలో భాగం కాని సమాచారాన్ని కలిగి ఉంటుంది.
+
+| పరామితి         | డేటాను యాక్సెస్ చేయడానికి ఆప్‌కోడ్                                                                                   | డేటాను యాక్సెస్ చేయడానికి సాలిడిటీ సంకేత భాష                  |
+| --------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| _I<sub>a</sub>_ | [`ADDRESS`](https://www.evm.codes/#30)                                                                               | `address(this)`                                               |
+| _I<sub>o</sub>_ | [`ORIGIN`](https://www.evm.codes/#32)                                                                                | `tx.origin`                                                   |
+| _I<sub>p</sub>_ | [`GASPRICE`](https://www.evm.codes/#3a)                                                                              | `tx.gasprice`                                                 |
+| _I<sub>d</sub>_ | [`CALLDATALOAD`](https://www.evm.codes/#35), మొదలైనవి.                                               | `msg.data`                                                    |
+| _I<sub>s</sub>_ | [`CALLER`](https://www.evm.codes/#33)                                                                                | `msg.sender`                                                  |
+| _I<sub>v</sub>_ | [`CALLVALUE`](https://www.evm.codes/#34)                                                                             | `msg.value`                                                   |
+| _I<sub>b</sub>_ | [`CODECOPY`](https://www.evm.codes/#39)                                                                              | `address(this).code`                                          |
+| _I<sub>H</sub>_ | బ్లాక్ హెడర్ ఫీల్డ్‌లు, [`NUMBER`](https://www.evm.codes/#43) మరియు [`DIFFICULTY`](https://www.evm.codes/#44) వంటివి | `block.number`, `block.difficulty`, మొదలైనవి. |
+| _I<sub>e</sub>_ | కాంట్రాక్ట్‌ల మధ్య కాల్స్ (కాంట్రాక్ట్ క్రియేషన్‌తో సహా) కోసం కాల్ స్టాక్ యొక్క లోతు              |                                                               |
+| _I<sub>w</sub>_ | EVM స్థితిని మార్చడానికి అనుమతించబడిందా, లేదా అది స్టాటిక్‌గా రన్ అవుతుందా                                           |                                                               |
+
+సెక్షన్ 9లోని మిగిలిన భాగాన్ని అర్థం చేసుకోవడానికి మరికొన్ని పారామితులు అవసరం:
+
+| పరామితి | సెక్షన్‌లో నిర్వచించబడింది                                     | అర్థం                                                                                                                                                                                                                                                              |
+| ------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| _σ_     | 2 (p. 2, సమీకరణం 1)         | బ్లాక్‌చైన్ యొక్క స్థితి                                                                                                                                                                                                                                           |
+| _g_     | 9.3 (p. 13) | మిగిలిన గ్యాస్                                                                                                                                                                                                                                                     |
+| _A_     | 6.1 (p. 8)  | సంచిత ఉపస్థితి (లావాదేవీ ముగిసినప్పుడు షెడ్యూల్ చేయబడిన మార్పులు)                                                                                                                                                                               |
+| _o_     | 9.3 (p. 13) | అంతర్గత లావాదేవీ (ఒక కాంట్రాక్టు మరొకటిని కాల్ చేసినప్పుడు) మరియు వ్యూ ఫంక్షన్‌లకు కాల్స్ (మీరు కేవలం సమాచారం కోసం అడుగుతున్నప్పుడు, కాబట్టి లావాదేవీ కోసం వేచి ఉండాల్సిన అవసరం లేదు) విషయంలో తిరిగి వచ్చే ఫలితం - అవుట్పుట్ |
+
+## 9.4 ఎగ్జిక్యూషన్ అవలోకనం {#94-execution-overview}
+
+ఇప్పుడు అన్ని ప్రాథమిక అంశాలు ఉన్నాయి, మనం చివరకు EVM ఎలా పనిచేస్తుందో పని చేయడం ప్రారంభించవచ్చు.
+
+సమీకరణాలు 137-142 EVMను అమలు చేయడానికి ప్రారంభ పరిస్థితులను మనకు ఇస్తాయి:
+
+| చిహ్నం           | ప్రారంభ విలువ                                                                    | అర్థం                                                                                                                                                                                                                                                                                                            |
+| ---------------- | -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| _μ<sub>g</sub>_  | _g_                                                                              | మిగిలిన గ్యాస్                                                                                                                                                                                                                                                                                                   |
+| _μ<sub>pc</sub>_ | _0_                                                                              | ప్రోగ్రామ్ కౌంటర్, అమలు చేయడానికి తదుపరి ఇన్స్ట్రక్షన్ యొక్క చిరునామా                                                                                                                                                                                                                                            |
+| _μ<sub>m</sub>_  | _(0, 0, ...)_ | మెమరీ, అన్ని సున్నాలకు ప్రారంభించబడింది                                                                                                                                                                                                                                                                          |
+| _μ<sub>i</sub>_  | _0_                                                                              | అత్యధిక మెమరీ స్థానం ఉపయోగించబడింది                                                                                                                                                                                                                                                                              |
+| _μ<sub>s</sub>_  | _()_                                                          | స్టాక్, ప్రారంభంలో ఖాళీగా ఉంటుంది                                                                                                                                                                                                                                                                                |
+| _μ<sub>o</sub>_  | _∅_                                                                              | అవుట్పుట్, మనం రిటర్న్ డేటాతో ([`RETURN`](https://www.evm.codes/#f3) లేదా [`REVERT`](https://www.evm.codes/#fd)) లేదా అది లేకుండా ([`STOP`](https://www.evm.codes/#00) లేదా [`SELFDESTRUCT`](https://www.evm.codes/#ff)) ఆపే వరకు మరియు ఆపకపోతే ఖాళీ సెట్. |
+
+సమీకరణం 143 మనకు అమలు సమయంలో ప్రతి సమయంలో నాలుగు సాధ్యమయ్యే పరిస్థితులు ఉన్నాయని, మరియు వాటితో ఏమి చేయాలో చెబుతుంది:
+
+1. `Z(σ,μ,A,I)`. Z అనేది ఒక ఆపరేషన్ చెల్లని స్థితి మార్పును సృష్టిస్తుందా లేదా అని పరీక్షించే ఒక ఫంక్షన్‌ను సూచిస్తుంది (చూడండి [అసాధారణమైన ఆపివేయడం](#942-exceptional-halting)). ఇది True అని మూల్యాంకనం చేస్తే, కొత్త స్థితి పాత దానితో సమానంగా ఉంటుంది (గ్యాస్ బర్న్ అవడం మినహా) ఎందుకంటే మార్పులు అమలు చేయబడలేదు.
+2. అమలు చేయబడుతున్న ఆప్‌కోడ్ [`REVERT`](https://www.evm.codes/#fd) అయితే, కొత్త స్థితి పాత స్థితి వలెనే ఉంటుంది, కొంత గ్యాస్ కోల్పోబడుతుంది.
+3. ఆపరేషన్ల క్రమం ముగిసినట్లయితే, [`RETURN`](https://www.evm.codes/#f3)) ద్వారా సూచించబడినట్లుగా, స్థితి కొత్త స్థితికి నవీకరించబడుతుంది.
+4. మనం 1-3 ముగింపు షరతులలో ఒకదానిలో లేకపోతే, రన్ చేయడం కొనసాగించండి.
+
+## 9.4.1 మెషీన్ స్థితి {#941-machine-state}
+
+ఈ విభాగం మెషీన్ స్థితిని మరింత వివరంగా వివరిస్తుంది. ఇది _w_ ప్రస్తుత ఆప్‌కోడ్ అని నిర్దేశిస్తుంది. _μ<sub>pc</sub>_ అనేది _||I<sub>b</sub>||_ కంటే తక్కువగా ఉంటే, అంటే సంకేత భాష యొక్క పొడవు కంటే, ఆ బైట్ (_I<sub>b</sub>[μ<sub>pc</sub>]_) ఆప్‌కోడ్. లేకపోతే, ఆప్‌కోడ్ [`STOP`](https://www.evm.codes/#00)గా నిర్వచించబడింది.
+
+ఇది ఒక [స్టాక్ మెషీన్](https://en.wikipedia.org/wiki/Stack_machine) కాబట్టి, ప్రతి ఆప్‌కోడ్ ద్వారా పాప్ చేయబడిన (_δ_) మరియు పుష్ చేయబడిన (_α_) అంశాల సంఖ్యను మనం ట్రాక్ చేయాలి.
+
+## 9.4.2 అసాధారణమైన నిలిపివేత {#942-exceptional-halt}
+
+ఈ విభాగం _Z_ ఫంక్షన్‌ను నిర్వచిస్తుంది, ఇది మనకు అసాధారణమైన ముగింపు ఎప్పుడు ఉంటుందో నిర్దేశిస్తుంది. ఇది ఒక [బూలియన్](https://en.wikipedia.org/wiki/Boolean_data_type) ఫంక్షన్, కాబట్టి ఇది [లాజికల్ ఆర్ కోసం _∨_](https://en.wikipedia.org/wiki/Logical_disjunction) మరియు [లాజికల్ అండ్ కోసం _∧_](https://en.wikipedia.org/wiki/Logical_conjunction) ఉపయోగిస్తుంది.
+
+ఈ షరతులలో ఏది నిజమైనా మనకు అసాధారణమైన నిలుపుదల ఉంటుంది:
+
+- **_μ<sub>g</sub> < C(σ,μ,A,I)_**
+  సెక్షన్ 9.2లో మనం చూసినట్లుగా, _C_ అనేది గ్యాస్ ఖర్చును నిర్దేశించే ఫంక్షన్. తదుపరి ఆప్‌కోడ్‌ను కవర్ చేయడానికి తగినంత గ్యాస్ మిగిలి లేదు.
+
+- **_δ<sub>w</sub>=∅_**
+  ఒక ఆప్‌కోడ్ కోసం పాప్ చేయబడిన ఐటెమ్‌ల సంఖ్య నిర్వచించబడకపోతే, అప్పుడు ఆ ఆప్‌కోడ్ కూడా నిర్వచించబడదు.
+
+- **_|| μ<sub>s</sub> || < δ<sub>w</sub>_**
+  స్టాక్ అండర్‌ఫ్లో, ప్రస్తుత ఆప్‌కోడ్ కోసం స్టాక్‌లో తగినన్ని ఐటెమ్‌లు లేవు.
+
+- **_w = JUMP ∧ μ<sub>s</sub>[0]∉D(I<sub>b</sub>)_**
+  ఆప్‌కోడ్ [`JUMP`](https://www.evm.codes/#56) మరియు చిరునామా [`JUMPDEST`](https://www.evm.codes/#5b) కాదు. గమ్యం [`JUMPDEST`](https://www.evm.codes/#5b) అయినప్పుడు మాత్రమే జంప్‌లు చెల్లుబాటు అవుతాయి.
+
+- **_w = JUMPI ∧ μ<sub>s</sub>[1]≠0 ∧ μ<sub>s</sub>[0] ∉ D(I<sub>b</sub>)_**
+  ఆప్‌కోడ్ [`JUMPI`](https://www.evm.codes/#57), షరతు నిజం (సున్నా కానిది) కాబట్టి జంప్ జరగాలి, మరియు చిరునామా [`JUMPDEST`](https://www.evm.codes/#5b) కాదు. గమ్యం [`JUMPDEST`](https://www.evm.codes/#5b) అయినప్పుడు మాత్రమే జంప్‌లు చెల్లుబాటు అవుతాయి.
+
+- **_w = RETURNDATACOPY ∧ μ<sub>s</sub>[1]+μ<sub>s</sub>[2]>|| μ<sub>o</sub> ||_**
+  ఆప్‌కోడ్ [`RETURNDATACOPY`](https://www.evm.codes/#3e). ఈ ఆప్‌కోడ్ స్టాక్ మూలకం _μ<sub>s</sub>[1]_ అనేది రిటర్న్ డేటా బఫర్‌లో చదవడానికి ఆఫ్‌సెట్, మరియు స్టాక్ మూలకం _μ<sub>s</sub>[2]_ అనేది డేటా పొడవు. మీరు రిటర్న్ డేటా బఫర్ ముగింపును దాటి చదవడానికి ప్రయత్నించినప్పుడు ఈ పరిస్థితి ఏర్పడుతుంది. కాల్‌డేటా లేదా సంకేత భాషకే అలాంటి షరతు లేదని గమనించండి. మీరు ఆ బఫర్‌ల ముగింపును దాటి చదవడానికి ప్రయత్నించినప్పుడు మీకు కేవలం సున్నాలు మాత్రమే వస్తాయి.
+
+- **_|| μ<sub>s</sub> || - δ<sub>w</sub> + α<sub>w</sub> > 1024_**
+
+  స్టాక్ పొంగి పొర్లు. ఆప్‌కోడ్‌ను అమలు చేయడం వల్ల 1024 కంటే ఎక్కువ ఐటెమ్‌లతో కూడిన స్టాక్ ఏర్పడితే, ఆపండి.
+
+- **_¬I<sub>w</sub> ∧ W(w,μ)_**
+  మనం స్టాటిక్‌గా రన్ చేస్తున్నామా ([¬ అనేది నిరాకరణ](https://en.wikipedia.org/wiki/Negation) మరియు మనం బ్లాక్‌చైన్ స్థితిని మార్చడానికి అనుమతించబడినప్పుడు _I<sub>w</sub>_ నిజం)?  అలా అయితే, మరియు మనం స్థితిని మార్చే ఆపరేషన్‌ను ప్రయత్నిస్తుంటే, అది జరగదు.
+
+  _W(w,μ)_ ఫంక్షన్ తరువాత సమీకరణం 150లో నిర్వచించబడింది. ఈ షరతులలో ఒకటి నిజమైతే _W(w,μ)_ నిజం:
+
+  - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_**
+    ఈ ఆప్‌కోడ్‌లు కొత్త కాంట్రాక్ట్‌ను సృష్టించడం, విలువను నిల్వ చేయడం లేదా ప్రస్తుత కాంట్రాక్ట్‌ను నాశనం చేయడం ద్వారా స్థితిని మారుస్తాయి.
+
+  - **_LOG0≤w ∧ w≤LOG4_**
+    మమ్మల్ని స్టాటిక్‌గా పిలిస్తే, మేము లాగ్ ఎంట్రీలను విడుదల చేయలేము.
+    లాగ్ ఆప్‌కోడ్‌లు అన్నీ [`LOG0` (A0)](https://www.evm.codes/#a0) మరియు [`LOG4` (A4)](https://www.evm.codes/#a4) మధ్య పరిధిలో ఉన్నాయి.
+    లాగ్ ఆప్‌కోడ్ తర్వాత ఉన్న సంఖ్య లాగ్ ఎంట్రీలో ఎన్ని టాపిక్‌లు ఉన్నాయో నిర్దేశిస్తుంది.
+
+  - **_w=CALL ∧ μ<sub>s</sub>[2]≠0_**
+    మీరు స్టాటిక్‌గా ఉన్నప్పుడు మరొక కాంట్రాక్ట్‌ను పిలవవచ్చు, కానీ అలా చేస్తే మీరు దానికి ETH బదిలీ చేయలేరు.
+
+- **_w = SSTORE ∧ μ<sub>g</sub> ≤ G<sub>callstipend</sub>_**
+  మీకు G<sub>callstipend</sub> (అపెండిక్స్ Gలో 2300గా నిర్వచించబడింది) కంటే ఎక్కువ గ్యాస్ ఉంటే తప్ప మీరు [`SSTORE`](https://www.evm.codes/#55)ను అమలు చేయలేరు.
+
+## 9.4.3 జంప్ డెస్టినేషన్ చెల్లుబాటు {#943-jump-dest-valid}
+
+ఇక్కడ మనం [`JUMPDEST`](https://www.evm.codes/#5b) ఆప్‌కోడ్‌లు ఏమిటో అధికారికంగా నిర్వచిస్తాము. మనం కేవలం 0x5B అనే బైట్ విలువను చూడలేము, ఎందుకంటే అది PUSH లోపల ఉండవచ్చు (మరియు అందువల్ల డేటా కానీ ఆప్‌కోడ్ కాదు).
+
+సమీకరణం (153)లో మనం _N(i,w)_ అనే ఫంక్షన్‌ను నిర్వచిస్తాము. మొదటి పారామీటర్, _i_, ఆప్‌కోడ్ యొక్క స్థానం. రెండవది, _w_, ఆప్‌కోడ్. w∈[PUSH1, PUSH32] అయితే, ఆప్‌కోడ్ ఒక PUSH అని అర్థం (చతురస్రాకార బ్రాకెట్‌లు ముగింపు బిందువులను కలిగి ఉన్న పరిధిని నిర్వచిస్తాయి). ఆ సందర్భంలో తదుపరి ఆప్‌కోడ్ _i+2+(w−PUSH1)_ వద్ద ఉంటుంది. [`PUSH1`](https://www.evm.codes/#60) కోసం మనం రెండు బైట్లు ముందుకు వెళ్ళాలి (PUSH స్వయంగా మరియు ఒక బైట్ విలువ), [`PUSH2`](https://www.evm.codes/#61) కోసం మనం మూడు బైట్లు ముందుకు వెళ్ళాలి ఎందుకంటే ఇది రెండు బైట్ల విలువ, మొదలైనవి. అన్ని ఇతర EVM ఆప్‌కోడ్‌లు కేవలం ఒక బైట్ పొడవు ఉంటాయి, కాబట్టి అన్ని ఇతర సందర్భాలలో _N(i,w)=i+1_.
+
+ఈ ఫంక్షన్ సమీకరణం (152)లో _D<sub>J</sub>(c,i)_ని నిర్వచించడానికి ఉపయోగించబడుతుంది, ఇది సంకేత భాష _c_లో, ఆప్‌కోడ్ స్థానం _i_తో ప్రారంభమయ్యే అన్ని చెల్లుబాటు అయ్యే జంప్ గమ్యస్థానాల [సెట్](https://en.wikipedia.org/wiki/Set_\(mathematics\)). ఈ ఫంక్షన్ పునరావృతంగా నిర్వచించబడింది. i≥||c||_ అయితే, అంటే మనం సంకేత భాష చివరిలో లేదా దాని తర్వాత ఉన్నాము. మనం ఇకపై జంప్ గమ్యస్థానాలను కనుగొనలేము, కాబట్టి ఖాళీ సెట్‌ను తిరిగి ఇవ్వండి.
+
+అన్ని ఇతర సందర్భాల్లో మనం తదుపరి ఆప్‌కోడ్‌కు వెళ్లి దాని నుండి ప్రారంభమయ్యే సెట్‌ను పొందడం ద్వారా సంకేత భాష యొక్క మిగిలిన భాగాన్ని చూస్తాము. _c[i]_ అనేది ప్రస్తుత ఆప్‌కోడ్, కాబట్టి _N(i,c[i])_ అనేది తదుపరి ఆప్‌కోడ్ యొక్క స్థానం. _D<sub>J</sub>(c,N(i,c[i]))_ అనేది తదుపరి ఆప్‌కోడ్ వద్ద ప్రారంభమయ్యే చెల్లుబాటు అయ్యే జంప్ గమ్యస్థానాల సెట్. ప్రస్తుత ఆప్‌కోడ్ `JUMPDEST` కాకపోతే, ఆ సెట్‌ను తిరిగి ఇవ్వండి. అది `JUMPDEST` అయితే, దానిని ఫలిత సెట్‌లో చేర్చి, దానిని తిరిగి ఇవ్వండి.
+
+## 9.4.4 సాధారణ నిలిపివేత {#944-normal-halt}
+
+నిలిపివేసే ఫంక్షన్ _H_, మూడు రకాల విలువలను తిరిగి ఇవ్వగలదు.
+
+- మనం హాల్ట్ ఆప్‌కోడ్‌లో లేకపోతే, _∅_, ఖాళీ సెట్‌ను తిరిగి ఇవ్వండి. సంప్రదాయం ప్రకారం, ఈ విలువ బూలియన్ ఫాల్స్‌గా అన్వయించబడుతుంది.
+- మనం అవుట్‌పుట్‌ను ఉత్పత్తి చేయని హాల్ట్ ఆప్‌కోడ్‌ను కలిగి ఉంటే ([`STOP`](https://www.evm.codes/#00) లేదా [`SELFDESTRUCT`](https://www.evm.codes/#ff)), రిటర్న్ విలువగా సున్నా పరిమాణం గల బైట్‌ల క్రమాన్ని తిరిగి ఇవ్వండి. ఇది ఖాళీ సెట్‌కు చాలా భిన్నమైనదని గమనించండి. ఈ విలువ అంటే EVM నిజంగా ఆగిపోయింది, కానీ చదవడానికి రిటర్న్ డేటా లేదు.
+- మనం అవుట్‌పుట్‌ను ఉత్పత్తి చేసే హాల్ట్ ఆప్‌కోడ్‌ను కలిగి ఉంటే ([`RETURN`](https://www.evm.codes/#f3) లేదా [`REVERT`](https://www.evm.codes/#fd)), ఆ ఆప్‌కోడ్ ద్వారా నిర్దేశించబడిన బైట్‌ల క్రమాన్ని తిరిగి ఇవ్వండి. ఈ క్రమం మెమరీ నుండి తీసుకోబడింది, స్టాక్ పైభాగంలో ఉన్న విలువ (_μ<sub>s</sub>[0]_) మొదటి బైట్, మరియు దాని తర్వాత ఉన్న విలువ (_μ<sub>s</sub>[1]_) పొడవు.
+
+## H.2 ఇన్స్ట్రక్షన్ సెట్ {#h2-instruction-set}
+
+మనం EVM యొక్క చివరి ఉపవిభాగం 9.5కు వెళ్లే ముందు, ఇన్స్ట్రక్షన్‌లనే చూద్దాం. అవి p. 29లో ప్రారంభమయ్యే అపెండిక్స్ H.2లో నిర్వచించబడ్డాయి. ఆ నిర్దిష్ట ఆప్‌కోడ్‌తో మారుతున్నట్లుగా పేర్కొనబడని ఏదైనా అదే విధంగా ఉంటుందని ఆశించబడుతుంది. మారే వేరియబుల్స్ \<something\>′గా పేర్కొనబడ్డాయి.
+
+ఉదాహరణకు, [`ADD`](https://www.evm.codes/#01) ఆప్‌కోడ్‌ను చూద్దాం.
+
+| విలువ | సంకేత నామం | δ | α | వివరణ                                                                                                                                                                                                                 |
+| ----: | ---------- | - | - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|  0x01 | ADD        | 2 | 1 | సంకలన ఆపరేషన్.                                                                                                                                                                                        |
+|       |            |   |   | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[0] + μ<sub>s</sub>[1]_ |
+
+_δ_ అనేది మనం స్టాక్ నుండి పాప్ చేసే విలువల సంఖ్య. ఈ సందర్భంలో రెండు, ఎందుకంటే మనం పై రెండు విలువలను కలుపుతున్నాము.
+
+_α_ అనేది మనం తిరిగి పుష్ చేసే విలువల సంఖ్య. ఈ సందర్భంలో ఒకటి, మొత్తం.
+
+కాబట్టి కొత్త స్టాక్ టాప్ (_μ′<sub>s</sub>[0]_) పాత స్టాక్ టాప్ (_μ<sub>s</sub>[0]_) మరియు దాని కింద ఉన్న పాత విలువ (_μ<sub>s</sub>[1]_) యొక్క మొత్తం.
+
+"కళ్ళు తిరిగే జాబితా"తో అన్ని ఆప్‌కోడ్‌లను పరిశీలించే బదులు, ఈ కథనం కొత్తది ఏదైనా పరిచయం చేసే ఆ ఆప్‌కోడ్‌లను మాత్రమే వివరిస్తుంది.
+
+| విలువ | సంకేత నామం | δ | α | వివరణ                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ----: | ---------- | - | - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|  0x20 | KECCAK256  | 2 | 1 | కీకాక్-256 హాష్‌ను లెక్కించండి.                                                                                                                                                                                                                                                                                                                                                                                                                      |
+|       |            |   |   | _μ′<sub>s</sub>[0] ≡ KEC(μ<sub>m</sub>[μ<sub>s</sub>[0] . . . (μ<sub>s</sub>[0] + μ<sub>s</sub>[1] − 1)])_ |
+|       |            |   |   | _μ′<sub>i</sub> ≡ M(μ<sub>i</sub>,μ<sub>s</sub>[0],μ<sub>s</sub>[1])_                                                                                                                                                                                                                                                                     |
+
+మెమరీని యాక్సెస్ చేసే మొదటి ఆప్‌కోడ్ ఇది (ఈ సందర్భంలో, రీడ్ ఓన్లీ). అయినప్పటికీ, ఇది మెమరీ యొక్క ప్రస్తుత పరిమితులకు మించి విస్తరించవచ్చు, కాబట్టి మనం _μ<sub>i</sub>_ ని నవీకరించాలి._ మనం దీనిని p. 29లోని సమీకరణం 328లో నిర్వచించబడిన _M_ ఫంక్షన్‌ను ఉపయోగించి చేస్తాము.
+
+| విలువ | సంకేత నామం | δ | α | వివరణ                                                    |
+| ----: | ---------- | - | - | -------------------------------------------------------- |
+|  0x31 | BALANCE    | 1 | 1 | ఇచ్చిన ఖాతా యొక్క బ్యాలెన్స్‌ను పొందండి. |
+|       |            |   |   | ...      |
+
+మనం బ్యాలెన్స్ కనుగొనవలసిన చిరునామా _μ<sub>s</sub>[0] mod 2<sup>160</sup>_. స్టాక్ పైన ఉన్నది చిరునామా, కానీ చిరునామాలు కేవలం 160 బిట్‌లు మాత్రమే కాబట్టి, మనం విలువను [మాడ్యులో](https://en.wikipedia.org/wiki/Modulo_operation) 2<sup>160</sup> లెక్కిస్తాము.
+
+σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] ≠ ∅_ అయితే, ఈ చిరునామా గురించి సమాచారం ఉందని అర్థం. ఆ సందర్భంలో, _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>]<sub>b</sub>_ ఆ చిరునామా యొక్క బ్యాలెన్స్. σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] = ∅_ అయితే, ఈ చిరునామా ప్రారంభించబడలేదని మరియు బ్యాలెన్స్ సున్నా అని అర్థం. మీరు p. 4లోని సెక్షన్ 4.1లో ఖాతా సమాచార ఫీల్డ్‌ల జాబితాను చూడవచ్చు.
+
+రెండవ సమీకరణం, _A'<sub>a</sub> ≡ A<sub>a</sub> ∪ \{μ<sub>s</sub>[0] mod 2<sup>160</sup>}_, వెచ్చని నిల్వ (ఇటీవల యాక్సెస్ చేయబడిన మరియు కాష్ చేయబడే అవకాశం ఉన్న నిల్వ) మరియు చల్లని నిల్వ (యాక్సెస్ చేయబడని మరియు తిరిగి పొందడానికి ఎక్కువ ఖరీదైన నెమ్మదిగా ఉన్న నిల్వలో ఉండే అవకాశం ఉన్న నిల్వ) మధ్య ఖర్చు వ్యత్యాసానికి సంబంధించినది. _A<sub>a</sub>_ అనేది లావాదేవీ ద్వారా గతంలో యాక్సెస్ చేయబడిన చిరునామా జాబితా, ఇది యాక్సెస్ చేయడానికి చౌకగా ఉండాలి, p. 8లోని సెక్షన్ 6.1లో నిర్వచించబడినట్లుగా. మీరు ఈ విషయం గురించి [EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)లో మరింత చదవవచ్చు.
+
+| విలువ | సంకేత నామం | δ  | α  | వివరణ                                                                                                                                           |
+| ----: | ---------- | -- | -- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
+|  0x8F | DUP16      | 16 | 17 | 16వ స్టాక్ ఐటెమ్‌ను డూప్లికేట్ చేయండి.                                                                                          |
+|       |            |    |    | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[15]_ |
+
+ఏదైనా స్టాక్ ఐటెమ్‌ను ఉపయోగించడానికి, మనం దానిని పాప్ చేయాలని గమనించండి, అంటే మనం దాని పైన ఉన్న అన్ని స్టాక్ ఐటెమ్‌లను కూడా పాప్ చేయాలి. [`DUP<n>`](https://www.evm.codes/#8f) మరియు [`SWAP<n>`](https://www.evm.codes/#9f) విషయంలో, దీని అర్థం పదహారు విలువల వరకు పాప్ చేసి, ఆపై పుష్ చేయవలసి ఉంటుంది.
+
+## 9.5 ఎగ్జిక్యూషన్ సైకిల్ {#95-exec-cycle}
+
+ఇప్పుడు మనకు అన్ని భాగాలు ఉన్నాయి, మనం చివరకు EVM యొక్క ఎగ్జిక్యూషన్ సైకిల్ ఎలా డాక్యుమెంట్ చేయబడిందో అర్థం చేసుకోవచ్చు.
+
+సమీకరణం (155) స్థితిని బట్టి ఇలా చెబుతుంది:
+
+- _σ_ (గ్లోబల్ బ్లాక్‌చైన్ స్థితి)
+- _μ_ (EVM స్థితి)
+- _A_ (ఉపస్థితి, లావాదేవీ ముగిసినప్పుడు జరిగే మార్పులు)
+- _I_ (ఎగ్జిక్యూషన్ ఎన్విరాన్మెంట్)
+
+కొత్త స్థితి _(σ', μ', A', I')_.
+
+సమీకరణాలు (156)-(158) స్టాక్‌ను మరియు ఒక ఆప్‌కోడ్ (_μ<sub>s</sub>_) కారణంగా అందులో జరిగే మార్పును నిర్వచిస్తాయి. సమీకరణం (159) అనేది గ్యాస్‌లో మార్పు (_μ<sub>g</sub>_). సమీకరణం (160) ప్రోగ్రామ్ కౌంటర్ (_μ<sub>pc</sub>_)లో మార్పు. చివరగా, సమీకరణాలు (161)-(164) ఇతర పారామీటర్లు ఆప్‌కోడ్ ద్వారా స్పష్టంగా మార్చబడకపోతే అవే విధంగా ఉంటాయని నిర్దేశిస్తాయి.
+
+దీనితో EVM పూర్తిగా నిర్వచించబడింది.
+
+## ముగింపు {#conclusion}
+
+గణిత సంజ్ఞామానం కచ్చితమైనది మరియు ఎల్లో పేపర్ ఇతీరియము యొక్క ప్రతి వివరాలను పేర్కొనడానికి అనుమతించింది. అయినప్పటికీ, దీనికి కొన్ని ప్రతికూలతలు ఉన్నాయి:
+
+- ఇది మానవులకు మాత్రమే అర్థమవుతుంది, అంటే [కంప్లయన్స్ టెస్టులు](https://github.com/ethereum/tests) మాన్యువల్‌గా వ్రాయబడాలి.
+- ప్రోగ్రామర్లు కంప్యూటర్ సంకేత భాషను అర్థం చేసుకుంటారు.
+  వారు గణిత సంజ్ఞామానాన్ని అర్థం చేసుకోవచ్చు లేదా చేసుకోకపోవచ్చు.
+
+బహుశా ఈ కారణాల వల్ల, కొత్త [ఏకాభిప్రాయం లేయర్ స్పెక్స్](https://github.com/ethereum/consensus-specs/blob/dev/tests/core/pyspec/README.md) పైథాన్‌లో వ్రాయబడ్డాయి. [పైథాన్‌లో ఎగ్జిక్యూషన్ లేయర్ స్పెక్స్](https://ethereum.github.io/execution-specs) ఉన్నాయి, కానీ అవి పూర్తి కాలేదు. మొత్తం ఎల్లో పేపర్‌ను పైథాన్ లేదా అలాంటి భాషలోకి అనువదించే వరకు మరియు అనువదించనంత వరకు, ఎల్లో పేపర్ సేవలో కొనసాగుతుంది, మరియు దానిని చదవగలగడం సహాయకరంగా ఉంటుంది.
diff --git a/public/content/translations/te/eips/index.md b/public/content/translations/te/eips/index.md
new file mode 100644
index 00000000000..9022261f6e3
--- /dev/null
+++ b/public/content/translations/te/eips/index.md
@@ -0,0 +1,78 @@
+---
+title: "ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనలు (EIPలు)"
+description: "EIPలను అర్థం చేసుకోవడానికి మీకు అవసరమైన ప్రాథమిక సమాచారం"
+lang: te
+---
+
+# ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనలు (EIPల)కు పరిచయం {#introduction-to-ethereum-improvement-proposals}
+
+## EIPలు అంటే ఏమిటి? {#what-are-eips}
+
+[ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనలు (EIPలు)](https://eips.ethereum.org/) అనేవి ఎథేరియం కోసం సంభావ్య కొత్త ఫీచర్‌లు లేదా ప్రక్రియలను నిర్దేశించే ప్రమాణాలు. EIPలు ప్రతిపాదిత మార్పుల కోసం సాంకేతిక నిర్దేశాలను కలిగి ఉంటాయి మరియు కమ్యూనిటీకి “సత్యానికి మూలంగా” పనిచేస్తాయి. ఎథేరియం కోసం నెట్‌వర్క్ అప్‌గ్రేడ్‌లు మరియు అప్లికేషన్ ప్రమాణాలు EIP ప్రక్రియ ద్వారా చర్చించబడతాయి మరియు అభివృద్ధి చేయబడతాయి.
+
+ఎథేరియం కమ్యూనిటీలో ఎవరైనా EIPని సృష్టించే సామర్థ్యాన్ని కలిగి ఉంటారు. EIPలను వ్రాయడానికి మార్గదర్శకాలు [EIP-1](https://eips.ethereum.org/EIPS/eip-1)లో చేర్చబడ్డాయి. ఒక EIP ప్రాథమికంగా చిన్న ప్రేరణతో సంక్షిప్త సాంకేతిక నిర్దేశాలను అందించాలి. EIP రచయిత కమ్యూనిటీలో ఏకాభిప్రాయం సాధించడానికి మరియు ప్రత్యామ్నాయ అభిప్రాయాలను నమోదు చేయడానికి బాధ్యత వహిస్తారు. చక్కగా రూపొందించిన EIPని సమర్పించడానికి అధిక సాంకేతిక అవరోధం ఉన్నందున, చారిత్రాత్మకంగా, చాలా మంది EIP రచయితలు సాధారణంగా అప్లికేషన్ లేదా ప్రోటోకాల్ అభివృద్ధి చేసేవారు.
+
+## EIPలు ఎందుకు ముఖ్యమైనవి? {#why-do-eips-matter}
+
+ఎథేరియంలో మార్పులు ఎలా జరుగుతాయి మరియు డాక్యుమెంట్ చేయబడతాయి అనే విషయంలో EIPలు కీలక పాత్ర పోషిస్తాయి. ప్రజలు మార్పులను ప్రతిపాదించడానికి, చర్చించడానికి మరియు స్వీకరించడానికి ఇవి మార్గం. [వివిధ రకాల EIPలు](https://eips.ethereum.org/EIPS/eip-1#eip-types) ఉన్నాయి, వీటిలో ఏకాభిప్రాయాన్ని ప్రభావితం చేసే మరియు [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) వంటి నెట్‌వర్క్ అప్‌గ్రేడ్ అవసరమయ్యే తక్కువ-స్థాయి ప్రోటోకాల్ మార్పుల కోసం కోర్ EIPలు, మరియు [EIP-20](https://eips.ethereum.org/EIPS/eip-20) మరియు [EIP-721](https://eips.ethereum.org/EIPS/eip-721) వంటి అప్లికేషన్ ప్రమాణాల కోసం ERCలు ఉన్నాయి.
+
+ప్రతి నెట్‌వర్క్ అప్‌గ్రేడ్‌లో నెట్‌వర్క్‌లోని ప్రతి [ఎథేరియం క్లయింట్](/learn/#clients-and-nodes) ద్వారా అమలు చేయాల్సిన EIPల సెట్ ఉంటుంది. దీనర్థం ఎథేరియం మెయిన్‌నెట్‌లోని ఇతర క్లయింట్‌లతో ఏకాభిప్రాయంలో ఉండటానికి, క్లయింట్ అభివృద్ధి చేసేవారు అవసరమైన అన్ని EIPలను అమలు చేశారని నిర్ధారించుకోవాలి.
+
+మార్పుల కోసం సాంకేతిక నిర్దేశాలను అందించడంతో పాటు, EIPలు ఎథేరియంలో పాలన జరిగే యూనిట్: ఎవరైనా ఒకదాన్ని ప్రతిపాదించడానికి స్వేచ్ఛ ఉంది, ఆపై కమ్యూనిటీలోని వివిధ వాటాదారులు దానిని ఒక ప్రమాణంగా స్వీకరించాలా లేదా నెట్‌వర్క్ అప్‌గ్రేడ్‌లో చేర్చాలా అని నిర్ణయించడానికి చర్చిస్తారు. కోర్-యేతర EIPలను అన్ని అప్లికేషన్‌లు స్వీకరించాల్సిన అవసరం లేదు (ఉదాహరణకు, EIP-20ని అమలు చేయని ఫంగిబుల్ టోకెన్‌ను సృష్టించడం సాధ్యమవుతుంది), కానీ కోర్ EIPలు విస్తృతంగా స్వీకరించబడాలి (ఎందుకంటే అన్ని నోడ్‌లు ఒకే నెట్‌వర్క్‌లో భాగంగా ఉండటానికి అప్‌గ్రేడ్ చేయాలి), కోర్-యేతర EIPల కంటే కోర్ EIPలకు కమ్యూనిటీలో విస్తృత ఏకాభిప్రాయం అవసరం.
+
+## EIPల చరిత్ర {#history-of-eips}
+
+[ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనల (EIPs) GitHub రిపోజిటరీ](https://github.com/ethereum/EIPs) అక్టోబర్ 2015లో సృష్టించబడింది. EIP ప్రక్రియ [బిట్‌కాయిన్ ఇంప్రూవ్‌మెంట్ ప్రతిపాదనల (BIPలు)](https://github.com/bitcoin/bips) ప్రక్రియపై ఆధారపడి ఉంటుంది, ఇది [పైథాన్ ఎన్‌హాన్స్‌మెంట్ ప్రతిపాదనల (PEPలు)](https://www.python.org/dev/peps/) ప్రక్రియపై ఆధారపడి ఉంటుంది.
+
+EIP ఎడిటర్‌లు సాంకేతిక పటిష్టత, ఫార్మాటింగ్ సమస్యలు మరియు స్పెల్లింగ్, వ్యాకరణం మరియు కోడ్ శైలిని సరిచేయడం కోసం EIPలను సమీక్షించే ప్రక్రియతో విధులు నిర్వహిస్తారు. మార్టిన్ బెక్జ్, విటాలిక్ బుటెరిన్, గావిన్ వుడ్, మరియు మరికొందరు 2015 నుండి 2016 చివరి వరకు అసలు EIP ఎడిటర్‌లుగా ఉన్నారు.
+
+ప్రస్తుత EIP ఎడిటర్‌లు
+
+- అలెక్స్ బెరెగ్జాస్జీ (@axic)
+- గావిన్ జాన్ (@Pandapip1)
+- గ్రెగ్ కోల్విన్ (@gcolvin)
+- మాట్ గార్నెట్ (@lightclient)
+- సామ్ విల్సన్ (@SamWilsn)
+
+ఎమెరిటస్ EIP ఎడిటర్‌లు
+
+- కేసీ డెట్రియో (@cdetrio)
+- హడ్సన్ జేమ్సన్ (@Souptacular)
+- మార్టిన్ బెక్జ్ (@wanderer)
+- మైకా జోల్టు (@MicahZoltu)
+- నిక్ జాన్సన్ (@arachnid)
+- నిక్ సేవర్స్ (@nicksavers)
+- విటాలిక్ బుటెరిన్ (@vbuterin)
+
+మీరు EIP ఎడిటర్ కావాలనుకుంటే, దయచేసి [EIP-5069](https://eips.ethereum.org/EIPS/eip-5069)ని తనిఖీ చేయండి.
+
+ఒక ప్రతిపాదన EIPగా మారడానికి సిద్ధంగా ఉన్నప్పుడు EIP ఎడిటర్‌లు నిర్ణయిస్తారు మరియు EIP రచయితలు వారి ప్రతిపాదనలను ముందుకు తీసుకెళ్లడంలో సహాయపడతారు. [ఎథేరియం క్యాట్ హెర్డర్స్](https://www.ethereumcatherders.com/) EIP ఎడిటర్‌లు మరియు కమ్యూనిటీ మధ్య సమావేశాలను నిర్వహించడంలో సహాయపడతారు ([EIPIP](https://github.com/ethereum-cat-herders/EIPIP) చూడండి).
+
+చార్ట్‌తో పాటు పూర్తి ప్రామాణీకరణ ప్రక్రియ [EIP-1](https://eips.ethereum.org/EIPS/eip-1)లో వివరించబడింది
+
+## మరింత తెలుసుకోండి {#learn-more}
+
+మీరు EIPల గురించి మరింత చదవడానికి ఆసక్తి కలిగి ఉంటే, [EIPల వెబ్‌సైట్](https://eips.ethereum.org/) మరియు [EIP-1](https://eips.ethereum.org/EIPS/eip-1)ని చూడండి. ఇక్కడ కొన్ని ఉపయోగకరమైన లింక్‌లు ఉన్నాయి:
+
+- [ప్రతి ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదన జాబితా](https://eips.ethereum.org/all)
+- [అన్ని EIP రకాల వివరణ](https://eips.ethereum.org/EIPS/eip-1#eip-types)
+- [అన్ని EIP స్టేటస్‌ల వివరణ](https://eips.ethereum.org/EIPS/eip-1#eip-process)
+
+### కమ్యూనిటీ విద్యా ప్రాజెక్ట్‌లు {#community-projects}
+
+- [PEEPanEIP](https://www.youtube.com/playlist?list=PL4cwHXAawZxqu0PKKyMzG_3BJV_xZTi1F) — _PEEPanEIP అనేది ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదన (EIPలు) మరియు రాబోయే అప్‌గ్రేడ్‌ల యొక్క ముఖ్య లక్షణాలను చర్చించే ఒక విద్యా వీడియో సిరీస్._
+- [EIPs.wtf](https://www.eips.wtf/) — _EIPs.wtf ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనల (EIPలు) కోసం అదనపు సమాచారాన్ని అందిస్తుంది, ఇందులో వాటి స్టేటస్, అమలు వివరాలు, సంబంధిత పుల్ రిక్వెస్ట్‌లు మరియు కమ్యూనిటీ ఫీడ్‌బ్యాక్ ఉన్నాయి._
+- [EIP.Fun](https://eipfun.substack.com/) — _EIP.Fun ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనల (EIPలు)పై తాజా వార్తలు, EIP సమావేశాలపై అప్‌డేట్‌లు మరియు మరిన్నింటిని అందిస్తుంది._
+- [EIPs Insight](https://eipsinsight.com/) — _EIPs ఇన్‌సైట్ అనేది వివిధ వనరుల నుండి సేకరించిన సమాచారం ప్రకారం ఎథేరియం ఇంప్రూవ్‌మెంట్ ప్రతిపాదనల (EIPలు) ప్రక్రియ & గణాంకాల స్థితిని సూచిస్తుంది._
+
+## పాల్గొనండి {#participate}
+
+ఎవరైనా EIPని సృష్టించవచ్చు. ప్రతిపాదనను సమర్పించే ముందు, ఒకరు [EIP-1](https://eips.ethereum.org/EIPS/eip-1)ని చదవాలి, ఇది EIP ప్రక్రియను మరియు EIP ఎలా వ్రాయాలో వివరిస్తుంది, మరియు [ఎథేరియం మేజిషియన్స్](https://ethereum-magicians.org/)పై ఫీడ్‌బ్యాక్‌ను అభ్యర్థించాలి, ఇక్కడ డ్రాఫ్ట్ సమర్పించే ముందు ప్రతిపాదనలు మొదట కమ్యూనిటీతో చర్చించబడతాయి.
+
+## సూచనలు {#references}
+
+<cite class="citation">
+
+హడ్సన్ జేమ్సన్ రాసిన [ఎథేరియం ప్రోటోకాల్ డెవలప్‌మెంట్ గవర్నెన్స్ మరియు నెట్‌వర్క్ అప్‌గ్రేడ్ కోఆర్డినేషన్](https://hudsonjameson.com/posts/2020-03-23-ethereum-protocol-development-governance-and-network-upgrade-coordination/) నుండి పాక్షికంగా అందించబడిన పేజీ కంటెంట్
+
+</cite>
diff --git a/public/content/translations/te/energy-consumption/index.md b/public/content/translations/te/energy-consumption/index.md
new file mode 100644
index 00000000000..fa87292c147
--- /dev/null
+++ b/public/content/translations/te/energy-consumption/index.md
@@ -0,0 +1,86 @@
+---
+title: "ఇథిరియం శక్తి వినియోగం"
+description: "ఇథిరియం యొక్క శక్తి వినియోగాన్ని అర్థం చేసుకోవడానికి మీకు అవసరమైన ప్రాథమిక సమాచారం."
+lang: te
+---
+
+# ఇథిరియం యొక్క శక్తి వ్యయం {#proof-of-stake-energy}
+
+ఇథిరియం ఒక గ్రీన్ బ్లాక్‌చెయిన్. ఇథిరియం యొక్క [ప్రూఫ్-ఆఫ్-స్టేక్](/developers/docs/consensus-mechanisms/pos) ఏకాభిప్రాయ యంత్రాంగం [నెట్‌వర్క్‌ను సురక్షితం చేయడానికి శక్తి](/developers/docs/consensus-mechanisms/pow)కి బదులుగా ETHను ఉపయోగిస్తుంది. మొత్తం గ్లోబల్ నెట్‌వర్క్‌లో ఇథిరియం యొక్క శక్తి వినియోగం సుమారుగా [~0.0026 TWh/yr](https://carbon-ratings.com/eth-report-2022)గా ఉంది.
+
+ఇథిరియం కోసం శక్తి వినియోగ అంచనా [CCRI (క్రిప్టో కార్బన్ రేటింగ్స్ ఇన్‌స్టిట్యూట్)](https://carbon-ratings.com) అధ్యయనం నుండి వచ్చింది. వారు ఇథిరియం నెట్‌వర్క్ యొక్క విద్యుత్ వినియోగం మరియు కార్బన్ ఫుట్‌ప్రింట్ యొక్క బాటమ్-అప్ అంచనాలను రూపొందించారు ([నివేదికను చూడండి](https://carbon-ratings.com/eth-report-2022)). వారు వివిధ హార్డ్‌వేర్ మరియు క్లయింట్ సాఫ్ట్‌వేర్ కాన్ఫిగరేషన్‌లతో విభిన్న నోడ్‌ల విద్యుత్ వినియోగాన్ని కొలిచారు. నెట్‌వర్క్ యొక్క వార్షిక విద్యుత్ వినియోగం కోసం అంచనా వేయబడిన **2,601 MWh** (0.0026 TWh), ప్రాంతీయ-నిర్దిష్ట కార్బన్ తీవ్రత కారకాలను వర్తింపజేయడం ద్వారా **870 టన్నుల CO2e** వార్షిక కార్బన్ ఉద్గారాలకు అనుగుణంగా ఉంటుంది. నోడ్‌లు నెట్‌వర్క్‌లోకి ప్రవేశించినప్పుడు మరియు నిష్క్రమించినప్పుడు ఈ విలువ మారుతుంది - మీరు [కేంబ్రిడ్జ్ బ్లాక్‌చెయిన్ నెట్‌వర్క్ సస్టైనబిలిటీ ఇండెక్స్](https://ccaf.io/cbnsi/ethereum) ద్వారా రోలింగ్ 7-రోజుల సగటు అంచనాను ఉపయోగించి ట్రాక్ చేయవచ్చు (గమనిక: వారు తమ అంచనాల కోసం కొద్దిగా భిన్నమైన పద్ధతిని ఉపయోగిస్తారు - వివరాలు వారి సైట్‌లో అందుబాటులో ఉన్నాయి).
+
+ఇథిరియం యొక్క శక్తి వినియోగాన్ని సందర్భోచితంగా చెప్పాలంటే, మేము కొన్ని ఇతర ఉత్పత్తులు మరియు పరిశ్రమల కోసం వార్షిక అంచనాలను పోల్చవచ్చు. ఇథిరియం కోసం అంచనా ఎక్కువగా ఉందా లేదా తక్కువగా ఉందా అని బాగా అర్థం చేసుకోవడానికి ఇది మాకు సహాయపడుతుంది.
+
+<EnergyConsumptionChart />
+
+పైన ఉన్న చార్ట్ అనేక ఇతర ఉత్పత్తులు మరియు పరిశ్రమలతో పోలిస్తే, ఇథిరియం కోసం TWh/yrలో అంచనా వేయబడిన శక్తి వినియోగాన్ని ప్రదర్శిస్తుంది. అందించిన అంచనాలు జూలై 2023లో యాక్సెస్ చేయబడిన, పబ్లిక్‌గా అందుబాటులో ఉన్న సమాచారం నుండి తీసుకోబడ్డాయి, దిగువ పట్టికలో మూలాలకు లింక్‌లు అందుబాటులో ఉన్నాయి.
+
+|                       | వార్షిక శక్తి వినియోగం (TWh) | PoS ఇథిరియంతో పోలిక |                                                                                     మూలాధారం                                                                                    |
+| :-------------------- | :---------------------------------------------: | :-----------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
+| గ్లోబల్ డేటా సెంటర్లు |                       190                       |       73,000x       |                                    [మూలం](https://www.iea.org/commentaries/data-centres-and-energy-from-global-headlines-to-local-headaches)                                    |
+| బిట్‌కాయిన్           |                       149                       |       53,000x       |                                                                 [మూలం](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
+| గోల్డ్ మైనింగ్        |                       131                       |       50,000x       |                                                                 [మూలం](https://ccaf.io/cbnsi/cbeci/comparisons)                                                                 |
+| USAలో గేమింగ్\*       |                        34                       |       13,000x       |                 [మూలం](https://www.researchgate.net/publication/336909520_Toward_Greener_Gaming_Estimating_National_Energy_Use_and_Energy_Efficiency_Potential)                 |
+| PoW ఇథిరియం           |                        21                       |        8,100x       |                                                                     [మూలం](https://ccaf.io/cbnsi/ethereum/1)                                                                    |
+| గూగుల్                |                        19                       |        7,300x       |                                           [మూలం](https://www.gstatic.com/gumdrop/sustainability/google-2022-environmental-report.pdf)                                           |
+| Netflix               |              0.457              |         176x        | [మూలం](https://assets.ctfassets.net/4cd45et68cgf/7B2bKCqkXDfHLadrjrNWD8/e44583e5b288bdf61e8bf3d7f8562884/2021_US_EN_Netflix_EnvironmentalSocialGovernanceReport-2021_Final.pdf) |
+| PayPal                |               0.26              |         100x        |                                  [మూలం](https://s202.q4cdn.com/805890769/files/doc_downloads/global-impact/CDP_Climate_Change_PayPal-\(1\).pdf)                                 |
+| AirBnB                |               0.02              |          8x         |                              [మూలం](https://s26.q4cdn.com/656283129/files/doc_downloads/governance_doc_updated/Airbnb-ESG-Factsheet-\(Final\).pdf)                              |
+| **PoS ఇథిరియం**       |            **0.0026**           |        **1x**       |                                                                [మూలం](https://carbon-ratings.com/eth-report-2022)                                                               |
+
+\*PCలు, ల్యాప్‌టాప్‌లు మరియు గేమింగ్ కన్సోల్‌ల వంటి ఎండ్ యూజర్ పరికరాలను కలిగి ఉంటుంది.
+
+శక్తి వినియోగం కోసం కచ్చితమైన అంచనాలను పొందడం సంక్లిష్టమైనది, ప్రత్యేకించి కొలవబడుతున్నది సంక్లిష్టమైన సరఫరా గొలుసు లేదా దాని సామర్థ్యాన్ని ప్రభావితం చేసే విస్తరణ వివరాలను కలిగి ఉన్నప్పుడు. ఉదాహరణకు, నెట్‌ఫ్లిక్స్ మరియు గూగుల్ కోసం శక్తి వినియోగ అంచనాలు వాటి సిస్టమ్‌లను నిర్వహించడానికి మరియు వినియోగదారులకు కంటెంట్‌ను అందించడానికి ఉపయోగించే శక్తిని మాత్రమే కలిగి ఉన్నాయా (_ప్రత్యక్ష వ్యయం_) లేదా కంటెంట్‌ను ఉత్పత్తి చేయడానికి, కార్పొరేట్ కార్యాలయాలను నడపడానికి, ప్రకటనలు మొదలైన వాటికి అవసరమైన వ్యయాన్ని కలిగి ఉన్నాయా (_పరోక్ష వ్యయం_) అనే దానిపై ఆధారపడి ఉంటాయి. పరోక్ష వ్యయంలో టీవీలు, కంప్యూటర్లు మరియు మొబైల్స్ వంటి ఎండ్-యూజర్ పరికరాలలో కంటెంట్‌ను వినియోగించడానికి అవసరమైన శక్తి కూడా ఉండవచ్చు.
+
+పైన ఉన్న అంచనాలు సరైన పోలికలు కావు. లెక్కించబడిన పరోక్ష వ్యయం మొత్తం మూలాన్ని బట్టి మారుతుంది మరియు చాలా అరుదుగా ఎండ్-యూజర్ పరికరాల నుండి శక్తిని కలిగి ఉంటుంది. ప్రతి అంతర్లీన మూలం ఏమి కొలవబడుతుందో దాని గురించి మరిన్ని వివరాలను కలిగి ఉంటుంది.
+
+పైన ఉన్న పట్టిక మరియు చార్ట్‌లో బిట్‌కాయిన్ మరియు ప్రూఫ్-ఆఫ్-వర్క్ ఇథిరియంతో పోలికలు కూడా ఉన్నాయి. ప్రూఫ్-ఆఫ్-వర్క్ నెట్‌వర్క్‌ల శక్తి వినియోగం స్థిరంగా ఉండదని మరియు రోజువారీగా మారుతుందని గమనించడం ముఖ్యం. అంచనాలు మూలాల మధ్య కూడా విస్తృతంగా మారవచ్చు. వినియోగించే శక్తి మొత్తం గురించి మాత్రమే కాకుండా, ఆ శక్తి యొక్క మూలాలు మరియు సంబంధిత నైతిక విలువల గురించి కూడా ఈ అంశం సూక్ష్మమైన [చర్చ](https://www.coindesk.com/business/2020/05/19/the-last-word-on-bitcoins-energy-consumption/)ను ఆకర్షిస్తుంది. శక్తి వినియోగం పర్యావరణ పాదముద్రకు కచ్చితంగా సరిపోలవలసిన అవసరం లేదు, ఎందుకంటే వేర్వేరు ప్రాజెక్టులు పునరుత్పాదక ఇంధనాల తక్కువ లేదా ఎక్కువ నిష్పత్తితో సహా విభిన్న శక్తి వనరులను ఉపయోగించవచ్చు. ఉదాహరణకు, [కేంబ్రిడ్జ్ బిట్‌కాయిన్ ఎలక్ట్రిసిటీ కన్సమ్ప్షన్ ఇండెక్స్](https://ccaf.io/cbnsi/cbeci/comparisons) ప్రకారం, బిట్‌కాయిన్ నెట్‌వర్క్ డిమాండ్‌ను సిద్ధాంతపరంగా గ్యాస్ ఫ్లేరింగ్ లేదా ప్రసారం మరియు పంపిణీలో నష్టపోయే విద్యుత్తు ద్వారా శక్తినివ్వవచ్చని సూచిస్తుంది. స్థిరత్వం కోసం ఇథిరియం మార్గం నెట్‌వర్క్‌లోని శక్తి-ఆకలితో ఉన్న భాగాన్ని గ్రీన్ ప్రత్యామ్నాయంతో భర్తీ చేయడం.
+
+మీరు [కేంబ్రిడ్జ్ బ్లాక్‌చెయిన్ నెట్‌వర్క్ సస్టైనబిలిటీ ఇండెక్స్ సైట్](https://ccaf.io/cbnsi/ethereum)లో అనేక పరిశ్రమల కోసం శక్తి వినియోగం మరియు కార్బన్ ఉద్గారాల అంచనాలను బ్రౌజ్ చేయవచ్చు.
+
+## లావాదేవీకి అంచనాలు {#per-transaction-estimates}
+
+చాలా ఆర్టికల్స్ బ్లాక్‌చెయిన్‌ల కోసం "లావాదేవీకి" అయ్యే శక్తి వ్యయాన్ని అంచనా వేస్తాయి. ఒక బ్లాక్‌ను ప్రతిపాదించడానికి మరియు ధృవీకరించడానికి అవసరమైన శక్తి దానిలోని లావాదేవీల సంఖ్యతో సంబంధం లేకుండా ఉంటుంది కాబట్టి ఇది తప్పుదారి పట్టించవచ్చు. లావాదేవీకి ఒక యూనిట్ శక్తి వ్యయం అంటే తక్కువ లావాదేవీలు తక్కువ శక్తి వ్యయానికి దారితీస్తాయని మరియు దీనికి విరుద్ధంగా ఉంటుందని సూచిస్తుంది, కానీ అది అలా కాదు. అలాగే, లావాదేవీకి అంచనాలు బ్లాక్‌చెయిన్ యొక్క లావాదేవీ నిర్గమాంశను ఎలా నిర్వచిస్తారనే దానిపై చాలా సున్నితంగా ఉంటాయి, మరియు ఈ నిర్వచనాన్ని మార్చడం ద్వారా విలువను పెద్దదిగా లేదా చిన్నదిగా కనిపించేలా చేయవచ్చు.
+
+ఉదాహరణకు, ఇథిరియంలో, లావాదేవీ నిర్గమాంశ బేస్ లేయర్‌ది మాత్రమే కాదు - ఇది దాని అన్ని "[లేయర్ 2](/layer-2/)" రోలప్‌ల లావాదేవీ నిర్గమాంశల మొత్తం కూడా. లేయర్ 2లు సాధారణంగా గణనలలో చేర్చబడవు, కానీ సీక్వెన్సర్ల ద్వారా వినియోగించే అదనపు శక్తి (చిన్నది) మరియు అవి ప్రాసెస్ చేసే లావాదేవీల సంఖ్య (పెద్దది)ను లెక్కించడం వల్ల లావాదేవీకి అంచనాలు గణనీయంగా తగ్గే అవకాశం ఉంది. ప్లాట్‌ఫారమ్‌ల అంతటా లావాదేవీకి శక్తి వినియోగం యొక్క పోలికలు తప్పుదారి పట్టించడానికి ఇది ఒక కారణం.
+
+## ఇథిరియం యొక్క కార్బన్ రుణం {#carbon-debt}
+
+ఇథిరియం యొక్క శక్తి వ్యయం చాలా తక్కువ, కానీ ఇది ఎల్లప్పుడూ అలా లేదు. ఇథిరియం వాస్తవానికి ప్రూఫ్-ఆఫ్-వర్క్‌ను ఉపయోగించింది, ఇది ప్రస్తుత ప్రూఫ్-ఆఫ్-స్టేక్ యంత్రాంగం కంటే చాలా ఎక్కువ పర్యావరణ వ్యయాన్ని కలిగి ఉంది.
+
+మొదటి నుండి, ఇథిరియం ప్రూఫ్-ఆఫ్-స్టేక్ ఆధారిత ఏకాభిప్రాయ యంత్రాంగాన్ని అమలు చేయడానికి ప్రణాళిక వేసింది, కానీ భద్రత మరియు వికేంద్రీకరణను త్యాగం చేయకుండా అలా చేయడానికి సంవత్సరాల తరబడి పరిశోధన మరియు అభివృద్ధి పట్టింది. అందువల్ల, నెట్‌వర్క్‌ను ప్రారంభించడానికి ప్రూఫ్-ఆఫ్-వర్క్ యంత్రాంగం ఉపయోగించబడింది. ప్రూఫ్-ఆఫ్-వర్క్ కోసం మైనర్లు తమ కంప్యూటింగ్ హార్డ్‌వేర్‌ను ఉపయోగించి ఒక విలువను లెక్కించాలి, ఈ ప్రక్రియలో శక్తిని వెచ్చించాలి.
+
+![ది మెర్జ్‌కు ముందు మరియు తరువాత ఇథిరియం యొక్క శక్తి వినియోగాన్ని పోల్చడం, ది మెర్జ్‌కు ముందు అధిక శక్తి వినియోగాన్ని సూచించడానికి ఎడమ వైపున ఈఫిల్ టవర్‌ను (330 మీటర్ల ఎత్తు) ఉపయోగించడం, మరియు ది మెర్జ్ తరువాత శక్తి వినియోగంలో నాటకీయ తగ్గింపును సూచించడానికి కుడి వైపున 4 సెం.మీ ఎత్తు ఉన్న చిన్న లెగో బొమ్మను ఉపయోగించడం](energy_consumption_pre_post_merge.png)
+
+CCRI అంచనా ప్రకారం, ది మెర్జ్ ఇథిరియం యొక్క వార్షిక విద్యుత్ వినియోగాన్ని **99.988%** కంటే ఎక్కువ తగ్గించింది. అదేవిధంగా, ఇథిరియం యొక్క కార్బన్ పాదముద్ర సుమారుగా **99.992%** తగ్గింది (11,016,000 నుండి 870 టన్నుల CO2eకి). దీనిని దృక్కోణంలో ఉంచడానికి, ఉద్గారాల తగ్గింపు ఈఫిల్ టవర్ ఎత్తు నుండి ఒక చిన్న ప్లాస్టిక్ బొమ్మ బొమ్మకు వెళ్లడం లాంటిది, పైన ఉన్న చిత్రంలో వివరించినట్లు. ఫలితంగా, నెట్‌వర్క్‌ను సురక్షితం చేయడానికి అయ్యే పర్యావరణ వ్యయం గణనీయంగా తగ్గుతుంది. అదే సమయంలో, నెట్‌వర్క్ భద్రత మెరుగుపడిందని నమ్ముతారు.
+
+## ఒక గ్రీన్ అప్లికేషన్ లేయర్ {#green-applications}
+
+ఇథిరియం యొక్క శక్తి వినియోగం చాలా తక్కువగా ఉన్నప్పటికీ, ఇథిరియంపై నిర్మించబడుతున్న ఒక గణనీయమైన, పెరుగుతున్న, మరియు అత్యంత చురుకైన [**రీజనరేటివ్ ఫైనాన్స్ (ReFi)**](/refi/) కమ్యూనిటీ కూడా ఉంది. ReFi అప్లికేషన్‌లు పర్యావరణానికి ప్రయోజనం చేకూర్చే సానుకూల బాహ్య ప్రభావాలను కలిగి ఉన్న ఆర్థిక అప్లికేషన్‌లను రూపొందించడానికి DeFi భాగాలను ఉపయోగిస్తాయి. ReFi అనేది ఇథిరియంతో దగ్గరి సంబంధం ఉన్న మరియు సాంకేతిక పురోగతి మరియు పర్యావరణ పరిరక్షణను జతచేయడమే లక్ష్యంగా పెట్టుకున్న విస్తృతమైన ["సోలార్‌పంక్"](https://en.wikipedia.org/wiki/Solarpunk) ఉద్యమంలో భాగం. ఇథిరియం యొక్క వికేంద్రీకృత, అనుమతిరహిత, మరియు కంపోజబుల్ స్వభావం దీనిని ReFi మరియు సోలార్‌పంక్ కమ్యూనిటీలకు ఆదర్శవంతమైన బేస్ లేయర్‌గా చేస్తుంది.
+
+[గిట్‌కాయిన్](https://gitcoin.co) వంటి వెబ్3 నేటివ్ పబ్లిక్ గూడ్స్ ఫండింగ్ ప్లాట్‌ఫారమ్‌లు ఇథిరియం యొక్క అప్లికేషన్ లేయర్‌పై పర్యావరణ స్పృహతో కూడిన నిర్మాణాన్ని ప్రేరేపించడానికి క్లైమేట్ రౌండ్‌లను నడుపుతాయి. ఈ కార్యక్రమాల అభివృద్ధి ద్వారా (మరియు ఇతరులు, ఉదాహరణకు, [DeSci](/desci/)), ఇథిరియం పర్యావరణ మరియు సామాజికంగా నికర-సానుకూల సాంకేతికతగా మారుతోంది.
+
+<Alert variant="update">
+<AlertEmoji text=":evergreen_tree:" />
+<AlertContent>
+<AlertDescription>
+  ఈ పేజీని మరింత ఖచ్చితమైనదిగా చేయవచ్చని మీరు భావిస్తే, దయచేసి ఒక సమస్యను లేదా PRను లేవనెత్తండి. ఈ పేజీలోని గణాంకాలు పబ్లిక్‌గా అందుబాటులో ఉన్న డేటా ఆధారంగా అంచనాలు - అవి ethereum.org బృందం లేదా ఇథిరియం ఫౌండేషన్ నుండి అధికారిక ప్రకటన లేదా వాగ్దానాన్ని సూచించవు.
+</AlertDescription>
+</AlertContent>
+</Alert>
+
+## మరింత సమాచారం {#further-reading}
+
+- [కేంబ్రిడ్జ్ బ్లాక్‌చెయిన్ నెట్‌వర్క్ సస్టైనబిలిటీ ఇండెక్స్](https://ccaf.io/cbnsi/ethereum)
+- [ప్రూఫ్-ఆఫ్-వర్క్ బ్లాక్‌చెయిన్‌లపై వైట్ హౌస్ నివేదిక](https://web.archive.org/web/20221109005700/https://www.whitehouse.gov/wp-content/uploads/2022/09/09-2022-Crypto-Assets-and-Climate-Report.pdf)
+- [ఇథిరియం ఉద్గారాలు: ఒక బాటమ్-అప్ అంచనా](https://kylemcdonald.github.io/ethereum-emissions/) - _Kyle McDonald_
+- [ఇథిరియం శక్తి వినియోగ సూచిక](https://digiconomist.net/ethereum-energy-consumption/) - _Digiconomist_
+- [ETHMerge.com](https://ethmerge.com/) - _[@InsideTheSim](https://twitter.com/InsideTheSim)_
+- [ది మెర్జ్ - ఇథిరియం నెట్‌వర్క్ యొక్క విద్యుత్ వినియోగం మరియు కార్బన్ పాదముద్రపై చిక్కులు](https://carbon-ratings.com/eth-report-2022) - _CCRI_
+- [ఇథిరియం శక్తి వినియోగం](https://mirror.xyz/jmcook.eth/ODpCLtO4Kq7SCVFbU4He8o8kXs418ZZDTj0lpYlZkR8)
+
+## సంబంధిత అంశాలు {#related-topics}
+
+- [ది బీకాన్ చైన్](/roadmap/beacon-chain)
+- [ది మెర్జ్](/roadmap/merge/)
diff --git a/public/content/translations/te/eth/supply/index.md b/public/content/translations/te/eth/supply/index.md
new file mode 100644
index 00000000000..36c31215510
--- /dev/null
+++ b/public/content/translations/te/eth/supply/index.md
@@ -0,0 +1,80 @@
+---
+title: "ETH సరఫరా మరియు జారీని అర్థం చేసుకోవడం"
+description: "EIPలు, PoS, మరియు EIP-1559 వంటి కీలక భావనలను కవర్ చేస్తూ, ETH సరఫరా మరియు జారీకి ప్రారంభకులకు అనుకూలమైన గైడ్."
+lang: te
+---
+
+# ETH సరఫరా మరియు జారీ {#eth-supply-and-issuance}
+
+## అవసరాలు {#prerequisites}
+
+ఈ ఆర్టికల్ ముందస్తు జ్ఞానం లేని ప్రారంభకుల కోసం వ్రాయబడింది. అయితే, ఈ అంశాన్ని పూర్తిగా అర్థం చేసుకోవడానికి, [ఇతీరియం ఇంప్రూవ్‌మెంట్ ప్రపోజల్స్ (EIPలు)](/eips/#introduction-to-ethereum-improvement-proposals), [ప్రూఫ్-ఆఫ్-వర్క్ (PoW)](/developers/docs/consensus-mechanisms/pow/), [ప్రూఫ్-ఆఫ్-స్టేక్ (PoS)](/developers/docs/consensus-mechanisms/pos/), మరియు [ది లండన్ అప్‌గ్రేడ్](/ethereum-forks/#london) వంటి భావనలపై ప్రాథమిక అవగాహన కలిగి ఉండటం సహాయకరంగా ఉంటుంది.
+
+## ఈ రోజు ఎన్ని ETH టోకెన్‌లు ఉన్నాయి? {#current-eth-supply}
+
+ETH యొక్క మొత్తం సరఫరా డైనమిక్‌గా ఉంటుంది మరియు రెండు ప్రధాన కారకాల కారణంగా నిరంతరం మారుతూ ఉంటుంది:
+
+1. **ప్రూఫ్-ఆఫ్-స్టేక్ (PoS) జారీ**: నెట్‌వర్క్‌ను సురక్షితం చేసే వాలిడేటర్‌లకు రివార్డులుగా కొత్త ETH సృష్టించబడుతుంది
+2. **EIP-1559 బర్నింగ్**: లావాదేవీ రుసుములలో ఒక భాగం సర్క్యులేషన్ నుండి శాశ్వతంగా తొలగించబడుతుంది
+
+మీరు [Ultrasound Money](https://ultrasound.money) వంటి ప్లాట్‌ఫారమ్‌లలో ప్రస్తుత సరఫరా మరియు ఈ మార్పులను నిజ సమయంలో ట్రాక్ చేయవచ్చు.
+
+నెట్‌వర్క్ యొక్క ఆరోగ్యం మరియు భవిష్యత్తును అర్థం చేసుకోవడానికి ఇతీరియం యొక్క సరఫరా మరియు జారీ చాలా ముఖ్యమైన కొలమానాలు. అయితే ETH జారీ అంటే ఏమిటి? దానిని విడమరిచి చూద్దాం.
+
+## ETH సరఫరా మరియు జారీ ఎందుకు ముఖ్యమైనవి {#why-eth-supply-matters}
+
+సాంప్రదాయ ఫైనాన్స్‌లో, కేంద్ర బ్యాంకులు డబ్బు సరఫరాను నియంత్రిస్తాయి, తరచుగా ఆర్థిక వ్యవస్థలను ఉత్తేజపరిచేందుకు ఎక్కువ డబ్బును ముద్రిస్తాయి. మరోవైపు, ఇతీరియం దాని కోడ్ ద్వారా నియంత్రించబడే ఒక పారదర్శకమైన మరియు ఊహించదగిన వ్యవస్థపై పనిచేస్తుంది. ఎన్ని ETH ఉన్నాయో మరియు కొత్త ETH ఎంత త్వరగా జారీ చేయబడుతుందో తెలుసుకోవడం వీటికి సహాయపడుతుంది:
+
+- **నమ్మకాన్ని పెంచుకోండి**: ఇతీరియం కమ్యూనిటీ సరఫరా మరియు జారీ డేటాను నేరుగా బ్లాక్ చైను నుండి ధృవీకరించగలదు.
+- **విలువను అర్థం చేసుకోండి**: జారీ మరియు ETH బర్న్ రేట్ల మధ్య సంబంధం ETH యొక్క ద్రవ్యోల్బణం లేదా ప్రతి ద్రవ్యోల్బణాన్ని ప్రభావితం చేస్తుంది, ఇది కాలక్రమేణా దాని విలువను ప్రభావితం చేస్తుంది.
+- **నెట్‌వర్క్ ఆరోగ్యాన్ని ట్రాక్ చేయండి**: జారీ మరియు బర్న్ రేట్లలో మార్పులు నెట్‌వర్క్ యొక్క కార్యాచరణ మరియు భద్రతను ప్రతిబింబిస్తాయి.
+
+## ETH జారీ అంటే ఏమిటి? {#eth-issuance}
+
+ఇతీరియం నెట్‌వర్క్‌ను సురక్షితం చేసే వాలిడేటర్‌లకు రివార్డులుగా కొత్త ETHను సృష్టించే ప్రక్రియను ETH జారీ అంటారు. ఇది మొత్తం సరఫరా నుండి వేరుగా ఉంటుంది, ఇది సర్క్యులేషన్‌లో ఉన్న ETH యొక్క మొత్తం పరిమాణం.
+
+### సరళంగా చెప్పాలంటే:
+
+- **జారీ** నెట్‌వర్క్‌కు కొత్త ETHను జోడిస్తుంది.
+- **బర్నింగ్** (EIP-1559 ద్వారా ప్రవేశపెట్టబడింది) లావాదేవీ రుసుములలో కొంత భాగాన్ని నాశనం చేయడం ద్వారా నెట్‌వర్క్ నుండి ETHను తొలగిస్తుంది.
+
+కాలక్రమేణా ఇతీరియం సరఫరా పెరుగుతుందా (ద్రవ్యోల్బణం) లేదా తగ్గుతుందా (ప్రతి ద్రవ్యోల్బణం) అని ఈ రెండు శక్తులు నిర్ధారిస్తాయి.
+
+## నేటి ETH సరఫరా మరియు జారీ {#eth-supply-today}
+
+ఇతీరియం యొక్క ప్రూఫ్-ఆఫ్-స్టేక్ (PoS) వ్యవస్థ దాని మునుపటి ప్రూఫ్-ఆఫ్-వర్క్ (PoW) మోడల్‌తో పోలిస్తే ETH జారీని గణనీయంగా తగ్గించింది. నెట్‌వర్క్‌ను సురక్షితం చేయడానికి ETHను లాక్ చేసే వాలిడేటర్‌లు రివార్డులుగా ETHను సంపాదిస్తారు. మీరు [Ultrasound Money](https://ultrasound.money)లో ప్రస్తుత జారీ రేటును చూడవచ్చు.
+
+అయితే, ఈ సంఖ్య డైనమిక్‌గా ఉంటుంది. EIP-1559కి ధన్యవాదాలు, నెట్‌వర్క్ కార్యాచరణ ఎక్కువగా ఉన్నప్పుడు, ETH బర్న్ రేట్లు జారీని అధిగమించగలవు, ఇది ప్రతి ద్రవ్యోల్బణ ప్రభావాన్ని సృష్టిస్తుంది. ఉదాహరణకు, NFT లాంచ్‌లు లేదా DeFi కార్యాచరణ వంటి అధిక డిమాండ్ ఉన్న కాలాల్లో, జారీ చేయబడిన దానికంటే ఎక్కువ ETH బర్న్ చేయబడవచ్చు.
+
+### ETH సరఫరా మరియు జారీని ట్రాక్ చేయడానికి ఉపకరణాలు:
+
+- [Ultrasound Money](https://ultrasound.money) - ETH సరఫరా, జారీ మరియు బర్న్ రేట్లను నిజ సమయంలో ట్రాక్ చేయడం
+- [Etherscan](https://etherscan.io) - సరఫరా మెట్రిక్స్‌తో కూడిన బ్లాక్ ఎక్స్‌ప్లోరర్
+
+## భవిష్యత్తు ETH సరఫరా మరియు జారీని ప్రభావితం చేసే కారకాలు {#future-eth-supply}
+
+ఇతీరియం భవిష్యత్తు సరఫరా స్థిరంగా లేదు—ఇది అనేక వేరియబుల్స్‌పై ఆధారపడి ఉంటుంది:
+
+1. **స్టేకింగ్ భాగస్వామ్యం**:
+   - నెట్‌వర్క్‌లో ఎక్కువ మంది వాలిడేటర్లు చేరడం అంటే ఎక్కువ ETH రివార్డులు పంపిణీ చేయబడతాయి.
+   - తక్కువ మంది వాలిడేటర్లు పాల్గొంటే జారీ తగ్గే అవకాశం ఉంది.
+   - [స్టేకింగ్](/staking/) గురించి మరింత తెలుసుకోండి.
+
+2. **నెట్‌వర్క్ కార్యాచరణ**:
+   - అధిక లావాదేవీల పరిమాణాలు ఎక్కువ ETH బర్న్ కావడానికి దారితీస్తాయి, ఇది జారీని ఆఫ్‌సెట్ చేయవచ్చు లేదా అధిగమించవచ్చు.
+   - [గ్యాస్ ఫీజులు](/developers/docs/gas/) గురించి మరియు అవి బర్నింగ్‌ను ఎలా ప్రభావితం చేస్తాయో చదవండి.
+
+3. **ప్రోటోకాల్ అప్‌గ్రేడ్‌లు**:
+   - ఇతీరియం కోడ్‌లో భవిష్యత్ మార్పులు స్టేకింగ్ రివార్డులు లేదా బర్నింగ్ మెకానిజమ్‌లను సర్దుబాటు చేయగలవు, సరఫరా డైనమిక్స్‌ను మరింతగా తీర్చిదిద్దుతాయి.
+   - [ఇతీరియం రోడ్‌మ్యాప్](/roadmap/) తో అప్‌డేట్‌గా ఉండండి.
+
+## రీక్యాప్: ETH సరఫరా, జారీ మరియు తదుపరి ఏమిటి {#recap}
+
+ETH సరఫరా మరియు జారీ గురించి మీరు తెలుసుకోవలసిన వాటి యొక్క శీఘ్ర సారాంశం ఇక్కడ ఉంది:
+
+- **ETH సరఫరా**: డైనమిక్ మరియు నిరంతరం మారుతూ ఉంటుంది, [Ultrasound Money](https://ultrasound.money) వంటి ఉపకరణాల ద్వారా నిజ సమయంలో ట్రాక్ చేయవచ్చు
+- **PoS కింద జారీ**: PoWతో పోలిస్తే గణనీయంగా తగ్గించబడింది, రివార్డులు వాలిడేటర్‌లకు వెళ్తాయి. [Ultrasound Money](https://ultrasound.money)లో ప్రస్తుత రేట్లను చూడండి
+- **EIP-1559 పాత్ర**: అధిక కార్యాచరణ కాలాల్లో ETH బర్నింగ్ నెట్‌వర్క్‌ను ప్రతి ద్రవ్యోల్బణంగా మార్చగలదు
+- **భవిష్యత్తు ట్రెండ్‌లు**: స్టేకింగ్ భాగస్వామ్యం, నెట్‌వర్క్ డిమాండ్ మరియు ప్రోటోకాల్ అప్‌డేట్‌లు అన్నీ ETH సరఫరాను తీర్చిదిద్దుతాయి
+
+ETH జారీని అర్థం చేసుకోవడం ఇతీరియం విలువను మరియు ప్రతి ద్రవ్యోల్బణ, వికేంద్రీకృత ఆస్తిగా దాని సామర్థ్యాన్ని స్పష్టం చేయడానికి సహాయపడుతుంది. ది మెర్జ్ ETH సరఫరాను ఎలా ప్రభావితం చేసిందనే దాని గురించి మరింత వివరణాత్మక సమాచారం కోసం, మా [వివరణాత్మక విశ్లేషణను](/roadmap/merge/issuance/) చూడండి. ETH భవిష్యత్తు గురించి ఆసక్తిగా ఉన్నారా? [Ultrasound Money](https://ultrasound.money) వంటి ఉపకరణాలతో మరింత లోతుగా తెలుసుకోండి లేదా మా [స్టేకింగ్ గైడ్‌లను](/staking/) అన్వేషించండి.
\ No newline at end of file
diff --git a/public/content/translations/te/ethereum-forks/index.md b/public/content/translations/te/ethereum-forks/index.md
new file mode 100644
index 00000000000..9f94f41bf2d
--- /dev/null
+++ b/public/content/translations/te/ethereum-forks/index.md
@@ -0,0 +1,663 @@
+---
+title: "అన్ని ఇతీరియము ఫోర్కుల కాలక్రమం (2014 నుండి ఇప్పటి వరకు)"
+description: "ప్రధాన మైలురాళ్ళు, విడుదలలు మరియు ఫోర్కులతో సహా ఇతీరియము బ్లాక్ చైను యొక్క చరిత్ర."
+lang: te
+sidebarDepth: 1
+---
+
+# అన్ని ఇతీరియము ఫోర్కుల కాలక్రమం (2014 నుండి ఇప్పటి వరకు) {#the-history-of-ethereum}
+
+ఇతీరియము బ్లాక్ చైను యొక్క అన్ని ప్రధాన మైలురాళ్ళు, ఫోర్కులు మరియు నవీకరణల కాలక్రమం.
+
+<ExpandableCard title="ఫోర్కులు అంటే ఏమిటి?" contentPreview="ఎథేరియం ప్రోటోకాల్ నియమాలలో మార్పులు, తరచుగా ప్రణాళికాబద్ధమైన సాంకేతిక నవీకరణలను కలిగి ఉంటాయి.">
+
+నెట్‌వర్క్‌కు ప్రధాన సాంకేతిక నవీకరణలు లేదా మార్పులు చేయవలసి వచ్చినప్పుడు ఫోర్కులు ఏర్పడతాయి – అవి సాధారణంగా [ఇతీరియము ఇంప్రూవ్‌మెంట్ ప్రపోజల్స్ (EIPలు)](/eips/) నుండి పుడతాయి మరియు ప్రోటోకాల్ యొక్క "నియమాలను" మారుస్తాయి.
+
+సాంప్రదాయ, కేంద్ర-నియంత్రిత సాఫ్ట్‌వేర్‌లో నవీకరణలు అవసరమైనప్పుడు, కంపెనీ తుది-వినియోగదారు కోసం కొత్త వెర్షన్‌ను ప్రచురిస్తుంది. బ్లాక్ చైనులు విభిన్నంగా పనిచేస్తాయి ఎందుకంటే కేంద్ర యాజమాన్యం లేదు. [Ethereum క్లయింట్లు](/developers/docs/nodes-and-clients/) కొత్త ఫోర్క్ నియమాలను అమలు చేయడానికి వారి సాఫ్ట్‌వేర్‌ను నవీకరించాలి. ఇంకా, బ్లాక్ సృష్టికర్తలు (ప్రూఫ్-ఆఫ్-వర్క్ ప్రపంచంలో మైనర్లు, ప్రూఫ్-ఆఫ్-స్టేక్ ప్రపంచంలో వాలిడేటర్లు) మరియు నోడ్స్ బ్లాక్‌లను సృష్టించాలి మరియు కొత్త నియమాలకు వ్యతిరేకంగా ధృవీకరించాలి. [ఏకాభిప్రాయ యంత్రాంగాలపై మరింత సమాచారం](/developers/docs/consensus-mechanisms/)
+
+ఈ నియమ మార్పులు నెట్‌వర్క్‌లో తాత్కాలిక విభజనను సృష్టించవచ్చు. కొత్త నియమాల ప్రకారం లేదా పాత వాటి ప్రకారం కొత్త బ్లాక్‌లను ఉత్పత్తి చేయవచ్చు. ఫోర్కుల గురించి సాధారణంగా ముందుగానే అంగీకరిస్తారు, తద్వారా ఖాతాదారులు మార్పులను ఏకగ్రీవంగా స్వీకరిస్తారు మరియు నవీకరణలతో కూడిన ఫోర్క్ ప్రధాన చైన్‌గా మారుతుంది. అయితే, అరుదైన సందర్భాల్లో, ఫోర్కులపై విభేదాలు నెట్‌వర్క్‌ను శాశ్వతంగా విభజించగలవు – ముఖ్యంగా <a href="#dao-fork">DAO ఫోర్క్</a>తో ఇతీరియము క్లాసిక్ సృష్టి.
+</ExpandableCard>
+
+<ExpandableCard title="కొన్ని నవీకరణలకు అనేక పేర్లు ఎందుకు ఉంటాయి?" contentPreview="నవీకరణల పేర్లు ఒక నమూనాని అనుసరిస్తాయి">
+
+ఇతీరియముకు ఆధారమైన సాఫ్ట్‌వేర్ రెండు భాగాలుగా ఉంటుంది, వాటిని [ఎగ్జిక్యూషన్ లేయర్](/glossary/#execution-layer) మరియు [ఏకాభిప్రాయం లేయర్](/glossary/#consensus-layer) అని పిలుస్తారు.
+
+**ఎగ్జిక్యూషన్ నవీకరణ నామకరణం**
+
+2021 నుండి, **ఎగ్జిక్యూషన్ లేయర్** కు నవీకరణలు [మునుపటి డెవలపర్ల సమావేశం స్థానాల](https://devcon.org/en/past-events/) నగరాల పేర్ల ప్రకారం కాలక్రమానుసారంగా పెట్టబడ్డాయి:
+
+| నవీకరణ పేరు | డెవలపర్ల సమావేశం సంవత్సరం | డెవలపర్ల సమావేశం సంఖ్య | నవీకరణ తేదీ               |
+| ----------- | ------------------------- | ---------------------- | ------------------------- |
+| బెర్లిన్    | 2014                      | 0                      | ఏప్రిల్ 15, 2021          |
+| లండన్       | 2015                      | I                      | ఆగస్టు 5, 2021            |
+| షాంఘై       | 2016                      | II                     | ఏప్రిల్ 12, 2023          |
+| కాన్కున్    | 2017                      | III                    | మార్చి 13, 2024           |
+| **ప్రేగ్**  | 2018                      | IV                     | నిర్ధారించబడలేదు - తదుపరి |
+| _ఒసాకా_     | 2019                      | V                      | నిర్ధారించబడలేదు          |
+| _బొగోటా_    | 2022                      | VI                     | నిర్ధారించబడలేదు          |
+| _బ్యాంకాక్_ | 2024                      | VII                    | నిర్ధారించబడలేదు          |
+
+**ఏకాభిప్రాయం నవీకరణ నామకరణం**
+
+[బీకన్ చైన్](/glossary/#beacon-chain) ప్రారంభించినప్పటి నుండి, **ఏకాభిప్రాయం లేయర్** కు నవీకరణలు అక్షర క్రమంలో కొనసాగే అక్షరాలతో ప్రారంభమయ్యే ఖగోళ నక్షత్రాల పేర్లతో పెట్టబడ్డాయి:
+
+| నవీకరణ పేరు                                                   | నవీకరణ తేదీ               |
+| ------------------------------------------------------------- | ------------------------- |
+| బీకన్ చైన్ జెనెసిస్                                           | డిసెంబర్ 1, 2020          |
+| [Altair](https://en.wikipedia.org/wiki/Altair)                | అక్టోబర్ 27, 2021         |
+| [Bellatrix](https://en.wikipedia.org/wiki/Bellatrix)          | సెప్టెంబర్ 6, 2022        |
+| [Capella](https://en.wikipedia.org/wiki/Capella)              | ఏప్రిల్ 12, 2023          |
+| [Deneb](https://en.wikipedia.org/wiki/Deneb)                  | మార్చి 13, 2024           |
+| [**Electra**](https://en.wikipedia.org/wiki/Electra_\(star\)) | నిర్ధారించబడలేదు - తదుపరి |
+| [_Fulu_](https://en.wikipedia.org/wiki/Fulu_\(star\))         | నిర్ధారించబడలేదు          |
+
+**సంయుక్త నామకరణం**
+
+ఎగ్జిక్యూషన్ మరియు ఏకాభిప్రాయం నవీకరణలు ప్రారంభంలో వేర్వేరు సమయాల్లో విడుదల చేయబడ్డాయి, కానీ 2022లో [ది మెర్జ్](/roadmap/merge/) తర్వాత ఇవి ఏకకాలంలో అమలు చేయబడ్డాయి. అందువల్ల, ఈ నవీకరణలకు సూచనలను సరళీకృతం చేయడానికి ఒకే సంయుక్త పదాన్ని ఉపయోగించి వ్యావహారిక పదాలు ఉద్భవించాయి. ఇది _షాంఘై-కాపెల్లా_ నవీకరణతో ప్రారంభమైంది, దీనిని సాధారణంగా "**షాపేల్లా**" అని పిలుస్తారు, మరియు _కాన్కున్-డెనెబ్_ (**డెన్కున్**), మరియు _ప్రేగ్-ఎలెక్ట్రా_ (**పెక్ట్రా**) నవీకరణలతో కొనసాగుతుంది.
+
+| ఎగ్జిక్యూషన్ నవీకరణ | ఏకాభిప్రాయం నవీకరణ | చిన్న పేరు |
+| ------------------- | ------------------ | ---------- |
+| షాంఘై               | కాపెల్లా           | "షాపేల్లా" |
+| కాన్కున్            | డెనెబ్             | "డెన్కున్" |
+| ప్రేగ్              | ఎలెక్ట్రా          | "పెక్ట్రా" |
+| ఒసాకా               | ఫులు               | "ఫుసాకా"   |
+</ExpandableCard>
+
+కొన్ని ప్రత్యేకంగా ముఖ్యమైన గత నవీకరణల గురించిన సమాచారానికి నేరుగా వెళ్లండి: [ది బీకన్ చైన్](/roadmap/beacon-chain/); [ది మెర్జ్](/roadmap/merge/); మరియు [EIP-1559](#london)
+
+భవిష్యత్ ప్రోటోకాల్ నవీకరణల కోసం చూస్తున్నారా? [ఇతీరియము రోడ్‌మ్యాప్‌లో రాబోయే నవీకరణల గురించి తెలుసుకోండి](/roadmap/).
+
+<Divider />
+
+## 2025 {#2025}
+
+### ఫులు-ఒసాకా ("ఫుసాకా") {#fusaka}
+
+<NetworkUpgradeSummary name="fusaka" />
+
+[ఫుసాకా గురించి మరింత](/roadmap/fusaka/)
+
+### ప్రేగ్-ఎలెక్ట్రా ("పెక్ట్రా") {#pectra}
+
+<NetworkUpgradeSummary name="pectra" />
+
+ప్రేగ్-ఎలెక్ట్రా ("పెక్ట్రా") నవీకరణలో ఇతీరియము ప్రోటోకాల్‌కు అనేక మెరుగుదలలు చేర్చబడ్డాయి, ఇవి అందరు వినియోగదారులు, లేయర్ 2 నెట్‌వర్క్‌లు, స్టేకర్లు మరియు నోడ్ ఆపరేటర్లకు అనుభవాన్ని మెరుగుపరచడం లక్ష్యంగా చేసుకున్నాయి.
+
+కాంపౌండింగ్ వాలిడేటర్ ఖాతాలతో స్టేకింగ్‌కు నవీకరణ వచ్చింది, మరియు ఎగ్జిక్యూషన్ ఉపసంహరణ చిరునామాను ఉపయోగించి స్టేక్ చేసిన నిధులపై మెరుగైన నియంత్రణ లభించింది. EIP-7251 ఒకే వాలిడేటర్ కోసం గరిష్ట ప్రభావవంతమైన బ్యాలెన్స్‌ను 2048కి పెంచింది, ఇది స్టేకర్ల కోసం మూలధన సామర్థ్యాన్ని మెరుగుపరుస్తుంది. EIP-7002 ఒక ఎగ్జిక్యూషన్ ఖాతాను వాలిడేటర్ చర్యలను సురక్షితంగా ప్రేరేపించడానికి వీలు కల్పించింది, ఇందులో నిష్క్రమించడం లేదా నిధుల భాగాలను ఉపసంహరించుకోవడం వంటివి ఉన్నాయి, ఇది ETH స్టేకర్ల అనుభవాన్ని మెరుగుపరుస్తుంది, అదే సమయంలో నోడ్ ఆపరేటర్ల కోసం జవాబుదారీతనాన్ని బలోపేతం చేయడంలో సహాయపడుతుంది.
+
+నవీకరణ యొక్క ఇతర భాగాలు సాధారణ వినియోగదారుల కోసం అనుభవాన్ని మెరుగుపరచడంపై దృష్టి పెట్టాయి. EIP-7702 ఒక సాధారణ నాన్-స్మార్ట్-కాంట్రాక్ట్ ఖాతా ([EOA](/glossary/#eoa)) కోసం స్మార్ట్ కాంట్రాక్ట్‌కు సమానమైన సంకేత భాషను అమలు చేసే సామర్థ్యాన్ని తెచ్చింది. ఇది లావాదేవీల బ్యాచింగ్, గ్యాస్ స్పాన్సర్‌షిప్, ప్రత్యామ్నాయ ప్రామాణీకరణ, ప్రోగ్రామబుల్ వ్యయ నియంత్రణలు, ఖాతా పునరుద్ధరణ యంత్రాంగాలు మరియు మరిన్ని వంటి సాంప్రదాయ ఇతీరియము ఖాతాల కోసం అపరిమితమైన కొత్త కార్యాచరణను అన్‌లాక్ చేసింది.
+
+<ExpandableCard title="Pectra EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+మెరుగైన వినియోగదారు అనుభవం:
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7702">EIP-7702</a> - <em>EOA ఖాతా సంకేత భాషను సెట్ చేయండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7691">EIP-7691</a> - <em>బ్లాబ్ త్రూపుట్ పెరుగుదల</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7623">EIP-7623</a> - <em>కాల్‌డేటా వ్యయాన్ని పెంచండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7840">EIP-7840</a> - <em>EL కాన్ఫిగ్ ఫైల్‌లకు బ్లాబ్ షెడ్యూల్‌ను జోడించండి</em></li>
+</ul>
+
+మెరుగైన స్టేకింగ్ అనుభవం:
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7251">EIP-7251</a> - <em><code>MAX_EFFECTIVE_BALANCE</code>ని పెంచండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7002">EIP-7002</a> - <em>ఎగ్జిక్యూషన్ లేయర్ ప్రేరేపించగల నిష్క్రమణలు</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7685">EIP-7685</a> - <em>సాధారణ ప్రయోజన ఎగ్జిక్యూషన్ లేయర్ అభ్యర్థనలు</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-6110">EIP-6110</a> - <em>చైన్‌లో వాలిడేటర్ డిపాజిట్లను సరఫరా చేయండి</em></li>
+</ul>
+
+ప్రోటోకాల్ సామర్థ్యం మరియు భద్రతా మెరుగుదలలు:
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2537">EIP-2537</a> - <em>BLS12-381 కర్వ్ ఆపరేషన్ల కోసం ప్రీకంపైల్ చేయండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2935">EIP-2935</a> - <em>స్థితిలో చారిత్రక బ్లాక్ హాష్‌లను సేవ్ చేయండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7549">EIP-7549</a> - <em>ధృవీకరణ బయట కమిటీ సూచికను తరలించండి</em></li>
+</ul>
+</ExpandableCard>
+
+- [Pectra.wtf](https://pectra.wtf)
+- [పెక్ట్రా స్టేకింగ్ అనుభవాన్ని ఎలా మెరుగుపరుస్తుందో](https://www.kiln.fi/post/next-ethereum-upgrade-how-pectra-will-enhance-the-staking-experience)
+- [ఎలెక్ట్రా నవీకరణ స్పెసిఫికేషన్‌లను చదవండి](https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/)
+- [ప్రేగ్-ఎలెక్ట్రా ("పెక్ట్రా") FAQ](/roadmap/pectra/)
+
+<Divider />
+
+## 2024 {#2024}
+
+### కాన్కున్-డెనెబ్ ("డెన్కున్") {#dencun}
+
+<NetworkUpgradeSummary name="dencun" />
+
+#### కాన్కున్ సారాంశం {#cancun-summary}
+
+కాన్కున్ నవీకరణలో ఇతీరియము యొక్క _ఎగ్జిక్యూషన్_ కు సంబంధించిన అనేక మెరుగుదలలు ఉన్నాయి, ఇవి డెనెబ్ ఏకాభిప్రాయం నవీకరణలతో పాటు స్కేలబిలిటీని మెరుగుపరచడం లక్ష్యంగా చేసుకున్నాయి.
+
+ముఖ్యంగా ఇది EIP-4844ని కలిగి ఉంటుంది, దీనిని **ప్రోటో-డాంక్షార్డింగ్** అని పిలుస్తారు, ఇది లేయర్ 2 రోల్అప్‌ల కోసం డేటా నిల్వ ఖర్చును గణనీయంగా తగ్గిస్తుంది. డేటా "బ్లాబ్స్" ప్రవేశపెట్టడం ద్వారా ఇది సాధించబడుతుంది, ఇది రోల్అప్‌లను తక్కువ కాలానికి మెయిన్‌నెట్‌కు డేటాను పోస్ట్ చేయడానికి అనుమతిస్తుంది. ఇది లేయర్ 2 రోల్అప్‌ల వినియోగదారులకు గణనీయంగా తక్కువ లావాదేవీల రుసుములకు దారితీస్తుంది.
+
+<ExpandableCard title="Cancun EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1153">EIP-1153</a> - <em>తాత్కాలిక నిల్వ ఆప్కోడ్లు</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4788">EIP-4788</a> - <em>EVMలో బీకన్ బ్లాక్ రూట్</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4844">EIP-4844</a> - <em>షార్డ్ బ్లాబ్ లావాదేవీలు (ప్రోటో-డాంక్షార్డింగ్)</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-5656">EIP-5656</a> - <em><code>MCOPY</code> - మెమరీ కాపీయింగ్ సూచన</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-6780">EIP-6780</a> - <em>అదే లావాదేవీలో మాత్రమే <code>SELFDESTRUCT</code></em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7516">EIP-7516</a> - <em><code>BLOBBASEFEE</code> ఆప్కోడ్</em></li>
+</ul>
+</ExpandableCard>
+
+- [లేయర్ 2 రోల్అప్‌లు](/layer-2/)
+- [ప్రోటో-డాంక్షార్డింగ్](/roadmap/scaling/#proto-danksharding)
+- [డాంక్షార్డింగ్](/roadmap/danksharding/)
+- [కాన్కున్ నవీకరణ స్పెసిఫికేషన్‌ను చదవండి](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/cancun.md)
+
+#### డెనెబ్ సారాంశం {#deneb-summary}
+
+డెనెబ్ నవీకరణలో ఇతీరియము యొక్క _ఏకాభిప్రాయం_ కు సంబంధించిన అనేక మెరుగుదలలు ఉన్నాయి, ఇవి స్కేలబిలిటీని మెరుగుపరచడం లక్ష్యంగా చేసుకున్నాయి. ఈ నవీకరణ ప్రోటో-డాంక్షార్డింగ్ (EIP-4844) ను ప్రారంభించడానికి కాన్కున్ ఎగ్జిక్యూషన్ నవీకరణలతో పాటు వస్తుంది, బీకన్ చైన్‌కు ఇతర మెరుగుదలలతో పాటు.
+
+ముందుగా రూపొందించిన సంతకం చేయబడిన "స్వచ్ఛంద నిష్క్రమణ సందేశాలు" ఇకపై గడువు ముగియవు, తద్వారా మూడవ-పక్ష నోడ్ ఆపరేటర్‌తో వారి నిధులను స్టేక్ చేసే వినియోగదారులకు మరింత నియంత్రణ లభిస్తుంది. ఈ సంతకం చేయబడిన నిష్క్రమణ సందేశంతో, స్టేకర్లు నోడ్ ఆపరేషన్‌ను అప్పగించవచ్చు, అదే సమయంలో ఎవరి నుండి అనుమతి అడగకుండా ఎప్పుడైనా సురక్షితంగా నిష్క్రమించి వారి నిధులను ఉపసంహరించుకునే సామర్థ్యాన్ని కలిగి ఉంటారు.
+
+EIP-7514, నెట్‌వర్క్‌లోకి వాలిడేటర్లు చేరే "చర్న్" రేటును ప్రతి ఎపోచ్‌కు ఎనిమిది (8) కి పరిమితం చేయడం ద్వారా ETH జారీని కఠినతరం చేస్తుంది. ETH జారీ అనేది మొత్తం స్టేక్ చేసిన ETHకు అనుపాతంలో ఉన్నందున, చేరే వాలిడేటర్ల సంఖ్యను పరిమితం చేయడం కొత్తగా జారీ చేయబడిన ETH యొక్క _వృద్ధి రేటు_ను పరిమితం చేస్తుంది, అదే సమయంలో నోడ్ ఆపరేటర్ల కోసం హార్డ్‌వేర్ అవసరాలను తగ్గిస్తుంది, వికేంద్రీకరణకు సహాయపడుతుంది.
+
+<ExpandableCard title="Deneb EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4788">EIP-4788</a> - <em>EVMలో బీకన్ బ్లాక్ రూట్</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4844">EIP-4844</a> - <em>షార్డ్ బ్లాబ్ లావాదేవీలు</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7044">EIP-7044</a> - <em>శాశ్వతంగా చెల్లుబాటు అయ్యే సంతకం చేయబడిన స్వచ్ఛంద నిష్క్రమణలు</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7045">EIP-7045</a> - <em>గరిష్ట ధృవీకరణ చేర్చబడిన జాబితాను పెంచండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7514">EIP-7514</a> - <em>గరిష్ట ఎపోచ్ చర్న్ పరిమితిని జోడించండి</em></li>
+</ul>
+</ExpandableCard>
+
+- [డెనెబ్ నవీకరణ స్పెసిఫికేషన్‌లను చదవండి](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/)
+- [కాన్కున్-డెనెబ్ ("డెన్కున్") FAQ](/roadmap/dencun/)
+
+<Divider />
+
+## 2023 {#2023}
+
+### షాంఘై-కాపెల్లా ("షాపేల్లా") {#shapella}
+
+<NetworkUpgradeSummary name="shapella" />
+
+#### షాంఘై సారాంశం {#shanghai-summary}
+
+షాంఘై నవీకరణ ఎగ్జిక్యూషన్ లేయర్‌కు స్టేకింగ్ ఉపసంహరణలను తీసుకువచ్చింది. కాపెల్లా నవీకరణతో పాటు, ఇది బ్లాక్‌లు ఉపసంహరణ కార్యకలాపాలను అంగీకరించడానికి వీలు కల్పించింది, ఇది స్టేకర్లు వారి ETHను బీకన్ చైన్ నుండి ఎగ్జిక్యూషన్ లేయర్‌కు ఉపసంహరించుకోవడానికి అనుమతిస్తుంది.
+
+<ExpandableCard title="షాంఘై EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3651">EIP-3651</a> – <em><code>COINBASE</code> చిరునామాను వెచ్చగా ప్రారంభిస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3855">EIP-3855</a> – <em>కొత్త <code>PUSH0</code> సూచన</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3860">EIP-3860</a> – <em>ఇనిట్‌కోడ్‌ను పరిమితం చేయండి మరియు మీటర్ చేయండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4895">EIP-4895</a> – <em>బీకన్ చైన్ పుష్ ఉపసంహరణలు కార్యకలాపాలుగా</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-6049">EIP-6049</a> - <em><code>SELFDESTRUCT</code>ను నిలిపివేయండి</em></li>
+</ul>
+</ExpandableCard>
+
+- [షాంఘై నవీకరణ స్పెసిఫికేషన్‌ను చదవండి](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/shanghai.md)
+
+#### కాపెల్లా సారాంశం {#capella-summary}
+
+కాపెల్లా నవీకరణ ఏకాభిప్రాయం లేయర్ (బీకన్ చైన్)కు మూడవ ప్రధాన నవీకరణ మరియు స్టేకింగ్ ఉపసంహరణలను ప్రారంభించింది. కాపెల్లా ఎగ్జిక్యూషన్ లేయర్ నవీకరణ, షాంఘైతో ఏకకాలంలో జరిగింది మరియు స్టేకింగ్ ఉపసంహరణ కార్యాచరణను ప్రారంభించింది.
+
+ఈ ఏకాభిప్రాయం లేయర్ నవీకరణ, వారి ప్రారంభ డిపాజిట్‌తో ఉపసంహరణ ఆధారాలను అందించని స్టేకర్లకు అలా చేయడానికి, తద్వారా ఉపసంహరణలను ప్రారంభించడానికి సామర్థ్యాన్ని తీసుకువచ్చింది.
+
+ఈ నవీకరణ ఆటోమేటిక్ ఖాతా స్వీపింగ్ కార్యాచరణను కూడా అందించింది, ఇది ఏదైనా అందుబాటులో ఉన్న రివార్డు చెల్లింపులు లేదా పూర్తి ఉపసంహరణల కోసం వాలిడేటర్ ఖాతాలను నిరంతరం ప్రాసెస్ చేస్తుంది.
+
+- [స్టేకింగ్ ఉపసంహరణల గురించి మరింత](/staking/withdrawals/).
+- [కాపెల్లా నవీకరణ స్పెసిఫికేషన్‌లను చదవండి](https://github.com/ethereum/consensus-specs/blob/dev/specs/capella/)
+
+<Divider />
+
+## 2022 {#2022}
+
+### పారిస్ (ది మెర్జ్) {#paris}
+
+<NetworkUpgradeSummary name="paris" />
+
+#### సారాంశం {#paris-summary}
+
+పారిస్ నవీకరణ ప్రూఫ్-ఆఫ్-వర్క్ బ్లాక్ చైను 58750000000000000000000 [టర్మినల్ టోటల్ డిఫికల్టీ](/glossary/#terminal-total-difficulty) దాటినప్పుడు ప్రేరేపించబడింది. ఇది సెప్టెంబర్ 15, 2022న బ్లాక్ 15537393 వద్ద జరిగింది, తదుపరి బ్లాక్‌లో పారిస్ నవీకరణను ప్రేరేపించింది. పారిస్ [ది మెర్జ్](/roadmap/merge/) పరివర్తన - దీని ప్రధాన లక్షణం [ప్రూఫ్-ఆఫ్-వర్క్](/developers/docs/consensus-mechanisms/pow) మైనింగ్ అల్గోరిథం మరియు సంబంధిత ఏకాభిప్రాయం తర్కాన్ని ఆపివేయడం మరియు బదులుగా [ప్రూఫ్-ఆఫ్-స్టేక్](/developers/docs/consensus-mechanisms/pos)ను ఆన్ చేయడం. పారిస్ స్వయంగా [ఎగ్జిక్యూషన్ ఖాతాదారులకు](/developers/docs/nodes-and-clients/#execution-clients) ఒక నవీకరణ (ఏకాభిప్రాయం లేయర్‌పై బెలాట్రిక్స్‌కు సమానం), ఇది వారి కనెక్ట్ చేయబడిన [ఏకాభిప్రాయం ఖాతాదారుల](/developers/docs/nodes-and-clients/#consensus-clients) నుండి సూచనలను తీసుకోవడానికి వీలు కల్పించింది. దీనికి [ఇంజిన్ ఎపిఐ](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md) అని పిలువబడే కొత్త అంతర్గత ఎపిఐ పద్ధతుల సెట్‌ను సక్రియం చేయడం అవసరం. [హోమ్‌స్టెడ్](#homestead) నుండి ఇది ఇతీరియము చరిత్రలో అత్యంత ముఖ్యమైన నవీకరణ అనడంలో సందేహం లేదు!
+
+- [పారిస్ నవీకరణ స్పెసిఫికేషన్‌ను చదవండి](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/mainnet-upgrades/paris.md)
+
+<ExpandableCard title="పారిస్ EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3675">EIP-3675</a> – <em>ఏకాభిప్రాయాన్ని ప్రూఫ్-ఆఫ్-స్టేక్‌కు నవీకరించండి</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4399">EIP-4399</a> – <em>DIFFICULTY ఆప్కోడ్‌ను PREVRANDAOతో భర్తీ చేయండి</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### బెలాట్రిక్స్ {#bellatrix}
+
+<NetworkUpgradeSummary name="bellatrix" />
+
+#### సారాంశం {#bellatrix-summary}
+
+బెలాట్రిక్స్ నవీకరణ [బీకన్ చైన్](/roadmap/beacon-chain) కోసం రెండవ షెడ్యూల్డ్ నవీకరణ, ఇది చైన్‌ను [ది మెర్జ్](/roadmap/merge/) కోసం సిద్ధం చేస్తుంది. ఇది నిష్క్రియాత్మకత మరియు స్లాషబుల్ నేరాల కోసం వాలిడేటర్ జరిమానాలను వాటి పూర్తి విలువలకు తీసుకువస్తుంది. బెలాట్రిక్స్, ది మెర్జ్ మరియు చివరి ప్రూఫ్-ఆఫ్-వర్క్ బ్లాక్ నుండి మొదటి ప్రూఫ్-ఆఫ్-స్టేక్ బ్లాక్‌కు పరివర్తన కోసం చైన్‌ను సిద్ధం చేయడానికి ఫోర్క్ ఎంపిక నియమాలకు ఒక నవీకరణను కూడా కలిగి ఉంటుంది. ఇందులో ఏకాభిప్రాయం ఖాతాదారులకు 58750000000000000000000 [టర్మినల్ టోటల్ డిఫికల్టీ](/glossary/#terminal-total-difficulty) గురించి తెలియజేయడం ఉంటుంది.
+
+- [బెలాట్రిక్స్ నవీకరణ స్పెసిఫికేషన్‌ను చదవండి](https://github.com/ethereum/consensus-specs/tree/dev/specs/bellatrix)
+
+---
+
+### గ్రే గ్లేసియర్ {#gray-glacier}
+
+<NetworkUpgradeSummary name="grayGlacier" />
+
+#### సారాంశం {#gray-glacier-summary}
+
+గ్రే గ్లేసియర్ నెట్‌వర్క్ నవీకరణ [డిఫికల్టీ బాంబ్](/glossary/#difficulty-bomb)ను మూడు నెలల పాటు వెనక్కి నెట్టింది. ఈ నవీకరణలో ప్రవేశపెట్టబడిన ఏకైక మార్పు ఇదే, మరియు ఇది [యారో గ్లేసియర్](#arrow-glacier) మరియు [మ్యూయిర్ గ్లేసియర్](#muir-glacier) నవీకరణల స్వభావానికి సమానంగా ఉంటుంది. [బైజాంటియమ్](#byzantium), [కాన్స్టాంటినోపుల్](#constantinople) మరియు [లండన్](#london) నెట్‌వర్క్ నవీకరణలపై ఇలాంటి మార్పులు చేయబడ్డాయి.
+
+- [EF బ్లాగ్ - గ్రే గ్లేసియర్ నవీకరణ ప్రకటన](https://blog.ethereum.org/2022/06/16/gray-glacier-announcement/)
+
+<ExpandableCard title="గ్రే గ్లేసియర్ EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-5133">EIP-5133</a> – <em>డిఫికల్టీ బాంబును సెప్టెంబర్ 2022 వరకు ఆలస్యం చేస్తుంది</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2021 {#2021}
+
+### యారో గ్లేసియర్ {#arrow-glacier}
+
+<NetworkUpgradeSummary name="arrowGlacier" />
+
+#### సారాంశం {#arrow-glacier-summary}
+
+యారో గ్లేసియర్ నెట్‌వర్క్ నవీకరణ [డిఫికల్టీ బాంబ్](/glossary/#difficulty-bomb)ను చాలా నెలల పాటు వెనక్కి నెట్టింది. ఈ నవీకరణలో ప్రవేశపెట్టబడిన ఏకైక మార్పు ఇదే, మరియు ఇది [మ్యూయిర్ గ్లేసియర్](#muir-glacier) నవీకరణ స్వభావానికి సమానంగా ఉంటుంది. [బైజాంటియమ్](#byzantium), [కాన్స్టాంటినోపుల్](#constantinople) మరియు [లండన్](#london) నెట్‌వర్క్ నవీకరణలపై ఇలాంటి మార్పులు చేయబడ్డాయి.
+
+- [EF బ్లాగ్ - యారో గ్లేసియర్ నవీకరణ ప్రకటన](https://blog.ethereum.org/2021/11/10/arrow-glacier-announcement/)
+- [ఇతీరియము క్యాట్ హెర్డర్స్ - ఇతీరియము యారో గ్లేసియర్ నవీకరణ](https://medium.com/ethereum-cat-herders/ethereum-arrow-glacier-upgrade-e8d20fa4c002)
+
+<ExpandableCard title="యారో గ్లేసియర్ EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-4345">EIP-4345</a> – <em>డిఫికల్టీ బాంబును జూన్ 2022 వరకు ఆలస్యం చేస్తుంది</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### అల్టెయిర్ {#altair}
+
+<NetworkUpgradeSummary name="altair" />
+
+#### సారాంశం {#altair-summary}
+
+అల్టెయిర్ నవీకరణ [బీకన్ చైన్](/roadmap/beacon-chain) కోసం మొదటి షెడ్యూల్డ్ నవీకరణ. ఇది "సింక్ కమిటీలకు" మద్దతును జోడించింది— తేలికైన ఖాతాదారులను ప్రారంభించడం, మరియు ది మెర్జ్ వైపు అభివృద్ధి జరుగుతున్నప్పుడు వాలిడేటర్ నిష్క్రియాత్మకత మరియు స్లాషింగ్ జరిమానాలను పెంచింది.
+
+- [అల్టెయిర్ నవీకరణ స్పెసిఫికేషన్‌ను చదవండి](https://github.com/ethereum/consensus-specs/tree/dev/specs/altair)
+
+#### <Emoji text=":tada:" size={1} className="me-2" />సరదా వాస్తవం! {#altair-fun-fact}
+
+అల్టెయిర్ కచ్చితమైన విడుదల సమయాన్ని కలిగి ఉన్న మొదటి ప్రధాన నెట్‌వర్క్ నవీకరణ. మునుపటి ప్రతి నవీకరణ ప్రూఫ్-ఆఫ్-వర్క్ చైన్‌పై ప్రకటించిన బ్లాక్ నంబర్‌పై ఆధారపడి ఉండేది, ఇక్కడ బ్లాక్ సమయాలు మారుతూ ఉంటాయి. బీకన్ చైన్‌కు ప్రూఫ్-ఆఫ్-వర్క్‌ను పరిష్కరించాల్సిన అవసరం లేదు, మరియు బదులుగా సమయ-ఆధారిత ఎపోచ్ సిస్టమ్‌పై పనిచేస్తుంది, ఇందులో 32 పన్నెండు-సెకన్ల "జాబితాలు" ఉంటాయి, ఇక్కడ వాలిడేటర్లు బ్లాక్‌లను ప్రతిపాదించగలరు. అందుకే మనం ఎపోచ్ 74,240కి ఎప్పుడు చేరుకుంటామో మరియు అల్టెయిర్ ప్రత్యక్ష ప్రసారం అవుతుందో మాకు ఖచ్చితంగా తెలుసు!
+
+- [బ్లాక్ సమయం](/developers/docs/blocks/#block-time)
+
+---
+
+### లండన్ {#london}
+
+<NetworkUpgradeSummary name="london" />
+
+#### సారాంశం {#london-summary}
+
+లండన్ నవీకరణ [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)ను ప్రవేశపెట్టింది, ఇది లావాదేవీ రుసుము మార్కెట్‌ను సంస్కరించింది, గ్యాస్ వాపసుల నిర్వహణ మరియు [ఐస్ ఏజ్](/glossary/#ice-age) షెడ్యూల్‌కు మార్పులతో పాటు.
+
+#### లండన్ నవీకరణ / EIP-1559 అంటే ఏమిటి? {#eip-1559}
+
+లండన్ నవీకరణకు ముందు, ఇతీరియముకు స్థిర-పరిమాణ బ్లాక్‌లు ఉండేవి. అధిక నెట్‌వర్క్ డిమాండ్ సమయాల్లో, ఈ బ్లాక్‌లు పూర్తి సామర్థ్యంతో పనిచేసేవి. ఫలితంగా, వినియోగదారులు తరచుగా బ్లాక్‌లో చేర్చబడటానికి డిమాండ్ తగ్గడానికి వేచి ఉండాల్సి వచ్చింది, ఇది పేలవమైన వినియోగదారు అనుభవానికి దారితీసింది. లండన్ నవీకరణ ఇతీరియముకు వేరియబుల్-పరిమాణ బ్లాక్‌లను ప్రవేశపెట్టింది.
+
+ఆగస్టు 2021 నాటి [లండన్ నవీకరణ](/ethereum-forks/#london)తో ఇతీరియము నెట్‌వర్క్‌పై లావాదేవీ రుసుములు లెక్కించే విధానం మారింది. లండన్ నవీకరణకు ముందు, `మూల` మరియు `ప్రాధాన్యత` రుసుములను వేరు చేయకుండా రుసుములు ఈ క్రింది విధంగా లెక్కించబడ్డాయి:
+
+ఆలిస్ బాబ్‌కు 1 ETH చెల్లించాల్సి ఉందని అనుకుందాం. లావాదేవీలో, గ్యాస్ పరిమితి 21,000 యూనిట్లు, మరియు గ్యాస్ ధర 200 గ్వేయి.
+
+మొత్తం రుసుము: `గ్యాస్ యూనిట్లు (పరిమితి) * ప్రతి యూనిట్‌కు గ్యాస్ ధర` అంటే `21,000 * 200 = 4,200,000 గ్వేయి` లేదా 0.0042 ETH
+
+లండన్ నవీకరణలో [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559) అమలు లావాదేవీ రుసుము యంత్రాంగాన్ని మరింత క్లిష్టతరం చేసింది, కానీ గ్యాస్ రుసుములను మరింత ఊహించగలిగేలా చేసింది, ఫలితంగా మరింత సమర్థవంతమైన లావాదేవీ రుసుము మార్కెట్ ఏర్పడింది. వినియోగదారులు గ్యాస్ (`మూల రుసుము`) కోసం మార్కెట్ ధర కంటే ఎక్కువ చెల్లించరని తెలుసుకుని, మరియు వారి టిప్‌ను మినహాయించి, ఏదైనా అదనపు మొత్తాన్ని తిరిగి పొందుతారని తెలుసుకుని, లావాదేవీని అమలు చేయడానికి వారు ఎంత చెల్లించడానికి సిద్ధంగా ఉన్నారో దానికి అనుగుణంగా `maxFeePerGas`తో లావాదేవీలను సమర్పించవచ్చు.
+
+ఈ వీడియో EIP-1559 మరియు దాని వల్ల కలిగే ప్రయోజనాలను వివరిస్తుంది: [EIP-1559 వివరించబడింది](https://www.youtube.com/watch?v=MGemhK9t44Q)
+
+- [మీరు డాప్స్ అభివృద్ధి చేసేవారా? మీ గ్రంథాలయాలను మరియు పనిముట్లను నవీకరించుకోవాలని నిర్ధారించుకోండి.](https://github.com/ethereum/execution-specs/blob/master/network-upgrades/london-ecosystem-readiness.md)
+- [ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2021/07/15/london-mainnet-announcement/)
+- [ఇతీరియము క్యాట్ హెర్డర్ వివరణను చదవండి](https://medium.com/ethereum-cat-herders/london-upgrade-overview-8eccb0041b41)
+
+<ExpandableCard title="లండన్ EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1559">EIP-1559</a> – <em>లావాదేవీ రుసుము మార్కెట్‌ను మెరుగుపరుస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3198">EIP-3198</a> – <em>బ్లాక్ నుండి <code>BASEFEE</code>ను తిరిగి ఇస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3529">EIP-3529</a> - <em>EVM కార్యకలాపాల కోసం గ్యాస్ వాపసులను తగ్గిస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3541">EIP-3541</a> - <em><code>0xEF</code>తో ప్రారంభమయ్యే కాంట్రాక్ట్‌లను అమలు చేయడాన్ని నిరోధిస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-3554">EIP-3554</a> – <em>ఐస్ ఏజ్‌ను డిసెంబర్ 2021 వరకు ఆలస్యం చేస్తుంది</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### బెర్లిన్ {#berlin}
+
+<NetworkUpgradeSummary name="berlin" />
+
+#### సారాంశం {#berlin-summary}
+
+బెర్లిన్ నవీకరణ కొన్ని EVM చర్యల కోసం గ్యాస్ ఖర్చును ఆప్టిమైజ్ చేసింది మరియు బహుళ లావాదేవీ రకాలకు మద్దతును పెంచుతుంది.
+
+- [ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2021/03/08/ethereum-berlin-upgrade-announcement/)
+- [ఇతీరియము క్యాట్ హెర్డర్ వివరణను చదవండి](https://medium.com/ethereum-cat-herders/the-berlin-upgrade-overview-2f7ad710eb80)
+
+<ExpandableCard title="బెర్లిన్ EIPలు" contentPreview="ఈ నవీకరణలో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2565">EIP-2565</a> – <em>ModExp గ్యాస్ ఖర్చును తగ్గిస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2718">EIP-2718</a> – <em>బహుళ లావాదేవీ రకాలకు సులభమైన మద్దతును ప్రారంభిస్తుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2929">EIP-2929</a> – <em>స్థితి యాక్సెస్ ఆప్కోడ్లకు గ్యాస్ ఖర్చు పెరుగుతుంది</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2930">EIP-2930</a> – <em>ఐచ్ఛిక యాక్సెస్ జాబితాలను జోడిస్తుంది</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2020 {#2020}
+
+### బీకన్ చైన్ జెనెసిస్ {#beacon-chain-genesis}
+
+<NetworkUpgradeSummary name="beaconChainGenesis" />
+
+#### సారాంశం {#beacon-chain-genesis-summary}
+
+సురక్షితంగా పంపడానికి [బీకన్ చైన్](/roadmap/beacon-chain/)కు 32 స్టేక్ చేసిన ETH యొక్క 16384 డిపాజిట్లు అవసరం. ఇది నవంబర్ 27న జరిగింది, మరియు బీకన్ చైన్ డిసెంబర్ 1, 2020న బ్లాక్‌లను ఉత్పత్తి చేయడం ప్రారంభించింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2020/11/27/eth2-quick-update-no-21/)
+
+<DocLink href="/roadmap/beacon-chain/">
+  బీకన్ చైన్
+</DocLink>
+
+---
+
+### స్టేకింగ్ డిపాజిట్ కాంట్రాక్ట్ అమలు చేయబడింది {#staking-deposit-contract}
+
+<NetworkUpgradeSummary name="stakingDepositContractDeployed" />
+
+#### సారాంశం {#deposit-contract-summary}
+
+స్టేకింగ్ డిపాజిట్ కాంట్రాక్ట్ ఇతీరియము పర్యావరణ వ్యవస్థకు [స్టేకింగ్](/glossary/#staking)ను ప్రవేశపెట్టింది. ఇది [మెయిన్‌నెట్](/glossary/#mainnet) కాంట్రాక్ట్ అయినప్పటికీ, ఇది ముఖ్యమైన [ఇతీరియము నవీకరణ](/roadmap/) అయిన [బీకన్ చైన్](/roadmap/beacon-chain/)ను ప్రారంభించే కాలక్రమంపై ప్రత్యక్ష ప్రభావాన్ని చూపింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2020/11/04/eth2-quick-update-no-19/)
+
+<DocLink href="/staking/">
+  స్టేకింగ్
+</DocLink>
+
+---
+
+### మ్యూయిర్ గ్లేసియర్ {#muir-glacier}
+
+<NetworkUpgradeSummary name="muirGlacier" />
+
+#### సారాంశం {#muir-glacier-summary}
+
+మ్యూయిర్ గ్లేసియర్ ఫోర్క్ [డిఫికల్టీ బాంబ్](/glossary/#difficulty-bomb) ఆలస్యాన్ని ప్రవేశపెట్టింది. [ప్రూఫ్-ఆఫ్-వర్క్](/developers/docs/consensus-mechanisms/pow/) ఏకాభిప్రాయ యంత్రాంగం యొక్క బ్లాక్ డిఫికల్టీలో పెరుగుదల లావాదేవీలను పంపడం మరియు డాప్స్ ఉపయోగించడం కోసం వేచి ఉండే సమయాన్ని పెంచడం ద్వారా ఇతీరియము యొక్క వినియోగితను క్షీణింపజేసే ప్రమాదం ఉంది.
+
+- [ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2019/12/23/ethereum-muir-glacier-upgrade-announcement/)
+- [ఇతీరియము క్యాట్ హెర్డర్ వివరణను చదవండి](https://medium.com/ethereum-cat-herders/ethereum-muir-glacier-upgrade-89b8cea5a210)
+
+<ExpandableCard title="ముయిర్ గ్లేసియర్ EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2384">EIP-2384</a> – <em>మరో 4,000,000 బ్లాక్‌ల వరకు, లేదా ~611 రోజుల వరకు డిఫికల్టీ బాంబును ఆలస్యం చేస్తుంది.</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2019 {#2019}
+
+### ఇస్తాంబుల్ {#istanbul}
+
+<NetworkUpgradeSummary name="istanbul" />
+
+#### సారాంశం {#istanbul-summary}
+
+ఇస్తాంబుల్ ఫోర్క్:
+
+- [EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine)లోని కొన్ని చర్యల [గ్యాస్](/glossary/#gas) ఖర్చును ఆప్టిమైజ్ చేసింది.
+- సేవా నిరాకరణ దాడి నిరోధకతను మెరుగుపరిచింది.
+- SNARKలు మరియు STARKలపై ఆధారపడిన [లేయర్ 2 స్కేలింగ్](/developers/docs/scaling/#layer-2-scaling) పరిష్కారాలను మరింత పనితీరుతో చేసింది.
+- ఇతీరియము మరియు జడ్‌క్యాష్ పరస్పరం పనిచేయడానికి వీలు కల్పించింది.
+- కాంట్రాక్ట్‌లు మరింత సృజనాత్మక ఫంక్షన్‌లను ప్రవేశపెట్టడానికి అనుమతించింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2019/11/20/ethereum-istanbul-upgrade-announcement/)
+
+<ExpandableCard title="ఇస్తాంబుల్ EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-152">EIP-152</a> – <em>ఇతీరియమును గోప్యతను కాపాడే కరెన్సీ అయిన జడ్‌క్యాష్‌తో పని చేయడానికి అనుమతిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1108">EIP-1108</a> – <em>[గ్యాస్](/glossary/#gas) ఖర్చులను మెరుగుపరచడానికి చౌకైన క్రిప్టోగ్రఫీ.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1344">EIP-1344</a> – <em><code>CHAINID</code> [ఆప్కోడ్](/developers/docs/ethereum-stack/#ethereum-virtual-machine)ను జోడించడం ద్వారా ఇతీరియమును రీప్లే దాడుల నుండి కాపాడుతుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1884">EIP-1884</a> – <em>వినియోగం ఆధారంగా ఆప్కోడ్ గ్యాస్ ధరలను ఆప్టిమైజ్ చేయడం.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2028">EIP-2028</a> – <em>బ్లాక్‌లలో ఎక్కువ డేటాను అనుమతించడానికి CallData ఖర్చును తగ్గిస్తుంది – [లేయర్ 2 స్కేలింగ్](/developers/docs/scaling/#layer-2-scaling) కోసం మంచిది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2200">EIP-2200</a> – <em>ఇతర ఆప్కోడ్ గ్యాస్ ధర మార్పులు.</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### కాన్స్టాంటినోపుల్ {#constantinople}
+
+<NetworkUpgradeSummary name="constantinople" />
+
+#### సారాంశం {#constantinople-summary}
+
+కాన్స్టాంటినోపుల్ ఫోర్క్:
+
+- బ్లాక్ [మైనింగ్](/developers/docs/consensus-mechanisms/pow/mining/) రివార్డులను 3 నుండి 2 ETHకి తగ్గించింది.
+- [ప్రూఫ్-ఆఫ్-స్టేక్ అమలు చేయబడకముందు](#beacon-chain-genesis) బ్లాక్ చైను స్తంభించకుండా చూసింది.
+- [EVM](/developers/docs/ethereum-stack/#ethereum-virtual-machine)లోని కొన్ని చర్యల [గ్యాస్](/glossary/#gas) ఖర్చును ఆప్టిమైజ్ చేసింది.
+- ఇంకా సృష్టించబడని చిరునామాలతో పరస్పర చర్య జరిపే సామర్థ్యాన్ని జోడించింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2019/02/22/ethereum-constantinople-st-petersburg-upgrade-announcement/)
+
+<ExpandableCard title="కాన్స్టాంటినోపుల్ EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-145">EIP-145</a> – <em>కొన్ని ఆన్‌చైన్ చర్యల ఖర్చును ఆప్టిమైజ్ చేస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1014">EIP-1014</a> – <em>ఇంకా సృష్టించబడని చిరునామాలతో పరస్పర చర్య జరపడానికి మిమ్మల్ని అనుమతిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1052">EIP-1052</a> – <em>మరొక కాంట్రాక్ట్ సంకేత భాష యొక్క హాష్‌ను తిరిగి పొందడానికి <code>EXTCODEHASH</code> సూచనను ప్రవేశపెడుతుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-1234">EIP-1234</a> – <em>బ్లాక్ చైను ప్రూఫ్-ఆఫ్-స్టేక్ ముందు స్తంభించకుండా చూస్తుంది మరియు బ్లాక్ రివార్డును 3 నుండి 2 ETHకి తగ్గిస్తుంది.</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2017 {#2017}
+
+### బైజాంటియమ్ {#byzantium}
+
+<NetworkUpgradeSummary name="byzantium" />
+
+#### సారాంశం {#byzantium-summary}
+
+బైజాంటియమ్ ఫోర్క్:
+
+- బ్లాక్ [మైనింగ్](/developers/docs/consensus-mechanisms/pow/mining/) రివార్డులను 5 నుండి 3 ETHకి తగ్గించింది.
+- [డిఫికల్టీ బాంబ్](/glossary/#difficulty-bomb)ను ఒక సంవత్సరం పాటు ఆలస్యం చేసింది.
+- ఇతర కాంట్రాక్ట్‌లకు స్థితి-మార్చని కాల్స్ చేసే సామర్థ్యాన్ని జోడించింది.
+- [లేయర్ 2 స్కేలింగ్](/developers/docs/scaling/#layer-2-scaling)ను అనుమతించడానికి కొన్ని క్రిప్టోగ్రఫీ పద్ధతులను జోడించింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2017/10/12/byzantium-hf-announcement/)
+
+<ExpandableCard title="బైజాంటియం EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-140">EIP-140</a> – <em><code>REVERT</code> ఆప్కోడ్‌ను జోడిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-658">EIP-658</a> – <em>విజయం లేదా వైఫల్యాన్ని సూచించడానికి లావాదేవీల రసీదులకు స్థితి ఫీల్డ్ జోడించబడింది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-196">EIP-196</a> – <em>[ZK-Snarks](/developers/docs/scaling/zk-rollups/)ను అనుమతించడానికి ఎలిప్టిక్ కర్వ్ మరియు స్కేలార్ మల్టిప్లికేషన్‌ను జోడిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-197">EIP-197</a> – <em>[ZK-Snarks](/developers/docs/scaling/zk-rollups/)ను అనుమతించడానికి ఎలిప్టిక్ కర్వ్ మరియు స్కేలార్ మల్టిప్లికేషన్‌ను జోడిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-198">EIP-198</a> – <em>RSA సంతకం ధృవీకరణను ప్రారంభిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-211">EIP-211</a> – <em>వేరియబుల్ పొడవు రిటర్న్ విలువలకు మద్దతును జోడిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-214">EIP-214</a> – <em><code>STATICCALL</code> ఆప్కోడ్‌ను జోడిస్తుంది, ఇతర కాంట్రాక్ట్‌లకు స్థితి-మార్చని కాల్స్‌ను అనుమతిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-100">EIP-100</a> – <em>డిఫికల్టీ సర్దుబాటు ఫార్ములాను మారుస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-649">EIP-649</a> – <em>[డిఫికల్టీ బాంబ్](/glossary/#difficulty-bomb)ను 1 సంవత్సరం ఆలస్యం చేస్తుంది మరియు బ్లాక్ రివార్డును 5 నుండి 3 ETHకి తగ్గిస్తుంది.</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2016 {#2016}
+
+### స్ప్యూరియస్ డ్రాగన్ {#spurious-dragon}
+
+<NetworkUpgradeSummary name="spuriousDragon" />
+
+#### సారాంశం {#spurious-dragon-summary}
+
+స్ప్యూరియస్ డ్రాగన్ ఫోర్క్ నెట్‌వర్క్‌పై (సెప్టెంబర్/అక్టోబర్ 2016) సేవా నిరాకరణ (DoS) దాడులకు రెండవ ప్రతిస్పందన, ఇందులో ఇవి ఉన్నాయి:
+
+- నెట్‌వర్క్‌పై భవిష్యత్ దాడులను నివారించడానికి ఆప్కోడ్ ధరను ట్యూన్ చేయడం.
+- బ్లాక్ చైను స్థితిని “డీబ్లోట్” చేయడానికి వీలు కల్పించడం.
+- రీప్లే దాడి రక్షణను జోడించడం.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2016/11/18/hard-fork-no-4-spurious-dragon/)
+
+<ExpandableCard title="స్పురియస్ డ్రాగన్ EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-155">EIP-155</a> – <em>ఒక ఇతీరియము చైన్ నుండి లావాదేవీలు ప్రత్యామ్నాయ చైన్‌పై పునఃప్రసారం చేయబడకుండా నిరోధిస్తుంది, ఉదాహరణకు ఒక టెస్టునెట్ లావాదేవీ ప్రధాన ఇతీరియము చైన్‌పై రీప్లే చేయబడటం.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-160">EIP-160</a> – <em><code>EXP</code> ఆప్కోడ్ ధరలను సర్దుబాటు చేస్తుంది – గణనపరంగా ఖరీదైన కాంట్రాక్ట్ కార్యకలాపాల ద్వారా నెట్‌వర్క్‌ను నెమ్మది చేయడం మరింత కష్టతరం చేస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-161">EIP-161</a> – <em>DOS దాడుల ద్వారా జోడించబడిన ఖాళీ ఖాతాలను తొలగించడానికి అనుమతిస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-170">EIP-170</a> – <em>బ్లాక్ చైనులోని ఒక కాంట్రాక్ట్ కలిగి ఉండగల గరిష్ట సంకేత భాష పరిమాణాన్ని మారుస్తుంది – 24576 బైట్లకు.</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### టాంజెరిన్ విజిల్ {#tangerine-whistle}
+
+<NetworkUpgradeSummary name="tangerineWhistle" />
+
+#### సారాంశం {#tangerine-whistle-summary}
+
+టాంజెరిన్ విజిల్ ఫోర్క్ నెట్‌వర్క్‌పై (సెప్టెంబర్/అక్టోబర్ 2016) సేవా నిరాకరణ (DoS) దాడులకు మొదటి ప్రతిస్పందన, ఇందులో ఇవి ఉన్నాయి:
+
+- తక్కువ ధర ఉన్న ఆపరేషన్ సంకేత భాషలకు సంబంధించిన అత్యవసర నెట్‌వర్క్ ఆరోగ్య సమస్యలను పరిష్కరించడం.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2016/10/18/faq-upcoming-ethereum-hard-fork/)
+
+<ExpandableCard title="టాన్జేరిన్ విజిల్ EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-150">EIP-150</a> – <em>స్పామ్ దాడులలో ఉపయోగించగల ఆప్కోడ్ల గ్యాస్ ఖర్చులను పెంచుతుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-158">EIP-158</a> – <em>ఇతీరియము ప్రోటోకాల్ యొక్క మునుపటి వెర్షన్లలోని లోపాల కారణంగా చాలా తక్కువ ఖర్చుతో స్థితిలో ఉంచబడిన పెద్ద సంఖ్యలో ఖాళీ ఖాతాలను తొలగించడం ద్వారా స్థితి పరిమాణాన్ని తగ్గిస్తుంది.</em></li>
+</ul>
+</ExpandableCard>
+
+---
+
+### DAO ఫోర్క్ {#dao-fork}
+
+<NetworkUpgradeSummary name="daoFork" />
+
+#### సారాంశం {#dao-fork-summary}
+
+DAO ఫోర్క్ [2016 DAO దాడి](https://www.coindesk.com/learn/understanding-the-dao-attack/)కి ప్రతిస్పందన, ఇక్కడ ఒక అసురక్షిత [DAO](/glossary/#dao) కాంట్రాక్ట్ నుండి ఒక హ్యాక్‌లో 3.6 మిలియన్ల కంటే ఎక్కువ ETH దోపిడీ చేయబడింది. ఈ ఫోర్క్ నిధులను తప్పు కాంట్రాక్ట్ నుండి ఒకే ఫంక్షన్‌తో [కొత్త కాంట్రాక్ట్](https://eth.blockscout.com/address/0xbf4ed7b27f1d666546e30d74d50d173d20bca754)కు తరలించింది: ఉపసంహరణ. నిధులను కోల్పోయిన ఎవరైనా వారి వాలెట్‌లలోని ప్రతి 100 DAO టోకెన్లకు 1 ETH ఉపసంహరించుకోవచ్చు.
+
+ఈ చర్యకు Ethereum కమ్యూనిటీ ఓటు వేసింది. ఏదైనా ETH హోల్డర్ [ఒక ఓటింగ్ ప్లాట్‌ఫారమ్](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/)లో లావాదేవీ ద్వారా ఓటు వేయగలిగారు. ఫోర్క్ చేయాలనే నిర్ణయం 85% కంటే ఎక్కువ ఓట్లను చేరుకుంది.
+
+కొందరు మైనర్లు ఫోర్క్ చేయడానికి నిరాకరించారు ఎందుకంటే DAO సంఘటన ప్రోటోకాల్‌లో లోపం కాదు. వారు [Ethereum Classic](https://ethereumclassic.org/)ని ఏర్పాటు చేశారు.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2016/07/20/hard-fork-completed/)
+
+---
+
+### హోమ్‌స్టెడ్ {#homestead}
+
+<NetworkUpgradeSummary name="homestead" />
+
+#### సారాంశం {#homestead-summary}
+
+హోమ్‌స్టెడ్ ఫోర్క్ భవిష్యత్తును దృష్టిలో ఉంచుకుంది. ఇందులో అనేక ప్రోటోకాల్ మార్పులు మరియు ఒక నెట్‌వర్కింగ్ మార్పు ఉన్నాయి, ఇది ఇతీరియముకు భవిష్యత్ నెట్‌వర్క్ నవీకరణలు చేసే సామర్థ్యాన్ని ఇచ్చింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2016/02/29/homestead-release/)
+
+<ExpandableCard title="హోమ్‍‍స్టెడ్ EIPలు" contentPreview="ఈ ఫోర్క్ లో చేర్చబడిన అధికారిక మెరుగుదలలు.">
+
+<ul>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-2">EIP-2</a> – <em>కాంట్రాక్ట్ సృష్టి ప్రక్రియకు మార్పులు చేస్తుంది.</em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-7">EIP-7</a> – <em>కొత్త ఆప్కోడ్‌ను జోడిస్తుంది: <code>DELEGATECALL</code></em></li>
+  <li><a href="https://eips.ethereum.org/EIPS/eip-8">EIP-8</a> – <em>devp2p ఫార్వర్డ్ కంపాటిబిలిటీ అవసరాలను ప్రవేశపెడుతుంది</em></li>
+</ul>
+</ExpandableCard>
+
+<Divider />
+
+## 2015 {#2015}
+
+### ఫ్రాంటియర్ థావింగ్ {#frontier-thawing}
+
+<NetworkUpgradeSummary name="frontierThawing" />
+
+#### సారాంశం {#frontier-thawing-summary}
+
+ఫ్రాంటియర్ థావింగ్ ఫోర్క్ ప్రతి [బ్లాక్](/glossary/#block)కు 5,000 [గ్యాస్](/glossary/#gas) పరిమితిని ఎత్తివేసింది మరియు డిఫాల్ట్ గ్యాస్ ధరను 51 [గ్వేయి](/glossary/#gwei)కి సెట్ చేసింది. ఇది లావాదేవీలను అనుమతించింది – లావాదేవీలకు 21,000 గ్యాస్ అవసరం. [ప్రూఫ్-ఆఫ్-స్టేక్](/glossary/#pos)కు భవిష్యత్ హార్డ్-ఫోర్క్‌ను నిర్ధారించడానికి [డిఫికల్టీ బాంబ్](/glossary/#difficulty-bomb) ప్రవేశపెట్టబడింది.
+
+- [ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2015/08/04/the-thawing-frontier/)
+- [ఇతీరియము ప్రోటోకాల్ నవీకరణ 1ని చదవండి](https://blog.ethereum.org/2015/08/04/ethereum-protocol-update-1/)
+
+---
+
+### ఫ్రాంటియర్ {#frontier}
+
+<NetworkUpgradeSummary name="frontier" />
+
+#### సారాంశం {#frontier-summary}
+
+ఫ్రాంటియర్ ఇతీరియము ప్రాజెక్ట్ యొక్క ప్రత్యక్ష, కానీ బేర్‌బోన్ అమలు. ఇది విజయవంతమైన ఒలింపిక్ పరీక్ష దశను అనుసరించింది. ఇది సాంకేతిక వినియోగదారుల కోసం, ప్రత్యేకంగా డెవలపర్‌ల కోసం ఉద్దేశించబడింది. [బ్లాక్‌లు](/glossary/#block) 5,000 [గ్యాస్](/glossary/#gas) పరిమితిని కలిగి ఉండేవి. ఈ ‘కరిగే’ కాలం మైనర్లు తమ కార్యకలాపాలను ప్రారంభించడానికి మరియు ప్రారంభ స్వీకర్తలు తమ ఖాతాదారులను ‘ поспіхом’ ఇన్‌స్టాల్ చేసుకోవడానికి వీలు కల్పించింది.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2015/07/22/frontier-is-coming-what-to-expect-and-how-to-prepare/)
+
+<Divider />
+
+## 2014 {#2014}
+
+### ఈథర్ అమ్మకం {#ether-sale}
+
+<NetworkUpgradeSummary name="etherSale" />
+
+ఈథర్ అధికారికంగా 42 రోజుల పాటు అమ్మకానికి వచ్చింది. మీరు దానిని BTCతో కొనుగోలు చేయవచ్చు.
+
+[ఇతీరియము ఫౌండేషన్ ప్రకటనను చదవండి](https://blog.ethereum.org/2014/07/22/launching-the-ether-sale/)
+
+---
+
+### పసుపు పత్రం విడుదల చేయబడింది {#yellowpaper}
+
+<NetworkUpgradeSummary name="yellowpaperRelease" />
+
+డా. గావిన్ వుడ్ రచించిన పసుపు పత్రం, ఇతీరియము ప్రోటోకాల్ యొక్క సాంకేతిక నిర్వచనం.
+
+[పసుపు పత్రాన్ని వీక్షించండి](https://github.com/ethereum/yellowpaper)
+
+<Divider />
+
+## 2013 {#2013}
+
+### వైట్‌పేపర్ విడుదల చేయబడింది {#whitepaper}
+
+<NetworkUpgradeSummary name="whitepaperRelease" />
+
+2013లో విటాలిక్ బ్యూటెరిన్, ఇతీరియము వ్యవస్థాపకుడు, 2015లో ప్రాజెక్ట్ ప్రారంభానికి ముందు ప్రచురించిన పరిచయ పత్రం.
+
+<DocLink href="/whitepaper/">
+  వైట్‌పేపర్
+</DocLink>
diff --git a/public/content/translations/te/foundation/index.md b/public/content/translations/te/foundation/index.md
new file mode 100644
index 00000000000..4d42bc884b4
--- /dev/null
+++ b/public/content/translations/te/foundation/index.md
@@ -0,0 +1,33 @@
+---
+title: "Ethereum ఫౌండేషన్"
+description: "Ethereum మరియు సంబంధిత సాంకేతికతలకు మద్దతు ఇవ్వడానికి అంకితమైన లాభాపేక్ష లేని సంస్థ Ethereum ఫౌండేషన్ (EF) గురించి తెలుసుకోండి."
+hideEditButton: true
+lang: te
+---
+
+# ఇథీరియం ఫౌండేషన్ {#ethereum-foundation}
+
+<Logo/>
+
+[Ethereum Foundation](http://ethereum.foundation/) (EF) అనేది ఇతీరియము పర్యావరణ వ్యవస్థకు మద్దతునిచ్చే ఒక లాభాపేక్ష లేని సంస్థ. ఇది ప్రోటోకాల్ అభివృద్ధికి నిధులు సమకూరుస్తుంది, పర్యావరణ వ్యవస్థను వృద్ధి చేస్తుంది మరియు ఇతీరియము కోసం వాదిస్తుంది.
+
+EF ఒక కంపెనీ కాదు, లేదా సాంప్రదాయ లాభాపేక్ష లేనిది కూడా. ఇది ఇతీరియమును నియంత్రించదు లేదా నడిపించదు, అలాగే ఇతీరియము-సంబంధిత సాంకేతికతల యొక్క కీలక అభివృద్ధికి నిధులు సమకూర్చే ఏకైక సంస్థ కూడా ఇది కాదు. EF అనేది చాలా పెద్ద [పర్యావరణ వ్యవస్థ](/community/)లో ఒక భాగం.
+
+## EF ఏమి చేస్తుంది {#what-the-ef-does}
+
+- **ప్రోటోకాల్ అభివృద్ధి** – క్లయింట్ అభివృద్ధి, పరిశోధన, నవీకరణలు మరియు [బగ్ బౌంటీ ప్రోగ్రామ్](/bug-bounty/)తో సహా ఇతీరియము యొక్క కోర్ ప్రోటోకాల్‌పై పనిచేస్తున్న బృందాలకు మద్దతు ఇవ్వడం
+- **పర్యావరణ వ్యవస్థ నిధులు** – [ఎకోసిస్టమ్ సపోర్ట్ ప్రోగ్రామ్](https://esp.ethereum.foundation/) ద్వారా ఇతీరియముపై నిర్మించే ప్రాజెక్ట్‌లకు గ్రాంట్లు మరియు మద్దతును అందించడం
+- **పరిశోధన** – క్రిప్టోగ్రఫీ, ఏకాభిప్రాయం, స్కేలింగ్, గోప్యత మరియు భద్రత వంటి రంగాలలో పరిశోధనకు నిధులు సమకూర్చడం
+
+## కార్యక్రమాలు మరియు చొరవలు {#programs-and-initiatives}
+
+- **[ఎకోసిస్టమ్ సపోర్ట్ ప్రోగ్రామ్](https://esp.ethereum.foundation/)** – ఇతీరియముపై నిర్మించబడుతున్న ఓపెన్-సోర్స్ ప్రాజెక్ట్‌ల కోసం గ్రాంట్లు మరియు మద్దతు
+- **[అకడమిక్ గ్రాంట్స్](https://esp.ethereum.foundation/academic-grants)** – ఇతీరియము-సంబంధిత అకడమిక్ పరిశోధనకు మద్దతు
+- **[Devcon](https://devcon.org/)** – ఇతీరియము డెవలపర్లు, పరిశోధకులు మరియు బిల్డర్ల కోసం వార్షిక సమావేశం
+- **[బగ్ బౌంటీ ప్రోగ్రామ్](/bug-bounty/)** – ఇతీరియము ప్రోటోకాల్‌లో లోపాలను కనుగొన్నందుకు బహుమతులు
+
+## మరింత తెలుసుకోండి {#learn-more}
+
+- [ethereum.foundation](https://ethereum.foundation/) – అధికారిక EF వెబ్‌సైట్
+- [EF బ్లాగ్](https://blog.ethereum.org/) – వార్తలు మరియు ప్రకటనలు
+- [ఎకోసిస్టమ్ సపోర్ట్ ప్రోగ్రామ్](https://esp.ethereum.foundation/) – గ్రాంట్లు మరియు మద్దతు
diff --git a/public/content/translations/te/gaming/index.md b/public/content/translations/te/gaming/index.md
new file mode 100644
index 00000000000..2f70047629b
--- /dev/null
+++ b/public/content/translations/te/gaming/index.md
@@ -0,0 +1,70 @@
+---
+title: "ఆన్చైన్ గేమింగ్"
+lang: te
+template: use-cases
+image: /images/robot-help-bar.png
+sidebarDepth: 2
+summaryPoint1: "గేమ్ నియమాలు మరియు స్థితిని స్టూడియో సర్వర్లు కాకుండా బ్లాక్‌చైన్ ద్వారా అమలు చేయవచ్చు"
+summaryPoint2: "అదే ఆన్చైన్ డేటాలోకి ప్లగ్ అయ్యే మోడ్స్, బాట్స్ లేదా పూర్తిగా కొత్త గేమ్స్ ఎవరైనా నిర్మించవచ్చు"
+summaryPoint3: "రెడ్‌స్టోన్ వంటి ప్రయోజన-నిర్మిత L2లు మరియు MUD వంటి ఫ్రేమ్‌వర్క్‌లు, నిజ-సమయ గేమ్‌ప్లేకు మద్దతు ఇచ్చేంతగా ఖర్చులను తగ్గిస్తాయి"
+buttons:
+  - content: ఇంకా నేర్చుకోండి
+    toId: how-gaming-on-ethereum-works
+  - content: యాప్‌లను అన్వేషించండి
+    toId: popular-games-built-on-ethereum
+    isSecondary: false
+---
+
+## Ethereumలో గేమింగ్ ఎలా పనిచేస్తుంది {#how-gaming-on-ethereum-works}
+
+Ethereumలో గేమింగ్ వివిధ రూపాల్లో వస్తుంది, నిర్దిష్ట ఫీచర్ల కోసం బ్లాక్‌చైన్‌ను ఏకీకృతం చేసే గేమ్‌ల నుండి మొత్తం గేమ్ ప్రపంచం ఆన్‌చైన్‌లో నివసించే గేమ్‌ల వరకు ఉంటుంది. చాలా గేమ్‌లు ఇన్-గేమ్ ఆస్తులను NFTలుగా (నాన్-ఫంగబుల్ టోకెన్లు) నిర్వహించడానికి Ethereumను ఉపయోగిస్తాయి. ఇది ఒకే గేమ్ డెవలపర్ యొక్క పర్యావరణ వ్యవస్థ యొక్క పరిమితులకు వెలుపల బహిరంగంగా ట్రేడ్ చేయడానికి, అమ్మడానికి లేదా బహుమతిగా ఇవ్వడానికి వీలైన ప్రత్యేకమైన డిజిటల్ వస్తువులను నిజంగా స్వంతం చేసుకోవడానికి ఆటగాళ్లను అనుమతిస్తుంది. ఈ ఆస్తులు ప్లేయర్ ఏజెన్సీ యొక్క కొత్త రూపాలను అందిస్తున్నప్పటికీ, కోర్ గేమ్ లాజిక్ తరచుగా కేంద్రీకృత సర్వర్లలో ఉంటుంది.
+
+పూర్తిగా ఆన్‌చైన్ గేమ్‌లు అంటే ప్రాథమిక మెకానిక్స్ మరియు తరచుగా మొత్తం గేమ్ ప్రపంచం, Ethereum బ్లాక్‌చైన్ (లేదా దాని లేయర్ 2లు) పై ఉన్న స్మార్ట్ కాంట్రాక్టుల ద్వారా నేరుగా నియంత్రించబడతాయి. ఇది అసమానమైన పారదర్శకతను నిర్ధారిస్తుంది. కేంద్ర సర్వర్లు లేవు, మధ్యవర్తులు లేరు—కేవలం పారదర్శకమైన, ప్లేయర్-ఆధారిత అనుభవాలు మరియు ఆర్థిక వ్యవస్థలు.
+
+- ఆటగాళ్లు తమ ఆస్తులను NFTలుగా సొంతం చేసుకుంటారు.
+- వస్తువులను స్వేచ్ఛగా ట్రేడ్ చేయవచ్చు, బహుమతిగా ఇవ్వవచ్చు లేదా అమ్మవచ్చు.
+- బ్లాక్‌చైన్ ఆస్తులు ఎప్పటికీ అందుబాటులో ఉండేలా చూస్తుంది.
+
+## గేమింగ్ యొక్క ప్రస్తుత స్థితి {#the-current-state-of-gaming}
+
+- **తరచుగా గేమ్ షట్‌డౌన్‌లు:** 2023 లోనే, [60+ గేమ్‌లు మూసివేయబడ్డాయి](https://tech4gamers.com/game-studios-shut-down-2023/), మరియు 11 గేమ్ స్టూడియోలు పూర్తిగా మూసివేయబడ్డాయి, దీనివల్ల ఆటగాళ్లకు వారి ఇన్-గేమ్ పెట్టుబడులకు ఏమీ మిగల్లేదు. ఆన్‌చైన్ గేమ్‌లు, వాటి లాజిక్ మరియు ఆస్తులు వికేంద్రీకృత నెట్‌వర్క్‌లో ఉండటంతో, బ్లాక్‌చైన్ ఉన్నంత కాలం కొనసాగగలవు, ఇది అధిక స్థాయి శాశ్వతత్వాన్ని అందిస్తుంది.
+- **లాక్ చేయబడిన ఆస్తులపై నిరాశ:** [51% గేమర్లు తాము కొనుగోలు చేసే ఇన్-గేమ్ వస్తువులను బహుమతిగా ఇవ్వలేకపోవడం లేదా తిరిగి అమ్మలేకపోవడం పట్ల నిరాశ చెందుతున్నారు](https://www.starknet.io/blog/blockchain-gaming/), మరియు 23% మంది ఇన్-గేమ్ కొనుగోళ్ల నుండి డబ్బును తిరిగి పొందడం ఎంత కష్టంగా ఉందో అని చిరాకు పడుతున్నారు. ఆటగాళ్ళు ఇన్-గేమ్ వస్తువులను సంపాదించడానికి గణనీయమైన సమయం మరియు డబ్బును పెట్టుబడి పెడతారు, కానీ వారు వాటిని నిజంగా స్వంతం చేసుకోలేదని కనుగొంటారు. Ethereum యొక్క NFT ప్రమాణం ధృవీకరించదగిన డిజిటల్ యాజమాన్యాన్ని అందిస్తుంది, ఆటగాళ్లు వారి ఆస్తులను నియంత్రించేలా చూస్తుంది.
+- **తిరిగి రాని అధిక వ్యయం:** [గేమర్లు తమ జీవితకాలంలో వర్చువల్ వస్తువులపై సగటున \$6,425 ఖర్చు చేస్తారు](https://www.starknet.io/blog/blockchain-gaming/), నెలకు \$8.74 లేదా సంవత్సరానికి \$104 ఖర్చు చేస్తారు. ఆన్‌చైన్ యాజమాన్యం ఆ ఖర్చును మునిగిపోయిన ఖర్చు నుండి డిజిటల్ ఆస్తిలో పెట్టుబడిగా మారుస్తుంది, దానిని భౌతిక సేకరణ వస్తువు వలె అమ్మవచ్చు, ట్రేడ్ చేయవచ్చు లేదా బహుమతిగా ఇవ్వవచ్చు.
+
+## Ethereum పై నిర్మించిన ప్రముఖ గేమ్‌లు {#popular-games-built-on-ethereum}
+
+డెవలపర్లు గేమ్‌లను మరింత ఆకర్షణీయంగా చేయడానికి కొత్త మార్గాలను అన్వేషిస్తున్నారు మరియు నైపుణ్యం-ఆధారిత గేమ్‌ప్లేను మరింత లోతుగా చేయడానికి సాధారణ రివార్డ్ మెకానిక్స్కు మించి వెళ్తున్నారు.
+
+<OnchainGamingProductList list="game" />
+
+## ఆడి-సంపాదించు (P2E) {#play-to-earn-p2e}
+
+ప్లే-టు-ఎర్న్ (P2E) గేమ్‌లతో, మీరు నిజ-ప్రపంచ విలువతో ఇన్-గేమ్ ఆస్తులను సంపాదించవచ్చు. అస్థిరమైన రివార్డులపై ఆధారపడిన ప్రారంభ P2E మోడల్‌ల వలె కాకుండా, కొత్త గేమ్‌లు దీర్ఘకాలిక విలువపై దృష్టి పెడతాయి. ఉదాహరణకు, [Wolf Game](https://gam3s.gg/wolf-game/) వ్యూహాత్మక గేమ్‌ప్లేని నిజమైన డిజిటల్ ఆస్తి యాజమాన్యంతో మిళితం చేస్తుంది. ఆటగాళ్లు వర్చువల్ గొర్రెలు మరియు తోడేళ్లను నిర్వహిస్తారు, ఇన్-గేమ్ కరెన్సీ WOOL సంపాదిస్తారు, దీనిని ట్రేడ్ చేయవచ్చు లేదా అమ్మవచ్చు.
+
+<OnchainGamingProductList list="p2e" />
+
+## ఇంటర్‌ఆపరేబిలిటీ & క్రాస్-చైన్ ప్లే {#interoperability-and-cross-chain-play}
+
+గేమింగ్ కోసం Ethereum యొక్క అత్యంత శక్తివంతమైన ఫీచర్లలో ఒకటి ఇంటర్‌ఆపరేబిలిటీ మరియు కంపోజబిలిటీకి దాని స్థానిక మద్దతు. సాంప్రదాయ గేమ్‌లు "గోడలతో కూడిన తోటలలో" పనిచేస్తాయి, ఇన్-గేమ్ ఆస్తులను మరియు పురోగతిని ఒకే టైటిల్‌కు లాక్ చేస్తాయి. Ethereum పై నిర్మించిన ఇన్-గేమ్ ఆస్తులు మరియు కోర్ గేమ్ లాజిక్ కూడా, భద్రతకు భంగం కలగకుండా వివిధ అప్లికేషన్‌లు మరియు చైన్‌ల మధ్య పరస్పరం సంభాషించగలవు. ఇది ఇంకా అభివృద్ధి చెందుతున్న పర్యావరణ వ్యవస్థ అయినప్పటికీ, కొన్ని Ethereum-ఆధారిత గేమ్ నెట్‌వర్క్‌లు ఇప్పటికే ఇంటర్‌ఆపరేబుల్‌గా ఉన్నాయి మరియు ఇన్-గేమ్ ఐటెమ్‌లను (NFTలు) బహుళ గేమ్‌లలో ఉపయోగించడానికి అనుమతిస్తాయి.
+
+ఉదాహరణకు, ఇల్లూవియంలో, [ఆటగాళ్లు ఇల్లూవియల్స్ అనే జీవులను సేకరించగలరు](https://gam3s.gg/news/illuvium-three-web3-games/), ఇవి NFTలు. ఈ ఇల్లూవియల్స్‌ను ఇల్లూవియం విశ్వంలో వివిధ గేమ్‌లలో ఉపయోగించవచ్చు. ఇల్లూవియం ఓవర్‌వరల్డ్‌లో పట్టుబడిన ఒక ఇల్లూవియల్‌ను ఇల్లూవియం అరీనాలో యుద్ధాల కోసం కూడా ఉపయోగించవచ్చు.
+
+మరో ఉదాహరణ గెలాక్సీ ఫైట్ క్లబ్. ఈ గేమ్‌లో, [ఆటగాళ్లు వివిధ NFT సేకరణలను ఉపయోగించి](https://gam3s.gg/galaxy-fight-club/) యుద్ధాలలో పాల్గొనవచ్చు, అంటే వివిధ ప్రాజెక్ట్‌ల నుండి NFTలను గేమ్‌లో ఉపయోగించవచ్చు.
+
+## స్కేలబిలిటీ & గ్యాస్ ఫీజు మెరుగుదలలు {#scalability-and-gas-fee-improvements}
+
+ఆన్‌చైన్ గేమింగ్ పై ఒక పాత విమర్శ ఏమిటంటే, బ్లాక్‌చైన్‌లు గేమర్‌లు ఆశించే అనుభవాన్ని అందించడానికి చాలా క్లిష్టంగా మరియు నెమ్మదిగా ఉంటాయి. కానీ Ethereum పరిపక్వత చెందడంతో, ఆన్‌చైన్ గేమింగ్ ఖర్చును గణనీయంగా తగ్గించడానికి మరియు పనితీరును మెరుగుపరచడానికి పరిష్కారాలు ఉద్భవించాయి, ఇది ఇంటరాక్టివ్ మరియు వేగవంతమైన అనుభవాలను సాధ్యం చేసింది.
+
+ఈ పురోగతులు ప్రధానంగా వీటి ద్వారా సాధించబడ్డాయి:
+
+- **గ్యాస్-లేని లావాదేవీలు:** ఇమ్యూటబుల్ X ను ఉపయోగించుకునే వాటితో సహా కొన్ని ప్లాట్‌ఫారమ్‌లు మరియు ప్రోటోకాల్‌లు, వినియోగదారునికి ఫీజులు లేకుండా NFTలను ట్రేడింగ్ చేయడం లేదా మింటింగ్ చేయడం వంటి లావాదేవీలను నిర్వహించే సామర్థ్యాన్ని అందిస్తాయి, ఇది ప్లేయర్ అనుభవాన్ని మరింత క్రమబద్ధీకరిస్తుంది.
+- **స్కేలింగ్ పరిష్కారాలు:** Arbitrum, zkSync మరియు Starknet వంటి Ethereum L2లు వాటి అధిక త్రూపుట్ మరియు తక్కువ ఖర్చుల కారణంగా ఆన్‌చైన్ గేమ్‌ల కోసం పర్యావరణ వ్యవస్థలను చురుకుగా ప్రోత్సహిస్తున్నాయి.
+- **[MUD పర్యావరణ వ్యవస్థ](https://mud.dev/):** MUD ఆన్‌చైన్ గేమ్ అభివృద్ధి కోసం Ethereum-ఆధారిత అప్లికేషన్ డెవలప్‌మెంట్ టూల్‌కిట్‌లను ఆప్టిమైజ్ చేస్తుంది, సంక్లిష్టమైన గేమ్ లాజిక్ కోసం మరింత సమర్థవంతమైన స్థితి నిర్వహణను అందిస్తుంది.
+
+## Ethereum గేమింగ్‌తో ప్రారంభించండి {#get-started-with-ethereum-gaming}
+
+Ethereum గేమింగ్‌లోకి ప్రవేశించడం మీరు అనుకున్నదానికంటే సులభం. కేవలం కొన్ని దశలతో, మీరు ఆడటం ప్రారంభించవచ్చు మరియు మీ పురోగతిని ఆస్వాదించవచ్చు:
+
+1. **క్రిప్టో వాలెట్‌ను సెటప్ చేయండి:** మీ డిజిటల్ ఆస్తులను నిర్వహించడానికి మరియు వికేంద్రీకృత అప్లికేషన్‌లతో సంభాషించడానికి మీకు ఒక వాలెట్ అవసరం. [ఒక వాలెట్‌ను ఎంచుకోండి](/wallets/find-wallet/)
+2. **మీ వాలెట్‌కు నిధులు సమకూర్చండి:** మీరు ఉపయోగించాలని ప్లాన్ చేస్తున్న లేయర్ 2 నెట్‌వర్క్‌కు సంబంధించిన కొన్ని ఈథర్ (ETH) లేదా టోకెన్‌లను పొందండి.
+3. **గేమ్‌లను అన్వేషించండి:** [Orden](https://orden.gg/), [ChainPlay](https://chainplay.gg/chain/ethereum/), [Gam3s.GG](https://gam3s.gg/), [DappRadar](https://dappradar.com/rankings/protocol/ethereum/category/games), [OpenSea](https://opensea.io/), మరియు [PlayToEarn.net](https://playtoearn.com/blockchaingames) వంటి ప్లాట్‌ఫారమ్‌లలో గేమ్‌లను కనుగొనండి.
diff --git a/public/content/translations/te/glossary/index.md b/public/content/translations/te/glossary/index.md
new file mode 100644
index 00000000000..d5ff8aaab7b
--- /dev/null
+++ b/public/content/translations/te/glossary/index.md
@@ -0,0 +1,505 @@
+---
+title: "ఇతీరియము పదకోశం"
+description: "ఇతీరియముకు సంబంధించిన సాంకేతిక, సాంకేతికేతర పదాల అసంపూర్ణ పదకోశం"
+lang: te
+---
+
+# పదకోశం {#ethereum-glossary}
+
+## \# {#section-numbers}
+
+<GlossaryDefinition term="51%-attack" />
+
+<Divider />
+
+## A {#section-a}
+
+<GlossaryDefinition term="account" />
+
+<GlossaryDefinition term="address" />
+
+<GlossaryDefinition term="abi" />
+
+<GlossaryDefinition term="anti-sybil" />
+
+<GlossaryDefinition term="api" />
+
+<GlossaryDefinition term="apr" />
+
+<GlossaryDefinition term="asic" />
+
+<GlossaryDefinition term="assert" />
+
+<GlossaryDefinition term="attestation" />
+
+<Divider />
+
+## B {#section-b}
+
+<GlossaryDefinition term="base-fee" />
+
+<GlossaryDefinition term="beacon-chain" />
+
+<GlossaryDefinition term="big-endian" />
+
+<GlossaryDefinition term="block" />
+
+<GlossaryDefinition term="block-explorer" />
+
+<GlossaryDefinition term="block-header" />
+
+<GlossaryDefinition term="block-propagation" />
+
+<GlossaryDefinition term="block-proposer" />
+
+<GlossaryDefinition term="block-reward" />
+
+<GlossaryDefinition term="block-status" />
+
+<GlossaryDefinition term="block-time" />
+
+<GlossaryDefinition term="block-validation" />
+
+<GlossaryDefinition term="blockchain" />
+
+<GlossaryDefinition term="bootnode" />
+
+<GlossaryDefinition term="bridge" />
+
+<GlossaryDefinition term="bytecode" />
+
+<GlossaryDefinition term="byzantium-fork" />
+
+<Divider />
+
+## C {#section-c}
+
+<GlossaryDefinition term="casper-ffg" />
+
+<GlossaryDefinition term="checkpoint" />
+
+<GlossaryDefinition term="compiling" />
+
+<GlossaryDefinition term="committee" />
+
+<GlossaryDefinition term="computational-infeasibility" />
+
+<GlossaryDefinition term="consensus" />
+
+<GlossaryDefinition term="consensus-client" />
+
+<GlossaryDefinition term="consensus-layer" />
+
+<GlossaryDefinition term="consensus-rules" />
+
+<GlossaryDefinition term="constantinople-fork" />
+
+<GlossaryDefinition term="contract-account" />
+
+<GlossaryDefinition term="contract-creation-transaction" />
+
+<GlossaryDefinition term="cryptography" />
+
+<GlossaryDefinition term="cryptoeconomics" />
+
+<Divider />
+
+## D {#section-d}
+
+<GlossaryDefinition term="doge-d" />
+
+<GlossaryDefinition term="dag" />
+
+<GlossaryDefinition term="dapp" />
+
+<GlossaryDefinition term="data-availability" />
+
+<GlossaryDefinition term="decentralization" />
+
+<GlossaryDefinition term="dao" />
+
+<GlossaryDefinition term="desci" />
+
+<GlossaryDefinition term="dex" />
+
+<GlossaryDefinition term="deposit-contract" />
+
+<GlossaryDefinition term="defi" />
+
+<GlossaryDefinition term="difficulty" />
+
+<GlossaryDefinition term="difficulty-bomb" />
+
+<GlossaryDefinition term="digital-signatures" />
+
+<GlossaryDefinition term="discovery" />
+
+<GlossaryDefinition term="distributed-hash-table" />
+
+<GlossaryDefinition term="double-spend" />
+
+<Divider />
+
+## E {#section-e}
+
+<GlossaryDefinition term="ecdsa" />
+
+<GlossaryDefinition term="encryption" />
+
+<GlossaryDefinition term="entropy" />
+
+<GlossaryDefinition term="epoch" />
+
+<GlossaryDefinition term="equivocation" />
+
+<GlossaryDefinition term="eth1" />
+
+<GlossaryDefinition term="eth2" />
+
+<GlossaryDefinition term="eip" />
+
+<GlossaryDefinition term="ens" />
+
+<GlossaryDefinition term="execution-client" />
+
+<GlossaryDefinition term="execution-layer" />
+
+<GlossaryDefinition term="eoa" />
+
+<GlossaryDefinition term="erc" />
+
+<GlossaryDefinition term="erc-20" />
+
+<GlossaryDefinition term="erc-721" />
+
+<GlossaryDefinition term="erc-1155" />
+
+<GlossaryDefinition term="ethash" />
+
+<GlossaryDefinition term="ether" />
+
+<GlossaryDefinition term="events" />
+
+<GlossaryDefinition term="evm" />
+
+<GlossaryDefinition term="evm-assembly-language" />
+
+<Divider />
+
+## F {#section-f}
+
+<GlossaryDefinition term="fallback-function" />
+
+<GlossaryDefinition term="faucet" />
+
+<GlossaryDefinition term="finality" />
+
+<GlossaryDefinition term="finney" />
+
+<GlossaryDefinition term="fork" />
+
+<GlossaryDefinition term="fork-choice-algorithm" />
+
+<GlossaryDefinition term="fraud-proof" />
+
+<GlossaryDefinition term="frontier" />
+
+<Divider />
+
+## G {#section-g}
+
+<GlossaryDefinition term="gas" />
+
+<GlossaryDefinition term="gas-limit" />
+
+<GlossaryDefinition term="gas-price" />
+
+<GlossaryDefinition term="genesis-block" />
+
+<GlossaryDefinition term="geth" />
+
+<GlossaryDefinition term="gwei" />
+
+<Divider />
+
+## H {#section-h}
+
+<GlossaryDefinition term="hard-fork" />
+
+<GlossaryDefinition term="hash" />
+
+<GlossaryDefinition term="hash-rate" />
+
+<GlossaryDefinition term="holographic-consensus" />
+
+<GlossaryDefinition term="homestead" />
+
+<Divider />
+
+## I {#section-i}
+
+<GlossaryDefinition term="index" />
+
+<GlossaryDefinition term="ide" />
+
+<GlossaryDefinition term="immutable-deployed-code-problem" />
+
+<GlossaryDefinition term="internal-transaction" />
+
+<GlossaryDefinition term="issuance" />
+
+<Divider />
+
+## K {#section-k}
+
+<GlossaryDefinition term="kdf" />
+
+<GlossaryDefinition term="key" />
+
+<GlossaryDefinition term="keystore" />
+
+<GlossaryDefinition term="keccak-256" />
+
+<Divider />
+
+## L {#section-l}
+
+<GlossaryDefinition term="layer-1" />
+
+<GlossaryDefinition term="layer-2" />
+
+<GlossaryDefinition term="library" />
+
+<GlossaryDefinition term="light-client" />
+
+<GlossaryDefinition term="liquidity" />
+
+<GlossaryDefinition term="liquidity-tokens" />
+
+<GlossaryDefinition term="lmd-ghost" />
+
+<Divider />
+
+## M {#section-m}
+
+<GlossaryDefinition term="mainnet" />
+
+<GlossaryDefinition term="max-fee-per-gas" />
+
+<GlossaryDefinition term="merkle-patricia-tree" />
+
+<GlossaryDefinition term="merkle-root" />
+
+<GlossaryDefinition term="message" />
+
+<GlossaryDefinition term="message-call" />
+
+<GlossaryDefinition term="mev" />
+
+<GlossaryDefinition term="mining" />
+
+<GlossaryDefinition term="miner" />
+
+<GlossaryDefinition term="mint" />
+
+<GlossaryDefinition term="multisig" />
+
+<Divider />
+
+## N {#section-n}
+
+<GlossaryDefinition term="network" />
+
+<GlossaryDefinition term="network-hashrate" />
+
+<GlossaryDefinition term="nft" />
+
+<GlossaryDefinition term="node" />
+
+<GlossaryDefinition term="nonce" />
+
+<Divider />
+
+## O {#section-o}
+
+<GlossaryDefinition term="offchain" />
+
+<GlossaryDefinition term="ommer" />
+
+<GlossaryDefinition term="onchain" />
+
+<GlossaryDefinition term="optimistic-rollup" />
+
+<GlossaryDefinition term="oracle" />
+
+<Divider />
+
+## P {#section-p}
+
+<GlossaryDefinition term="peer" />
+
+<GlossaryDefinition term="peer-to-peer-network" />
+
+<GlossaryDefinition term="permissionless" />
+
+<GlossaryDefinition term="plasma" />
+
+<GlossaryDefinition term="private-key" />
+
+<GlossaryDefinition term="private-chain" />
+
+<GlossaryDefinition term="poap" />
+
+<GlossaryDefinition term="pos" />
+
+<GlossaryDefinition term="pow" />
+
+<GlossaryDefinition term="proto-danksharding" />
+
+<GlossaryDefinition term="public-goods" />
+
+<GlossaryDefinition term="public-key" />
+
+<Divider />
+
+## R {#section-r}
+
+<GlossaryDefinition term="receipt" />
+
+<GlossaryDefinition term="re-entrancy-attack" />
+
+<GlossaryDefinition term="reward" />
+
+<GlossaryDefinition term="rlp" />
+
+<GlossaryDefinition term="rollups" />
+
+<GlossaryDefinition term="rpc" />
+
+<Divider />
+
+## S {#section-s}
+
+<GlossaryDefinition term="sha" />
+
+<GlossaryDefinition term="recovery-phrase" />
+
+<GlossaryDefinition term="sequencer" />
+
+<GlossaryDefinition term="serialization" />
+
+<GlossaryDefinition term="shard" />
+
+<GlossaryDefinition term="sidechain" />
+
+<GlossaryDefinition term="signing" />
+
+<GlossaryDefinition term="singleton" />
+
+<GlossaryDefinition term="slasher" />
+
+<GlossaryDefinition term="slot" />
+
+<GlossaryDefinition term="smart-contract" />
+
+<GlossaryDefinition term="snark" />
+
+<GlossaryDefinition term="soft-fork" />
+
+<GlossaryDefinition term="solidity" />
+
+<GlossaryDefinition term="solidity-inline-assembly" />
+
+<GlossaryDefinition term="stablecoin" />
+
+<GlossaryDefinition term="staking" />
+
+<GlossaryDefinition term="staking-pool" />
+
+<GlossaryDefinition term="stark" />
+
+<GlossaryDefinition term="state" />
+
+<GlossaryDefinition term="state-channels" />
+
+<GlossaryDefinition term="supermajority" />
+
+<GlossaryDefinition term="sybil-attack" />
+
+<GlossaryDefinition term="syncing" />
+
+<GlossaryDefinition term="sync-committee" />
+
+<GlossaryDefinition term="szabo" />
+
+<Divider />
+
+## T {#section-t}
+
+<GlossaryDefinition term="terminal-total-difficulty" />
+
+<GlossaryDefinition term="testnet" />
+
+<GlossaryDefinition term="token" />
+
+<GlossaryDefinition term="token-factory" />
+
+<GlossaryDefinition term="transaction" />
+
+<GlossaryDefinition term="transaction-fee" />
+
+<GlossaryDefinition term="trust-assumptions" />
+
+<GlossaryDefinition term="trustlessness" />
+
+<GlossaryDefinition term="turing-complete" />
+
+<Divider />
+
+## V {#section-v}
+
+<GlossaryDefinition term="validator" />
+
+<GlossaryDefinition term="validator-lifecycle" />
+
+<GlossaryDefinition term="validity-proof" />
+
+<GlossaryDefinition term="validium" />
+
+<GlossaryDefinition term="vyper" />
+
+<Divider />
+
+## W {#section-w}
+
+<GlossaryDefinition term="wallet" />
+
+<GlossaryDefinition term="web3" />
+
+<GlossaryDefinition term="wei" />
+
+<GlossaryDefinition term="wrapped-token" />
+
+<Divider />
+
+## Z {#section-z}
+
+<GlossaryDefinition term="zero-address" />
+
+<GlossaryDefinition term="zk-proof" />
+
+<GlossaryDefinition term="zk-rollup" />
+
+<Divider />
+
+## మూలాలు {#sources}
+
+_CC-BY-SA క్రింద [ఆండ్రియాస్ M. ఆంటోనోపౌలోస్, గావిన్ వుడ్](https://aantonop.com/books/mastering-ethereum) రాసిన [మాస్టరింగ్ ఇతీరియము](https://github.com/ethereumbook/ethereumbook) నుండి పాక్షికంగా అందించబడింది_
+
+<Divider />
+
+## ఈ పేజీకి సహకరించండి {#contribute-to-this-page}
+
+మేము ఏదైనా వదిలేశామా? ఏదైనా తప్పుగా ఉందా? GitHubలో ఈ పదకోశానికి సహకరించి, దానిని మెరుగుపరచడంలో మాకు సహాయం చేయండి!
+
+[ఎలా సహకరించాలో మరింత తెలుసుకోండి](/contributing/adding-glossary-terms)
diff --git a/public/content/translations/te/governance/index.md b/public/content/translations/te/governance/index.md
new file mode 100644
index 00000000000..ab5dd5cd36a
--- /dev/null
+++ b/public/content/translations/te/governance/index.md
@@ -0,0 +1,184 @@
+---
+title: "ఇతిరియం పాలన"
+description: "ఇతిరియం లో నిర్ణయాలు ఎలా తీసుకుంటారు అనే దాని పై ఉదాహరణ."
+lang: te
+---
+
+# Ethereum పాలనకు పరిచయం {#introduction}
+
+_Ethereum ఎవరి సొంతం కానప్పుడు, Ethereumకు సంబంధించిన గత మరియు భవిష్యత్ మార్పుల గురించి నిర్ణయాలు ఎలా తీసుకుంటారు?_ Ethereum పాలన అనేది అటువంటి నిర్ణయాలు తీసుకోవడానికి అనుమతించే ప్రక్రియను సూచిస్తుంది._
+
+<Divider />
+
+## పాలన అంటే ఏంటి? {#what-is-governance}
+
+పాలన అనేది నిర్ణయాలు తీసుకోవడానికి అనుమతించే వ్యవస్థలు. ఒక మామూలు సంస్థలో, ఎగ్జిక్యూటీవ్ టీమ్ లేదా ఒక బోర్డు అఫ్ డైరెక్టర్స్ కి నిర్ణయాల యొక్క తుదితీర్పు ఇస్తారు. లేదా షేర్ హోల్డర్స్ ప్రతిపాదనల పై ఓటు వేస్తారు. రాజకీయ వ్యవస్థలో, ఎన్నుకోబడిన అధికారులు తమ నియోజకవర్గాల కోరికలను సూచించే చట్టాన్ని రూపొందించవచ్చు.
+
+## వికేంద్రీకృత పాలన {#decentralized-governance}
+
+ఏ ఒక్క వ్యక్తి గాని లేదా సంస్థ గాని ఇతిరియం ని కంట్రోల్ గాని అధీనం లోకి గాని తీసుకోలేరు, కానీ నెట్‌వర్క్ యొక్క దీర్ఘాయువు మరియు శ్రేయస్సును ఉత్తమంగా నిర్ధారించడానికి మార్పులను అమలు చేయడం గురించి ఇంకా నిర్ణయాలు తీసుకోవలసిన అవసరం ఉంది. ఈ యాజమాన్యం లేకపోవడం సాంప్రదాయ సంస్థాగత పాలనను అననుకూల పరిష్కారంగా చేస్తుంది.
+
+## Ethereum పాలన {#ethereum-governance}
+
+ఇతిరియం పాలన అనేది ఒక ప్రక్రియ దాని ద్వారా ప్రోటోకాల్ లో ఏ మార్పులు తీసుకురావాలి అనేది చేస్తారు. మనం గుర్తుపెట్టుకోవాల్సిన పాయింట్ ఏంటి అంటే ఈ ప్రక్రియ ప్రజలు మరియు అప్లికేషన్స్ ప్రోటోకాల్ ఎలా ఉపయోగిస్తున్నాయి అని కాదు - ఇతిరియం పర్మిషన్ లెస్. ప్రపంచంలో ఎక్కడి నుండైనా ఎవరైనా ఆన్‌చైన్ కార్యకలాపాలలో పాల్గొనవచ్చు. అప్లికేషన్‌ను ఎవరు నిర్మించగలరు లేదా లావాదేవీని పంపగలరు అనేదానికి ఎలాంటి నియమాలు నిర్దేశించబడలేదు. అయితే, ప్రధాన ప్రోటోకాల్‌కు మార్పులను ప్రతిపాదించడానికి ఒక ప్రక్రియ ఉంది, దానిపై వికేంద్రీకృత అప్లికేషన్లు నడుస్తాయి. చాలా మంది Ethereum యొక్క స్థిరత్వంపై ఆధారపడి ఉన్నందున, Ethereumకు చేసే ఏవైనా మార్పులు సురక్షితంగా ఉన్నాయని మరియు సమాజం నుండి విస్తృత మద్దతు ఉందని నిర్ధారించడానికి, సామాజిక మరియు సాంకేతిక ప్రక్రియలతో సహా ప్రధాన మార్పులకు చాలా ఎక్కువ సమన్వయ పరిమితి ఉంది.
+
+### ఆన్‌చైన్ వర్సెస్ ఆఫ్‌చైన్ పాలన {#onchain-vs-offchain}
+
+బ్లాక్‌చైన్ సాంకేతికత కొత్త పాలన సామర్థ్యాలను అనుమతిస్తుంది, దీనిని ఆన్‌చైన్ పాలన అని పిలుస్తారు. ప్రతిపాదిత ప్రోటోకాల్ మార్పులను వాటాదారుల ఓటు ద్వారా, సాధారణంగా పాలన టోకెన్ హోల్డర్ల ద్వారా నిర్ణయించినప్పుడు మరియు ఓటింగ్ బ్లాక్‌చైన్‌లో జరిగినప్పుడు దానిని ఆన్‌చైన్ పాలన అంటారు. ఆన్‌చైన్ పాలన యొక్క కొన్ని రూపాలలో, ప్రతిపాదిత ప్రోటోకాల్ మార్పులు ఇప్పటికే కోడ్‌లో వ్రాయబడి ఉంటాయి మరియు వాటాదారులు లావాదేవీపై సంతకం చేయడం ద్వారా మార్పులను ఆమోదిస్తే అవి స్వయంచాలకంగా అమలు చేయబడతాయి.
+
+దీనికి వ్యతిరేక విధానమైన ఆఫ్‌చైన్ పాలనలో, ఏవైనా ప్రోటోకాల్ మార్పు నిర్ణయాలు సామాజిక చర్చ యొక్క అనధికారిక ప్రక్రియ ద్వారా జరుగుతాయి, అవి ఆమోదం పొందితే, కోడ్‌లో అమలు చేయబడతాయి.
+
+**Ethereum పాలన ఆఫ్‌చైన్‌లో జరుగుతుంది**, ఈ ప్రక్రియలో అనేక రకాల వాటాదారులు పాల్గొంటారు.
+
+_ప్రోటోకాల్ స్థాయిలో Ethereum పాలన ఆఫ్‌చైన్‌లో ఉన్నప్పటికీ, DAOs వంటి Ethereum పైన నిర్మించిన అనేక వినియోగ సందర్భాలు ఆన్‌చైన్ పాలనను ఉపయోగిస్తాయి._
+
+<ButtonLink href="/dao/">
+  DAOsపై మరింత
+</ButtonLink>
+
+<Divider />
+
+## ఎవరు పాల్గొంటారు? {#who-is-involved}
+
+[Ethereum కమ్యూనిటీ](/community/)లో వివిధ వాటాదారులు ఉన్నారు, ప్రతి ఒక్కరూ పాలన ప్రక్రియలో ఒక పాత్ర పోషిస్తారు. ప్రోటోకాల్ నుండి అత్యంత దూరంలో ఉన్న వాటాదారుల నుండి ప్రారంభించి, దగ్గరగా చూస్తే, మనకు ఈ క్రింది వారు ఉన్నారు:
+
+- **ఈథర్ హోల్డర్లు**: ఈ వ్యక్తులు ఏకపక్ష మొత్తంలో ETHను కలిగి ఉంటారు. [ETHపై మరింత](/what-is-ether/).
+- **అప్లికేషన్ వినియోగదారులు**: ఈ వ్యక్తులు Ethereum బ్లాక్‌చైన్‌లోని అప్లికేషన్‌లతో సంకర్షణ చెందుతారు.
+- **అప్లికేషన్/టూలింగ్ డెవలపర్లు**: ఈ వ్యక్తులు Ethereum బ్లాక్‌చైన్‌లో నడిచే అప్లికేషన్‌లను వ్రాస్తారు (ఉదా., DeFi, NFTలు, మొదలైనవి) లేదా Ethereumతో సంకర్షణ చెందడానికి టూలింగ్‌ను నిర్మిస్తారు (ఉదా., వాలెట్లు, పరీక్ష సూట్‌లు, మొదలైనవి). [డాప్స్‌పై మరింత](/apps/).
+- **నోడ్ ఆపరేటర్లు**: ఈ వ్యక్తులు బ్లాక్‌లు మరియు లావాదేవీలను ప్రచారం చేసే నోడ్‌లను నడుపుతారు, తమకు ఎదురయ్యే ఏదైనా చెల్లని లావాదేవీని లేదా బ్లాక్‌ను తిరస్కరిస్తారు. [నోడ్‌లపై మరింత](/developers/docs/nodes-and-clients/).
+- **EIP రచయితలు**: ఈ వ్యక్తులు Ethereum ప్రోటోకాల్‌కు, Ethereum ఇంప్రూవ్‌మెంట్ ప్రపోజల్స్ (EIPలు) రూపంలో మార్పులను ప్రతిపాదిస్తారు. [EIPలపై మరింత](/eips/).
+- **వాలిడేటర్లు**: ఈ వ్యక్తులు Ethereum బ్లాక్‌చైన్‌కు కొత్త బ్లాక్‌లను జోడించగల నోడ్‌లను నడుపుతారు.
+- **ప్రోటోకాల్ డెవలపర్లు** (a.k.a. "కోర్ డెవలపర్లు" ): ఈ వ్యక్తులు వివిధ Ethereum అమలులను నిర్వహిస్తారు (ఉదా., ఎగ్జిక్యూషన్ లేయర్‌లో go-ethereum, Nethermind, Besu, Erigon, Reth లేదా ఏకాభిప్రాయం లేయర్‌లో Prysm, Lighthouse, Nimbus, Teku, Lodestar, Grandine). [Ethereum క్లయింట్‌లపై మరింత](/developers/docs/nodes-and-clients/).
+
+_గమనిక: ఏ వ్యక్తి అయినా ఈ సమూహాలలో ఒకదాని కంటే ఎక్కువ వాటిలో భాగం కావచ్చు (ఉదా., ఒక ప్రోటోకాల్ డెవలపర్ ఒక EIPకి మద్దతు ఇవ్వవచ్చు మరియు ఒక బీకాన్ చైన్ వాలిడేటర్‌ను నడపవచ్చు మరియు DeFi అప్లికేషన్‌లను ఉపయోగించవచ్చు). అయినప్పటికీ, భావనాత్మక స్పష్టత కోసం, వాటి మధ్య తేడాలను గుర్తించడం సులభం._
+
+<Divider />
+
+## EIP అంటే ఏమిటి? {#what-is-an-eip}
+
+Ethereum పాలనలో ఉపయోగించే ఒక ముఖ్యమైన ప్రక్రియ **Ethereum ఇంప్రూవ్‌మెంట్ ప్రపోజల్స్ (EIPలు)** యొక్క ప్రతిపాదన. EIPలు Ethereum కోసం సంభావ్య కొత్త ఫీచర్లు లేదా ప్రక్రియలను నిర్దేశించే ప్రమాణాలు. Ethereum కమ్యూనిటీలోని ఎవరైనా ఒక EIPని సృష్టించవచ్చు. మీరు ఒక EIP వ్రాయడంలో లేదా పీర్-రివ్యూ మరియు/లేదా పాలనలో పాల్గొనడంలో ఆసక్తి కలిగి ఉంటే, చూడండి:
+
+<ButtonLink href="/eips/">
+  EIPలపై మరింత
+</ButtonLink>
+
+<Divider />
+
+## అధికారిక ప్రక్రియ {#formal-process}
+
+Ethereum ప్రోటోకాల్‌కు మార్పులను పరిచయం చేసే అధికారిక ప్రక్రియ క్రింది విధంగా ఉంటుంది:
+
+1. **ఒక కోర్ EIPని ప్రతిపాదించండి**: [EIP-1](https://eips.ethereum.org/EIPS/eip-1#core-eips)లో వివరించినట్లుగా, Ethereumకు ఒక మార్పును అధికారికంగా ప్రతిపాదించడంలోని మొదటి దశ, దానిని ఒక కోర్ EIPలో వివరించడం. ఇది ప్రోటోకాల్ డెవలపర్లు ఆమోదిస్తే అమలు చేసే EIP కోసం అధికారిక స్పెసిఫికేషన్‌గా పనిచేస్తుంది.
+
+2. **మీ EIPని ప్రోటోకాల్ డెవలపర్‌లకు సమర్పించండి**: మీరు కమ్యూనిటీ ఇన్‌పుట్ సేకరించిన కోర్ EIPని కలిగి ఉన్న తర్వాత, మీరు దానిని ప్రోటోకాల్ డెవలపర్‌లకు సమర్పించాలి. మీరు [AllCoreDevs కాల్](https://github.com/ethereum/execution-specs/tree/master/network-upgrades#getting-the-considered-for-inclusion-cfi-status)లో చర్చ కోసం ప్రతిపాదించడం ద్వారా అలా చేయవచ్చు. [Ethereum Magician's ఫోరమ్](https://ethereum-magicians.org/)లో లేదా [Ethereum R&D డిస్కార్డ్](https://discord.gg/mncqtgVSVw)లో ఇప్పటికే కొన్ని చర్చలు అసమకాలికంగా జరిగి ఉండే అవకాశం ఉంది.
+
+> ఈ దశ యొక్క సంభావ్య ఫలితాలు:
+
+> - భవిష్యత్ నెట్‌వర్క్ అప్‌గ్రేడ్ కోసం EIP పరిగణించబడుతుంది
+> - సాంకేతిక మార్పులు అభ్యర్థించబడతాయి
+> - ఇది ప్రాధాన్యత కానట్లయితే లేదా అభివృద్ధి ప్రయత్నంతో పోలిస్తే మెరుగుదల తగినంత పెద్దది కానట్లయితే అది తిరస్కరించబడవచ్చు
+
+3. **తుది ప్రతిపాదన వైపు పునరావృతం చేయండి:** సంబంధిత వాటాదారులందరి నుండి అభిప్రాయాన్ని స్వీకరించిన తర్వాత, మీరు దాని భద్రతను మెరుగుపరచడానికి లేదా వివిధ వినియోగదారుల అవసరాలను మెరుగ్గా తీర్చడానికి మీ ప్రారంభ ప్రతిపాదనకు మార్పులు చేయవలసి ఉంటుంది. మీ EIP అవసరమని మీరు విశ్వసించే అన్ని మార్పులను పొందుపరిచిన తర్వాత, మీరు దానిని మళ్లీ ప్రోటోకాల్ డెవలపర్‌లకు సమర్పించాల్సి ఉంటుంది. అప్పుడు మీరు ఈ ప్రక్రియ యొక్క తదుపరి దశకు వెళతారు, లేదా కొత్త ఆందోళనలు తలెత్తుతాయి, దీనికి మీ ప్రతిపాదనపై మరో రౌండ్ పునరావృత్తులు అవసరం.
+
+4. **నెట్‌వర్క్ అప్‌గ్రేడ్‌లో చేర్చబడిన EIP**: EIP ఆమోదించబడి, పరీక్షించబడి, అమలు చేయబడిందని అనుకుంటే, అది నెట్‌వర్క్ అప్‌గ్రేడ్‌లో భాగంగా షెడ్యూల్ చేయబడుతుంది. నెట్‌వర్క్ అప్‌గ్రేడ్‌ల యొక్క అధిక సమన్వయ ఖర్చులను బట్టి (ప్రతి ఒక్కరూ ఏకకాలంలో అప్‌గ్రేడ్ చేయాలి), EIPలు సాధారణంగా అప్‌గ్రేడ్‌లలో కలిసి కట్టబడతాయి.
+
+5. **నెట్‌వర్క్ అప్‌గ్రేడ్ సక్రియం చేయబడింది**: నెట్‌వర్క్ అప్‌గ్రేడ్ సక్రియం చేయబడిన తర్వాత, EIP Ethereum నెట్‌వర్క్‌లో ప్రత్యక్ష ప్రసారం చేయబడుతుంది. _గమనిక: నెట్‌వర్క్ అప్‌గ్రేడ్‌లు సాధారణంగా Ethereum మెయిన్‌నెట్‌లో యాక్టివేట్ కావడానికి ముందు టెస్ట్‌నెట్‌లలో యాక్టివేట్ చేయబడతాయి._
+
+ఈ ప్రవాహం, చాలా సరళీకృతం చేయబడినప్పటికీ, Ethereumలో ప్రోటోకాల్ మార్పు సక్రియం కావడానికి ముఖ్యమైన దశల యొక్క అవలోకనాన్ని అందిస్తుంది. ఇప్పుడు, ఈ ప్రక్రియలో అనధికారిక కారకాలను చూద్దాం.
+
+## అనధికారిక ప్రక్రియ {#informal-process}
+
+### మునుపటి పనిని అర్థం చేసుకోవడం {#prior-work}
+
+Ethereum మెయిన్‌నెట్‌లో అమలు కోసం తీవ్రంగా పరిగణించబడే EIPని సృష్టించే ముందు EIP ఛాంపియన్‌లు మునుపటి పని మరియు ప్రతిపాదనలతో తమను తాము పరిచయం చేసుకోవాలి. ఈ విధంగా, EIP ఇంతకు ముందు తిరస్కరించబడని కొత్తదాన్ని తీసుకువస్తుందని ఆశిస్తున్నాము. దీనిపై పరిశోధన చేయడానికి మూడు ప్రధాన ప్రదేశాలు [EIP రిపోజిటరీ](https://github.com/ethereum/EIPs), [Ethereum Magicians](https://ethereum-magicians.org/) మరియు [ethresear.ch](https://ethresear.ch/).
+
+### కార్యనిర్వాహక బృందాలు {#working-groups}
+
+సవరణలు లేదా మార్పులు లేకుండా EIP యొక్క ప్రారంభ ముసాయిదా Ethereum మెయిన్‌నెట్‌లో అమలు చేయబడే అవకాశం లేదు. సాధారణంగా, EIP ఛాంపియన్‌లు తమ ప్రతిపాదనను పేర్కొనడానికి, అమలు చేయడానికి, పరీక్షించడానికి, పునరావృతం చేయడానికి మరియు ఖరారు చేయడానికి ప్రోటోకాల్ డెవలపర్‌ల ఉపసమితితో పని చేస్తారు. చారిత్రాత్మకంగా, ఈ కార్యనిర్వాహక బృందాలకు చాలా నెలలు (మరియు కొన్నిసార్లు సంవత్సరాలు!) అవసరం. పని అవసరం. అదేవిధంగా, అటువంటి మార్పుల కోసం EIP ఛాంపియన్‌లు తుది-వినియోగదారు అభిప్రాయాన్ని సేకరించడానికి మరియు ఏవైనా విస్తరణ ప్రమాదాలను తగ్గించడానికి వారి ప్రయత్నాలలో సంబంధిత అప్లికేషన్/టూలింగ్ డెవలపర్‌లను ముందుగానే చేర్చుకోవాలి.
+
+### కమ్యూనిటీ ఏకాభిప్రాయం {#community-consensus}
+
+కొన్ని EIPలు కనీస సూక్ష్మ నైపుణ్యంతో సూటిగా ఉండే సాంకేతిక మెరుగుదలలు అయితే, కొన్ని మరింత క్లిష్టంగా ఉంటాయి మరియు వివిధ వాటాదారులను వివిధ మార్గాల్లో ప్రభావితం చేసే లాభనష్టాలతో వస్తాయి. దీని అర్థం కొన్ని EIPలు ఇతరులకన్నా సమాజంలో ఎక్కువ వివాదాస్పదంగా ఉంటాయి.
+
+వివాదాస్పద ప్రతిపాదనలను ఎలా నిర్వహించాలనే దానిపై స్పష్టమైన ప్లేబుక్ లేదు. ఇది Ethereum యొక్క వికేంద్రీకృత రూపకల్పన ఫలితంగా ఉంది, దీని ద్వారా ఏ ఒక్క వాటాదారుల సమూహం కూడా మరొకరిని బలవంతంగా నిర్బంధించదు: ప్రోటోకాల్ డెవలపర్లు కోడ్ మార్పులను అమలు చేయకుండా ఎంచుకోవచ్చు; నోడ్ ఆపరేటర్లు తాజా Ethereum క్లయింట్‌ను నడపకుండా ఎంచుకోవచ్చు; అప్లికేషన్ బృందాలు మరియు వినియోగదారులు చైన్‌లో లావాదేవీలు జరపకుండా ఎంచుకోవచ్చు. ప్రజలను నెట్‌వర్క్ అప్‌గ్రేడ్‌లను స్వీకరించమని బలవంతం చేసే మార్గం ప్రోటోకాల్ డెవలపర్‌లకు లేనందున, వివాదాస్పదత విస్తృత సమాజానికి కలిగే ప్రయోజనాలను మించినప్పుడు వారు సాధారణంగా EIPలను అమలు చేయడాన్ని నివారిస్తారు.
+
+EIP ఛాంపియన్‌లు సంబంధిత వాటాదారులందరి నుండి అభిప్రాయాన్ని అభ్యర్థించాలని ఆశించబడుతుంది. మీరు వివాదాస్పద EIP యొక్క ఛాంపియన్‌గా మిమ్మల్ని మీరు కనుగొంటే, మీ EIP చుట్టూ ఏకాభిప్రాయం నిర్మించడానికి అభ్యంతరాలను పరిష్కరించడానికి ప్రయత్నించాలి. Ethereum కమ్యూనిటీ యొక్క పరిమాణం మరియు వైవిధ్యం దృష్ట్యా, కమ్యూనిటీ ఏకాభిప్రాయాన్ని అంచనా వేయడానికి ఉపయోగపడే ఒక్క కొలమానం (ఉదా., ఒక కాయిన్ ఓటు) లేదు, మరియు EIP ఛాంపియన్‌లు వారి ప్రతిపాదన యొక్క పరిస్థితులకు అనుగుణంగా మారతారని భావిస్తున్నారు.
+
+Ethereum నెట్‌వర్క్ భద్రతకు మించి, ప్రోటోకాల్ డెవలపర్లు చారిత్రాత్మకంగా అప్లికేషన్/టూలింగ్ డెవలపర్లు మరియు అప్లికేషన్ వినియోగదారులు దేనికి విలువ ఇస్తారో దానిపై గణనీయమైన ప్రాధాన్యత ఇచ్చారు, ఎందుకంటే వారు Ethereumలో ఉపయోగించడం మరియు అభివృద్ధి చేయడం పర్యావరణ వ్యవస్థను ఇతర వాటాదారులకు ఆకర్షణీయంగా చేస్తుంది. అదనంగా, EIPలను అన్ని క్లయింట్ అమలులలో అమలు చేయాలి, వీటిని విభిన్న బృందాలు నిర్వహిస్తాయి. ఈ ప్రక్రియలో భాగంగా సాధారణంగా ఒక నిర్దిష్ట మార్పు విలువైనదని మరియు అది తుది-వినియోగదారులకు సహాయపడుతుందని లేదా భద్రతా సమస్యను పరిష్కరిస్తుందని ప్రోటోకాల్ డెవలపర్‌ల యొక్క బహుళ బృందాలను ఒప్పించడం ఉంటుంది.
+
+<Divider />
+
+## అసమ్మతులను నిర్వహించడం {#disagreements}
+
+విభిన్న ప్రేరణలు మరియు నమ్మకాలతో చాలా మంది వాటాదారులు ఉండటం అంటే అసమ్మతులు అసాధారణం కాదు.
+
+సాధారణంగా, సమస్య యొక్క మూలాన్ని అర్థం చేసుకోవడానికి మరియు ఎవరైనా జోక్యం చేసుకోవడానికి అనుమతించడానికి బహిరంగ వేదికలలో సుదీర్ఘ చర్చతో అసమ్మతులు నిర్వహించబడతాయి. సాధారణంగా, ఒక సమూహం అంగీకరిస్తుంది, లేదా ఒక సంతోషకరమైన మాధ్యమం సాధించబడుతుంది. ఒక సమూహం బలంగా భావిస్తే, ఒక నిర్దిష్ట మార్పును బలవంతం చేయడం చైన్ స్ప్లిట్‌కు దారితీయవచ్చు. కొంతమంది వాటాదారులు ఒక ప్రోటోకాల్ మార్పును అమలు చేయడాన్ని నిరసించినప్పుడు ఒక చైన్ స్ప్లిట్ జరుగుతుంది, దీని ఫలితంగా ప్రోటోకాల్ యొక్క విభిన్న, అననుకూల సంస్కరణలు పనిచేస్తాయి, దాని నుండి రెండు వేర్వేరు బ్లాక్‌చైన్‌లు ఉద్భవిస్తాయి.
+
+### DAO ఫోర్క్ {#dao-fork}
+
+నెట్‌వర్క్‌కు ప్రధాన సాంకేతిక అప్‌గ్రేడ్‌లు లేదా మార్పులు చేయవలసి వచ్చినప్పుడు మరియు ప్రోటోకాల్ యొక్క "నియమాలను" మార్చినప్పుడు ఫోర్క్‌లు జరుగుతాయి. [Ethereum క్లయింట్లు](/developers/docs/nodes-and-clients/) కొత్త ఫోర్క్ నియమాలను అమలు చేయడానికి వారి సాఫ్ట్‌వేర్‌ను నవీకరించాలి.
+
+[2016 DAO దాడి](https://www.coindesk.com/learn/understanding-the-dao-attack)కి ప్రతిస్పందనగా DAO ఫోర్క్ జరిగింది, ఇక్కడ ఒక అసురక్షిత [DAO](/glossary/#dao) కాంట్రాక్ట్ ఒక హ్యాక్‌లో 3.6 మిలియన్ ETH కంటే ఎక్కువ హరించబడింది. ఈ ఫోర్క్ నిధులను తప్పు కాంట్రాక్ట్ నుండి కొత్త కాంట్రాక్ట్‌కు తరలించింది, హ్యాక్‌లో నిధులను కోల్పోయిన ఎవరైనా వాటిని తిరిగి పొందటానికి అనుమతిస్తుంది.
+
+ఈ చర్యకు Ethereum కమ్యూనిటీ ఓటు వేసింది. ఏదైనా ETH హోల్డర్ [ఒక ఓటింగ్ ప్లాట్‌ఫారమ్](https://web.archive.org/web/20170620030820/http://v1.carbonvote.com/)లో లావాదేవీ ద్వారా ఓటు వేయగలిగారు. ఫోర్క్ చేయాలనే నిర్ణయం 85% కంటే ఎక్కువ ఓట్లను చేరుకుంది.
+
+హ్యాక్‌ను రద్దు చేయడానికి ప్రోటోకాల్ ఫోర్క్ చేసినప్పటికీ, ఫోర్క్ చేయాలని నిర్ణయించడంలో ఓటు మోసిన బరువు కొన్ని కారణాల వల్ల చర్చనీయాంశమని గమనించడం ముఖ్యం:
+
+- ఓటు వేయడానికి వచ్చిన వారి సంఖ్య చాలా తక్కువగా ఉంది
+- చాలా మందికి ఓటింగ్ జరుగుతోందని తెలియదు
+- ఓటు కేవలం ETH హోల్డర్లకు మాత్రమే ప్రాతినిధ్యం వహించింది, సిస్టమ్‌లోని ఇతర పాల్గొనేవారికి కాదు
+
+DAO సంఘటన ప్రోటోకాల్‌లో లోపం కాదని వారు భావించినందున, సంఘంలోని ఒక ఉపసమితి ఫోర్క్ చేయడానికి నిరాకరించింది. వారు [Ethereum Classic](https://ethereumclassic.org/)ని ఏర్పాటు చేశారు.
+
+ఈ రోజు, సిస్టమ్ యొక్క విశ్వసనీయ తటస్థతను కొనసాగించడానికి కాంట్రాక్ట్ బగ్‌లు లేదా కోల్పోయిన నిధుల విషయంలో జోక్యం చేసుకోని విధానాన్ని Ethereum కమ్యూనిటీ అవలంబించింది.
+
+DAO హ్యాక్‌పై మరిన్ని చూడండి:
+
+<YouTube id="rNeLuBOVe8A" />
+
+<Divider />
+
+### ఫోర్కింగ్ యొక్క ప్రయోజనం {#forking-utility}
+
+Ethereum/Ethereum Classic ఫోర్క్ ఆరోగ్యకరమైన ఫోర్క్‌కు అద్భుతమైన ఉదాహరణ. తమ నిర్దిష్ట చర్యలను కొనసాగించడానికి ఎదురయ్యే నష్టాలకు ఇది విలువైనదని భావించేంత బలంగా కొన్ని ప్రధాన విలువలపై ఒకరితో ఒకరు విభేదించిన రెండు సమూహాలు మాకు ఉన్నాయి.
+
+గణనీయమైన రాజకీయ, తాత్విక లేదా ఆర్థిక విభేదాల నేపథ్యంలో ఫోర్క్ చేయగల సామర్థ్యం Ethereum పాలన విజయంలో పెద్ద పాత్ర పోషిస్తుంది. ఫోర్క్ చేయగల సామర్థ్యం లేకుండా, ప్రత్యామ్నాయం నిరంతర అంతర్గత పోరాటం, చివరికి Ethereum క్లాసిక్‌ను ఏర్పాటు చేసిన వారికి బలవంతంగా అయిష్టంగా పాల్గొనడం మరియు Ethereum కోసం విజయం ఎలా ఉంటుందనే దానిపై పెరుగుతున్న విభిన్న దృష్టి.
+
+<Divider />
+
+## బీకాన్ చైన్ పాలన {#beacon-chain}
+
+Ethereum పాలన ప్రక్రియ తరచుగా నిష్కాపట్యత మరియు చేరిక కోసం వేగం మరియు సామర్థ్యాన్ని త్యాగం చేస్తుంది. బీకాన్ చైన్ అభివృద్ధిని వేగవంతం చేయడానికి, ఇది ప్రూఫ్-ఆఫ్-వర్క్ Ethereum నెట్‌వర్క్ నుండి విడిగా ప్రారంభించబడింది మరియు దాని స్వంత పాలన పద్ధతులను అనుసరించింది.
+
+స్పెసిఫికేషన్ మరియు డెవలప్‌మెంట్ ఇంప్లిమెంటేషన్‌లు ఎల్లప్పుడూ పూర్తిగా ఓపెన్ సోర్స్‌గా ఉన్నప్పటికీ, పైన వివరించిన నవీకరణలను ప్రతిపాదించడానికి ఉపయోగించే అధికారిక ప్రక్రియలు ఉపయోగించబడలేదు. ఇది పరిశోధకులు మరియు అమలు చేసేవారిచే మార్పులను వేగంగా పేర్కొనడానికి మరియు అంగీకరించడానికి అనుమతించింది.
+
+సెప్టెంబర్ 15, 2022న బీకాన్ చైన్ Ethereum ఎగ్జిక్యూషన్ లేయర్‌తో విలీనమైనప్పుడు, [పారిస్ నెట్‌వర్క్ అప్‌గ్రేడ్](/ethereum-forks/#paris)లో భాగంగా ది మెర్జ్ పూర్తయింది. [EIP-3675](https://eips.ethereum.org/EIPS/eip-3675) ప్రతిపాదన 'లాస్ట్ కాల్' నుండి 'ఫైనల్'గా మార్చబడింది, ప్రూఫ్-ఆఫ్-స్టేక్‌కు పరివర్తనను పూర్తి చేసింది.
+
+<ButtonLink href="/roadmap/merge/">
+  ది మెర్జ్‌పై మరింత
+</ButtonLink>
+
+<Divider />
+
+## నేను ఎలా పాలుపంచుకోవచ్చు? {#get-involved}
+
+- [ఒక EIPని ప్రతిపాదించండి](/eips/#participate)
+- [ప్రస్తుత ప్రతిపాదనలను చర్చించండి](https://ethereum-magicians.org/)
+- [R&D చర్చలో పాల్గొనండి](https://ethresear.ch/)
+- [Ethereum R&D డిస్కార్డ్‌లో చేరండి](https://discord.gg/mncqtgVSVw)
+- [ఒక నోడ్‌ను నడపండి](/developers/docs/nodes-and-clients/run-a-node/)
+- [క్లయింట్ అభివృద్ధికి సహకరించండి](/developers/docs/nodes-and-clients/#execution-clients)
+- [కోర్ డెవలపర్ అప్రెంటిస్‌షిప్ ప్రోగ్రామ్](https://blog.ethereum.org/2021/09/06/core-dev-apprenticeship-second-cohort/)
+
+## మరింత సమాచారం {#further-reading}
+
+Ethereumలో పాలన కఠినంగా నిర్వచించబడలేదు. వివిధ కమ్యూనిటీ పాల్గొనేవారికి దానిపై విభిన్న దృక్కోణాలు ఉన్నాయి. వాటిలో కొన్ని ఇక్కడ ఉన్నాయి:
+
+- [బ్లాక్‌చైన్ పాలనపై గమనికలు](https://vitalik.eth.limo/general/2017/12/17/voting.html) - _విటాలిక్ బుటెరిన్_
+- [Ethereum పాలన ఎలా పనిచేస్తుంది?](https://cryptotesters.com/blog/ethereum-governance) – _క్రిప్టోటెస్టర్స్_
+- [Ethereum పాలన ఎలా పనిచేస్తుంది](https://medium.com/coinmonks/how-ethereum-governance-works-71856426b63a) – _Micah Zoltu_
+- [Ethereum కోర్ డెవలపర్ అంటే ఏమిటి?](https://hudsonjameson.com/2020-06-22-what-is-an-ethereum-core-developer/) - _హడ్సన్ జేమ్సన్_
+- [పాలన, భాగం 2: ప్లూటోక్రసీ ఇంకా చెడ్డది](https://vitalik.eth.limo/general/2018/03/28/plutocracy.html) - _విటాలిక్ బుటెరిన్_
+- [కాయిన్ ఓటింగ్ పాలనను దాటి వెళ్లడం](https://vitalik.eth.limo/general/2021/08/16/voting3.html) - _విటాలిక్ బుటెరిన్_
+- [బ్లాక్‌చైన్ పాలనను అర్థం చేసుకోవడం](https://web.archive.org/web/20250124192731/https://research.2077.xyz/understanding-blockchain-governance) - _2077 రీసెర్చ్_
+- [ది Ethereum గవర్నమెంట్](https://www.galaxy.com/insights/research/ethereum-governance/) - _క్రిస్టీన్ కిమ్_
diff --git a/public/content/translations/te/guides/how-to-create-an-ethereum-account/index.md b/public/content/translations/te/guides/how-to-create-an-ethereum-account/index.md
new file mode 100644
index 00000000000..e0b98c6e6a7
--- /dev/null
+++ b/public/content/translations/te/guides/how-to-create-an-ethereum-account/index.md
@@ -0,0 +1,75 @@
+---
+title: "ఒక Ethereum అకౌంట్ \"తయారీ\" చేయటం ఎలా"
+description: "వాలెట్ తో ఒక ఇతిరియం అకౌంట్ ఎలా తాయారు చేసుకోవాలో ఒక స్టెప్ బై స్టెప్ మార్గదర్శకం."
+lang: te
+---
+
+# ఒక Ethereum అకౌంట్‌ను ఎలా తాయారు చేసుకోవాలి
+
+**ఎవరైనా ఉచితంగా Ethereum ఖాతాను సృష్టించుకోవచ్చు.** మీరు క్రిప్టో వాలెట్ యాప్‌ను ఇన్‌స్టాల్ చేసుకుంటే చాలు. వాలెట్లు మీ Ethereum ఖాతాను సృష్టించి, నిర్వహిస్తాయి. అవి లావాదేవీలను పంపగలవు, మీ బ్యాలెన్స్‌లను తనిఖీ చేయగలవు మరియు Ethereum మీద నిర్మించిన ఇతర యాప్‌లకు మిమ్మల్ని కనెక్ట్ చేయగలవు.
+
+వాలెట్‌తో మీరు తక్షణమే ఏదైనా టోకెన్ ఎక్స్ఛేంజ్, గేమ్‌లు, [NFT](/glossary/#nft) మార్కెట్‌ప్లేస్‌లలోకి లాగిన్ అవ్వవచ్చు. వ్యక్తిగత రిజిస్ట్రేషన్ అవసరం లేదు, Ethereum మీద నిర్మించిన అన్ని యాప్‌ల కోసం ఒకే ఖాతా భాగస్వామ్యం చేయబడుతుంది.
+
+## స్టెప్ 1: ఒక వాలెట్ ని ఎన్నుకో
+
+వాలెట్ అనేది ఒక అప్ దాని ద్వారా మీరు మీ ఇతిరియం అకౌంట్ ని మేనేజ్ చెయ్యొచ్చు. ఎంచుకోవడానికి డజన్ల కొద్దీ విభిన్న వాలెట్‌లు ఉన్నాయి: మొబైల్, డెస్క్‌టాప్ లేదా బ్రౌజర్ ఎక్స్‌టెన్షన్‌లు కూడా.
+
+<ButtonLink href="/wallets/find-wallet/">
+  వాలెట్‌ల జాబితా
+</ButtonLink>
+
+మీరు ఇందులో కొత్త అయితే, మీరు "క్రిప్టో కి కొత్త" ఫిల్టర్ ని సెలెక్ట్ చేయండి "వాలెట్ వెతకడం" పేజీ లో దాని ద్వారా మీరు ఏమేమి నేర్చుకోవాలి ఏవేవి తెలుసుకోవాలో అన్ని తెలుసుకుంటారు.
+
+![‘వాలెట్‌ను కనుగొనండి’ పేజీలో ఫిల్టర్ ఎంపిక](./wallet-box.png)
+
+ఎన్నో ప్రొఫైల్ ఫిల్టర్లు కూడా ఉన్నాయ్ మీ అవసరాలని తీర్చుకోడానికి. కామన్ గా వాడే వాల్లెట్స్ ఉన్నపటికీ - మీరు మీ స్వతఃగా రీసెర్చ్ చేయండి ఏదైనా కంపెనీ ని నమ్మే ముందు.
+
+## స్టెప్ 2: వాలెట్ ని డౌన్లోడ్ చేసి ఇన్స్టాల్ చేయండి
+
+మీరు ఒక వాలెట్ ని నిశ్చయించి కొని డౌన్లోడ్ చేసి ఇన్స్టాల్ చేయడానికి, వాటి యొక్క ఆఫిసిఅల్ వెబ్సైటు కు గాని లేదా అప్ స్టోర్ ని సంప్రదించండి. అందులో చాలా ఉచితం గానే లభిస్తాయి.
+
+## దశ 3: యాప్‌ను తెరిచి, మీ Ethereum ఖాతాను సృష్టించండి
+
+మీరు మొదట ఓపెన్ చేసేటప్పుడు మీరు కొత్త వాలెట్ తాయారు చేసుకుంటున్నారా లేదా ఉన్న అకౌంట్ ని ఇంపోర్ట్ చేసుకుంటున్నారా అని అడుగుతుంది. కొత్త అకౌంట్ తాయారి పై క్లిక్ చేయండి. **వాలెట్ సాఫ్ట్‌వేర్ మీ Ethereum ఖాతాను రూపొందించే దశ ఇది.**
+
+## స్టెప్ 4: మీ రికవరీ ఫ్రస్ ని పొందు పరచండి
+
+కొన్ని యాప్‌లు మిమ్మల్ని ఒక రహస్య "రికవరీ ఫ్రేజ్" (కొన్నిసార్లు "సీడ్ ఫ్రేజ్" లేదా "నిమోనిక్" అని పిలుస్తారు)ని సేవ్ చేయమని అభ్యర్థిస్తాయి. ఈ పదబంధాన్ని సురక్షితంగా ఉంచడం చాలా ముఖ్యం! ఇది మీ Ethereum ఖాతాను రూపొందించడానికి ఉపయోగించబడుతుంది మరియు లావాదేవీలను సమర్పించడానికి కూడా ఉపయోగించవచ్చు.
+
+**ఆ పదబంధం తెలిసిన ఏ వ్యక్తి అయినా అన్ని నిధులను నియంత్రణలోకి తీసుకోగలడు.** దీన్ని ఎవరితోనూ ఎప్పుడూ పంచుకోవద్దు. ఈ పదబంధంలో యాదృచ్ఛికంగా రూపొందించిన 12 నుండి 24 పదాలు ఉండాలి (పదాల క్రమం ముఖ్యం).
+
+<div>
+<Alert variant="update">
+<AlertEmoji text=":eyes:"/>
+<AlertContent className="flex-row justify-between items-center">
+  <div><b>వాలెట్ ఇన్‌స్టాల్ చేయబడిందా?</b><br/>దానిని ఎలా ఉపయోగించాలో తెలుసుకోండి.</div>
+  <ButtonLink href="/guides/how-to-use-a-wallet">
+    వాలెట్‌ను ఎలా ఉపయోగించాలి
+  </ButtonLink>
+</AlertContent>
+</Alert>
+</div>
+
+ఇతర గైడ్‌లపై ఆసక్తి ఉందా? మా వీటిని చూడండి: [దశల వారీ గైడ్‌లు](/guides/)
+
+## తరచుగా అడిగే ప్రశ్నలు
+
+### నా వాలెట్ మరియు నా ఇతిరియం అకౌంట్ ఒకటేనా?
+
+లేదు. వాలెట్ అనేది ఒక పని ముట్టు లాంటిది దాని ద్వారా మీరు మీ అకౌంట్స్ ని మేనేజ్ చెయ్యొచ్చు. ఒకే వాలెట్ అనేక ఖాతాలను యాక్సెస్ చేయగలదు మరియు ఒకే ఖాతాను బహుళ వాలెట్‌ల ద్వారా యాక్సెస్ చేయవచ్చు. రికవరీ పదబంధం ఖాతాలను సృష్టించడానికి ఉపయోగించబడుతుంది మరియు ఆస్తులను నిర్వహించడానికి వాలెట్ యాప్‌కు అనుమతి ఇస్తుంది.
+
+### నేను బిట్ కాయిన్ ని ఇతిరియం అడ్రస్ కి పంపించొచ్చా, లేదంటే ఇతెర్ ని బిట్ కాయిన్ అడ్రస్ కి పంపించొచ్చా?
+
+లేదు, మీరు చెయ్యలేరు. బిట్‌కాయిన్ మరియు ఈథర్ రెండు వేర్వేరు నెట్‌వర్క్‌లలో (అంటే, వేర్వేరు బ్లాక్‌చైన్‌లు) ఉన్నాయి, ప్రతిదానికి దాని స్వంత బుక్‌కీపింగ్ మరియు చిరునామా ఫార్మాట్‌లు ఉంటాయి. రెండు వేర్వేరు నెట్‌వర్క్‌లను అనుసంధానించడానికి వివిధ ప్రయత్నాలు జరిగాయి, వాటిలో ప్రస్తుతం అత్యంత చురుకైనది [వ్రాప్డ్ బిట్‌కాయిన్ లేదా WBTC](https://www.bitcoin.com/get-started/what-is-wbtc/). ఇది ఒక ఆమోదం కాదు, WBTC అనేది ఒక జవాబు(అంటే ఒక గుంపు లో మనుషులు దాని యొక్క ముఖ్యమైన ఫంక్షన్స్ ని కంట్రోల్ చేస్తారు) మరియు అది ఇక్కడ సమాచారం తెలుసుకోవడం కోసమే ఉంది.
+
+### ఇప్పుడు నా దగ్గర ఇత్ అడ్రస్ ఉంటె, ఇతర బ్లాక్ చైన్ లలో కూడా అదే అడ్రస్ ఉంటాదా?
+
+Ethereum మాదిరిగానే అంతర్లీన సాఫ్ట్‌వేర్‌ను ఉపయోగించే అన్ని బ్లాక్‌చైన్‌లలోనూ మీరు అదే [చిరునామా](/glossary/#address)ను ఉపయోగించవచ్చు (దీనిని 'EVM-అనుకూల' అని పిలుస్తారు). ఈ [జాబితా](https://chainlist.org/) మీరు ఏ బ్లాక్‌చెయిన్‌లను అదే చిరునామాతో ఉపయోగించవచ్చో మీకు చూపుతుంది. కొన్ని బ్లాక్ చైన్లు, ఉదాహరణ కు బిట్ కాయిన్, పూర్తిగా విభిన్న నెట్వర్క్ రూల్స్ ని పాటిస్తాది వాటికోసం మీకు ఇంకో అడ్రస్ ఫార్మటు తో వేరేయ్ అడ్రస్ కావాలి. మీకు స్మార్ట్ కాంట్రాక్ట్ వాలెట్ ఉంటే, ఏ బ్లాక్‌చెయిన్‌లకు మద్దతు ఉందో మరింత సమాచారం కోసం మీరు దాని ఉత్పత్తి వెబ్‌సైట్‌ను తనిఖీ చేయాలి, ఎందుకంటే సాధారణంగా వాటికి పరిమితమైన కానీ మరింత సురక్షితమైన పరిధి ఉంటుంది.
+
+### ఒక ఎక్స్చేంజి లో డబ్బు ఉంచడం కన్నా నా వాలెట్ లో డబ్బు ఉంచడం సురక్షితమేనా?
+
+మీ వాలెట్ మీ దగ్గరే ఉంది అంటే మీ డబ్బు సురక్షితాన్ని మరియు వాటి భాద్యత ని మీరు తీసుకున్నట్టే. దురదృష్టవశాత్తు చాలా ఎక్స్చేంజి లు విఫలం అయ్యి కస్టమర్ల డబ్బు పోగొట్టిన ఉదాహరణలు చాలా ఉన్నాయ్. వాలెట్‌ను (రికవరీ పదబంధంతో) కలిగి ఉండటం వలన మీ ఆస్తులను ఉంచడానికి కొంత సంస్థను విశ్వసించడంతో సంబంధం ఉన్న ప్రమాదాన్ని తొలగిస్తుంది. అయితే, మీరు దానిని మీ స్వంతంగా భద్రపరచుకోవాలి మరియు ఫిషింగ్ స్కామ్‌లు, అనుకోకుండా లావాదేవీలను ఆమోదించడం లేదా రికవరీ పదబంధాన్ని బహిర్గతం చేయడం, నకిలీ వెబ్‌సైట్‌లతో పరస్పర చర్య చేయడం మరియు ఇతర స్వీయ-సంరక్షణ ప్రమాదాలను నివారించాలి. లాభాలు నష్టాలు చాలా విభిన్నం.
+
+### నేను నా ఫోన్ గాని హార్డ్వేర్ వాలెట్ గాని కోల్పోతే, నేను అదే వాలెట్ ని ఉపయోగించి డబ్బు ని రికవర్ చెయ్యొచ్చా?
+
+లేదు, మీరు ఇంకో వాలెట్ ని ఉపయోగించొచ్చు. మీ సీడ్ ఫ్రస్ మీ దగ్గర ఉన్నపటికీ, మీరు ఆ ఫ్రస్ ని ఎన్ని వాల్లెట్స్ లో ఐన కొట్టొచ్చు మరియు అవి మీ అకౌంట్ ని రికవర్ చేస్తాయి. అయినప్పటికీ ఇలా చేసేటప్పుడు జాగ్రతగా ఉండండి: మీరు ఇది చేసేటప్పుడు మీరు ఇంటర్నెట్ కి కనెక్ట్ అవ్వకపోడం మంచిది ఆలా చేస్తే మీ సీడ్ ఫ్రస్ ఆక్సిడెంట్ల్ గా లీక్ అవ్వదు. రికవరీ పదబంధం లేకుండా కోల్పోయిన నిధులను తిరిగి పొందడం చాలాసార్లు అసాధ్యం.
diff --git a/public/content/translations/te/guides/how-to-id-scam-tokens/index.md b/public/content/translations/te/guides/how-to-id-scam-tokens/index.md
new file mode 100644
index 00000000000..dee6bbef355
--- /dev/null
+++ b/public/content/translations/te/guides/how-to-id-scam-tokens/index.md
@@ -0,0 +1,94 @@
+---
+title: "స్కామ్ టోకెన్లను ఎలా గుర్తించాలి"
+description: "స్కామ్ టోకెన్‌లను అర్థం చేసుకోవడం, అవి తమను తాము చట్టబద్ధంగా ఎలా కనిపించేలా చేసుకుంటాయో, మరియు వాటిని ఎలా నివారించాలో."
+lang: te
+---
+
+# స్కామ్ టోకెన్లను ఎలా గుర్తించాలి {#identify-scam-tokens}
+
+Ethereumకు అత్యంత సాధారణ ఉపయోగాలలో ఒకటి ఒక సమూహం వ్యాపారం చేయగల టోకెన్‌ను సృష్టించడం, ఒక రకంగా చెప్పాలంటే వారి స్వంత కరెన్సీ. ఈ టోకెన్‌లు సాధారణంగా [ERC-20](/developers/docs/standards/tokens/erc-20/) ప్రమాణాన్ని అనుసరిస్తాయి. అయినప్పటికీ, చాలా చోట్ల మంచిగా విలువ తెచ్చే విధంగా ఉంటాయి, దీనితో పాటు దొంగలు కూడా దీనిని దొంగతనం చేయాలి అని చూస్తున్నారు అవి వాళ్ళకి విలువ ని ఇస్తాయి.
+
+వాళ్ళు మిమ్మల్ని రెండు విధాలు గా మోసం చేస్తారు:
+
+- **మీకు ఒక స్కామ్ టోకెన్‌ను అమ్మడం**, ఇది మీరు కొనుగోలు చేయాలనుకుంటున్న చట్టబద్ధమైన టోకెన్ లాగా కనిపించవచ్చు, కానీ అవి స్కామర్లచే జారీ చేయబడతాయి మరియు వాటికి ఎటువంటి విలువ ఉండదు.
+- **చెడు లావాదేవీలపై సంతకం చేయడానికి మిమ్మల్ని మోసగించడం**, సాధారణంగా వారి స్వంత యూజర్ ఇంటర్‌ఫేస్‌లోకి మిమ్మల్ని మళ్లించడం ద్వారా. వాళ్ళు మీ దగ్గర ఉన్న ERC-20 టోకెన్స్ ల అలవెన్సు లో మార్పు చేసి, సురక్షితంగా ఉంచాల్సిన విషయాల్ని అధీనం చేసుకుంటారు ఇంకా మరెన్నో చెయ్యగలరు. ఈ వెబ్సైట్లు అచ్చం నిజం వాటిలానే ఉంటాయి, కానీ దాక్కుని ఉంటాయి.
+
+స్కామ్ టోకెన్‌లు అంటే ఏమిటో మరియు వాటిని ఎలా గుర్తించాలో వివరించడానికి, మనం ఒక ఉదాహరణను చూడబోతున్నాము: [`wARB`](https://eth.blockscout.com/token/0xB047c8032b99841713b8E3872F06cF32beb27b82). ఈ టోకెన్ చట్టబద్ధమైన [`ARB`](https://eth.blockscout.com/address/0xb50721bcf8d664c30412cfbc6cf7a15145234ad1) టోకెన్ లాగా కనిపించడానికి ప్రయత్నిస్తుంది.
+
+<ExpandableCard
+title="ARB అంటే ఏమిటి?"
+contentPreview=''>
+
+Arbitrum అనేది [optimistic rollups](/developers/docs/scaling/optimistic-rollups/)ను అభివృద్ధి చేసి, నిర్వహించే ఒక సంస్థ. ప్రారంభంలో, Arbitrum ఒక లాభాపేక్ష సంస్థగా నిర్వహించబడింది, కానీ ఆ తర్వాత వికేంద్రీకరించడానికి చర్యలు తీసుకుంది. ఆ ప్రక్రియలో భాగంగా, వారు వ్యాపారం చేయగల [పాలన టోకెన్](/dao/#token-based-membership)ను జారీ చేశారు.
+</ExpandableCard>
+
+<ExpandableCard
+title="స్కామ్ టోకెన్‌ను wARB అని ఎందుకు పిలుస్తారు?"
+contentPreview=''>
+
+Ethereumలో ఒక సంప్రదాయం ఉంది, ఒక ఆస్తి ERC-20కి అనుగుణంగా లేనప్పుడు, దాని పేరు \"w\"తో ప్రారంభమయ్యే విధంగా మేము దాని యొక్క \"wrapped\" వెర్షన్‌ను సృష్టిస్తాము. కాబట్టి, ఉదాహరణకు, మనకు బిట్‌కాయిన్ కోసం wBTC మరియు <a href="https://cointelegraph.com/news/what-is-wrapped-ethereum-weth-and-how-does-it-work">ether కోసం wETH</a> ఉన్నాయి.
+
+ఇప్పటికే Ethereumలో ఉన్న ERC-20 టోకెన్ యొక్క wrapped వెర్షన్‌ను సృష్టించడం అర్థరహితం, కానీ స్కామర్లు అంతర్లీన వాస్తవికత కంటే చట్టబద్ధత యొక్క రూపాన్ని నమ్ముతారు.
+</ExpandableCard>
+
+## ఈ స్కామ్ టోకెన్లు ఎలా పనిచేస్తాయి? {#how-do-scam-tokens-work}
+
+Ethereum యొక్క ముఖ్య ఉద్దేశ్యం వికేంద్రీకరణ. దీనర్థం, మీ ఆస్తులను జప్తు చేయగల లేదా స్మార్ట్ కాంట్రాక్ట్‌ను అమలు చేయకుండా నిరోధించగల కేంద్ర అధికారం ఏదీ లేదు. కానీ దీని అర్థం స్కామర్లు తమకు నచ్చిన ఏ స్మార్ట్ కాంట్రాక్ట్‌నైనా అమలు చేయగలరు.
+
+<ExpandableCard
+title="స్మార్ట్ కాంట్రాక్టులు అంటే ఏమిటి?"
+contentPreview=''>
+
+[స్మార్ట్ కాంట్రాక్టులు](/developers/docs/smart-contracts/) అనేవి Ethereum బ్లాక్‌చైన్ పైన పనిచేసే ప్రోగ్రామ్‌లు. ఉదాహరణకు, ప్రతి ERC-20 టోకెన్ ఒక స్మార్ట్ కాంట్రాక్ట్‌గా అమలు చేయబడుతుంది.
+</ExpandableCard>
+
+ప్రత్యేకంగా, Arbitrum `ARB` చిహ్నాన్ని ఉపయోగించే ఒక కాంట్రాక్ట్‌ను అమలు చేసింది. కానీ అదే చిహ్నాన్ని లేదా అలాంటిదే వేరొకదాన్ని ఉపయోగించి కాంట్రాక్ట్‌ను అమలు చేయకుండా ఇతరులను ఇది ఆపలేదు. కాంట్రాక్ట్ ఎవరు రాసినా, ఆ కాంట్రాక్ట్ ఏమి చేస్తుందో వారే నిర్ణయిస్తారు.
+
+## చట్టబద్ధంగా కనిపించడం {#appearing-legitimate}
+
+స్కామ్ టోకెన్ సృష్టికర్తలు చట్టబద్ధంగా కనిపించడానికి అనేక ఉపాయాలు చేస్తారు.
+
+- **చట్టబద్ధమైన పేరు మరియు చిహ్నం**. ముందే చెప్పినట్లుగా, ERC-20 కాంట్రాక్టులు ఇతర ERC-20 కాంట్రాక్టుల మాదిరిగానే అదే చిహ్నం మరియు పేరును కలిగి ఉండవచ్చు. భద్రత కోసం మీరు ఆ ఫీల్డ్‌లపై ఆధారపడలేరు.
+
+- **చట్టబద్ధమైన యజమానులు**. స్కామ్ టోకెన్‌లు తరచుగా నిజమైన టోకెన్‌ను చట్టబద్ధంగా కలిగి ఉంటారని ఆశించే చిరునామాలకు గణనీయమైన బ్యాలెన్స్‌లను ఎయిర్‌డ్రాప్ చేస్తాయి.
+
+  ఉదాహరణకు, `wARB`ని మళ్ళీ చూద్దాం. [సుమారు 16% టోకెన్లు](https://eth.blockscout.com/token/0xb047c8032b99841713b8E3872F06cF32beb27b82?tab=holders) ఒక చిరునామా ద్వారా కలిగి ఉన్నాయి, దాని పబ్లిక్ ట్యాగ్ [Arbitrum Foundation: Deployer](https://eth.blockscout.com/address/0x1C8db745ABe3C8162119b9Ef2c13864Cd1FDD72F). ఇది నకిలీ చిరునామా _కాదు_, ఇది నిజంగా Ethereum మెయిన్‌నెట్‌లో [నిజమైన ARB కాంట్రాక్ట్‌ను అమలు చేసిన](https://eth.blockscout.com/tx/0x242b50ab4fe9896cb0439cfe6e2321d23feede7eeceb31aa2dbb46fc06ed2670) చిరునామా.
+
+  ఒక చిరునామా యొక్క ERC-20 బ్యాలెన్స్ ERC-20 కాంట్రాక్ట్ యొక్క స్టోరేజ్‌లో భాగం కాబట్టి, కాంట్రాక్ట్ డెవలపర్ కోరుకున్నట్లుగా దానిని కాంట్రాక్ట్ ద్వారా పేర్కొనవచ్చు. ఒక కాంట్రాక్ట్ బదిలీలను నిషేధించడం కూడా సాధ్యమే, తద్వారా చట్టబద్ధమైన వినియోగదారులు ఆ స్కామ్ టోకెన్‌లను వదిలించుకోలేరు.
+
+- **చట్టబద్ధమైన బదిలీలు**. _చట్టబద్ధమైన యజమానులు స్కామ్ టోకెన్‌ను ఇతరులకు బదిలీ చేయడానికి చెల్లించరు, కాబట్టి బదిలీలు ఉంటే అది చట్టబద్ధమైనది అయి ఉండాలి, సరియైనదేనా?_ **తప్పు**. `Transfer` ఈవెంట్‌లు ERC-20 కాంట్రాక్ట్ ద్వారా ఉత్పత్తి చేయబడతాయి. ఈ స్కామర్లు అతి సులువు గా ఈ కాంట్రాక్టులని అవే ఈవెంట్స్ ని తయారీ చేయగలవు.
+
+## మోసపూరిత వెబ్‌సైట్‌లు {#websites}
+
+స్కామర్లు చాలా నమ్మశక్యంగా ఉండే వెబ్‌సైట్‌లను కూడా సృష్టించగలరు, కొన్నిసార్లు ఒకే రకమైన UIలతో ప్రామాణికమైన సైట్‌ల యొక్క ఖచ్చితమైన క్లోన్‌లను కూడా, కానీ సూక్ష్మమైన ఉపాయాలతో సృష్టిస్తారు. ఉదాహరణకు, చట్టబద్ధంగా కనిపించే బాహ్య లింకులు వాస్తవానికి వినియోగదారుని బాహ్య స్కామ్ సైట్‌కు పంపడం, లేదా వినియోగదారుని వారి కీలను బహిర్గతం చేయడానికి లేదా దాడి చేసేవారి చిరునామాకు నిధులను పంపడానికి మార్గనిర్దేశం చేసే తప్పు సూచనలు కావచ్చు.
+
+దీన్ని నివారించడానికి ఉత్తమ పద్ధతి ఏమిటంటే, మీరు సందర్శించే సైట్‌ల కోసం URLను జాగ్రత్తగా తనిఖీ చేయడం మరియు తెలిసిన ప్రామాణికమైన సైట్‌ల కోసం చిరునామాలను మీ బుక్‌మార్క్‌లలో సేవ్ చేయడం. అప్పుడు, మీరు అనుకోకుండా స్పెల్లింగ్ తప్పులు చేయకుండా లేదా బాహ్య లింక్‌లపై ఆధారపడకుండా మీ బుక్‌మార్క్‌ల ద్వారా నిజమైన సైట్‌ను యాక్సెస్ చేయవచ్చు.
+
+## మిమ్మల్ని మీరు ఎలా రక్షించుకోవాలి? మిమ్మల్ని మీరు రక్షించుకోండి {#protect-yourself}
+
+1. **కాంట్రాక్ట్ చిరునామాను తనిఖీ చేయండి**. చట్టబద్ధమైన టోకెన్‌లు చట్టబద్ధమైన సంస్థల నుండి వస్తాయి, మరియు మీరు ఆ సంస్థ యొక్క వెబ్‌సైట్‌లో కాంట్రాక్ట్ చిరునామాలను చూడవచ్చు. ఉదాహరణకు, [`ARB` కోసం మీరు చట్టబద్ధమైన చిరునామాలను ఇక్కడ చూడవచ్చు](https://docs.arbitrum.foundation/deployment-addresses#token).
+
+2. **నిజమైన టోకెన్లకు ద్రవ్యత ఉంటుంది**. మరొక ఎంపిక అత్యంత సాధారణ టోకెన్ మార్పిడి ప్రోటోకాల్స్‌లో ఒకటైన [Uniswap](https://uniswap.org/)లో లిక్విడిటీ పూల్ పరిమాణాన్ని చూడటం. ఈ ప్రోటోకాల్ లిక్విడిటీ పూల్స్‌ను ఉపయోగించి పనిచేస్తుంది, దీనిలో పెట్టుబడిదారులు ట్రేడింగ్ ఫీజుల నుండి రాబడిని ఆశించి తమ టోకెన్లను డిపాజిట్ చేస్తారు.
+
+స్కామర్లు నిజమైన ఆస్తులను పణంగా పెట్టడానికి ఇష్టపడరు కాబట్టి, స్కామ్ టోకెన్‌లకు సాధారణంగా చాలా చిన్న లిక్విడిటీ పూల్స్ ఉంటాయి, ఏవైనా ఉంటే. ఉదాహరణకు, `ARB`/`ETH` Uniswap పూల్ సుమారుగా ఒక మిలియన్ డాలర్లను కలిగి ఉంది ([తాజా విలువ కోసం ఇక్కడ చూడండి](https://app.uniswap.org/explore#/pools/0x755e5a186f0469583bd2e80d1216e02ab88ec6ca)) మరియు చిన్న మొత్తంలో కొనడం లేదా అమ్మడం ధరను మార్చదు:
+
+![చట్టబద్ధమైన టోకెన్‌ను కొనుగోలు చేయడం](./uniswap-real.png)
+
+కానీ మీరు స్కామ్ టోకెన్ `wARB`ని కొనడానికి ప్రయత్నించినప్పుడు, చిన్న కొనుగోలు కూడా ధరను 90% కంటే ఎక్కువగా మారుస్తుంది:
+
+![స్కామ్ టోకెన్‌ను కొనుగోలు చేయడం](./uniswap-scam.png)
+
+`wARB` చట్టబద్ధమైన టోకెన్ కాకపోవచ్చని చూపించే మరో సాక్ష్యం ఇది.
+
+3. **Etherscanలో చూడండి**. చాలా స్కామ్ టోకెన్లు గుర్తుపట్టి కమ్యూనిటీ వాటిని ఫిర్యాదు కూడా చేసాయి. అటువంటి టోకెన్‌లు [Etherscanలో గుర్తించబడతాయి](https://info.etherscan.com/etherscan-token-reputation/). Etherscan నిజానికి ఒక అధికారిక మూలం కానప్పటికీ (వికేంద్రీకృత నెట్‌వర్క్‌ల స్వభావం ప్రకారం చట్టబద్ధత కోసం ఒక అధికారిక మూలం ఉండదు), Etherscan ద్వారా స్కామ్‌లుగా గుర్తించబడిన టోకెన్‌లు బహుశా స్కామ్‌లే అయి ఉంటాయి.
+
+   ![Etherscanలో స్కామ్ టోకెన్](./etherscan-scam.png)
+
+## ముగింపు {#conclusion}
+
+ప్రపంచంలో విలువ ఉన్నంత కాలం, దానిని తమ కోసం దొంగిలించడానికి ప్రయత్నించే స్కామర్లు ఉంటారు, మరియు వికేంద్రీకృత ప్రపంచంలో మిమ్మల్ని మీరు తప్ప మిమ్మల్ని రక్షించడానికి ఎవరూ ఉండరు. మేము ఆశిస్తున్నాం, మీరు ఈ పాయింట్స్ అన్ని మీరు గుర్తుపెట్టుకొని అసలైన టోకెన్స్ ఏవో కనిపెట్టి అని ఆశించి స్కామ్ లలో పడకూడదు అని ఆశిస్తున్నాం:
+
+- స్కామ్ టోకెన్లు ఆచ్ఛం నిజం టోకెన్ల లానే అదే పేరు, అదే సింబల్ వాడుతారు ఇంకా మరెన్నో.
+- స్కామ్ టోకెన్‌లు ఒకే కాంట్రాక్ట్ చిరునామాను ఉపయోగించ _లేవు_.
+- చట్టబద్ధమైన టోకెన్ చిరునామాకు ఉత్తమ మూలం అది ఏ సంస్థ యొక్క టోకెనో ఆ సంస్థే.
+- అది విఫలమైతే, మీరు [Uniswap](https://app.uniswap.org/#/swap) మరియు [Blockscout](https://eth.blockscout.com/) వంటి ప్రసిద్ధ, విశ్వసనీయ అప్లికేషన్‌లను ఉపయోగించవచ్చు.
diff --git a/public/content/translations/te/guides/how-to-revoke-token-access/index.md b/public/content/translations/te/guides/how-to-revoke-token-access/index.md
new file mode 100644
index 00000000000..398933749ae
--- /dev/null
+++ b/public/content/translations/te/guides/how-to-revoke-token-access/index.md
@@ -0,0 +1,75 @@
+---
+title: "మీ క్రిప్టో ఫండ్‌లకు స్మార్ట్ కాంట్రాక్ట్ యాక్సెస్‌ను ఎలా రద్దు చేయాలి"
+description: "దోపిడీ చేసే స్మార్ట్ కాంట్రాక్ట్ టోకెన్ యాక్సెస్‌ను రద్దు చేయడంపై ఇది ఒక ఎలా చేయాలి అనే గైడ్"
+lang: te
+---
+
+# మీ క్రిప్టో ఫండ్‌లకు స్మార్ట్ కాంట్రాక్ట్ యాక్సెస్‌ను ఎలా రద్దు చేయాలి
+
+మీరు మీ నిధులకు యాక్సెస్ అనుమతించిన అన్ని [స్మార్ట్ కాంట్రాక్ట్‌ల](/glossary/#smart-contract) జాబితాను ఎలా వీక్షించాలో మరియు వాటిని ఎలా రద్దు చేయాలో ఈ గైడ్ మీకు నేర్పుతుంది.
+
+కొన్నిసార్లు హానికరమైన డెవలపర్లు స్మార్ట్ కాంట్రాక్ట్‌లలోకి బ్యాక్‌డోర్‌లను నిర్మిస్తారు, ఇది స్మార్ట్ కాంట్రాక్ట్‌తో పరస్పర చర్య జరిపే తెలియని వినియోగదారుల నిధులకు యాక్సెస్‌ను అనుమతిస్తుంది. తరచుగా జరిగేది ఏమిటంటే, భవిష్యత్తులో చిన్న మొత్తంలో [గ్యాస్‌ను](/glossary/#gas) ఆదా చేసే ప్రయత్నంలో అటువంటి ప్లాట్‌ఫారమ్‌లు **అపరిమిత సంఖ్యలో టోకెన్‌లను** ఖర్చు చేయడానికి వినియోగదారుడి నుండి అనుమతి కోరుతాయి, కానీ ఇది పెరిగిన ప్రమాదంతో వస్తుంది.
+
+ఒక ప్లాట్‌ఫారమ్ మీ [వాలెట్](/glossary/#wallet) లోని టోకెన్‌కు అపరిమిత యాక్సెస్ హక్కులను కలిగి ఉంటే, మీరు వారి ప్లాట్‌ఫారమ్ నుండి మీ వాలెట్‌లోకి మీ నిధులను ఉపసంహరించుకున్నప్పటికీ, వారు ఆ టోకెన్‌లన్నింటినీ ఖర్చు చేయవచ్చు. హానికరమైన వ్యక్తులు ఇప్పటికీ మీ నిధులను యాక్సెస్ చేయవచ్చు మరియు మీకు ఎటువంటి రికవరీ ఎంపిక లేకుండా వాటిని వారి వాలెట్‌లలోకి ఉపసంహరించుకోవచ్చు.
+
+పరీక్షించని కొత్త ప్రాజెక్ట్‌లను ఉపయోగించకుండా ఉండటం, మీకు అవసరమైన వాటిని మాత్రమే ఆమోదించడం లేదా క్రమం తప్పకుండా యాక్సెస్‌ను రద్దు చేయడం మాత్రమే రక్షణ. కాబట్టి, మీరు దాన్ని ఎలా చేస్తారు?
+
+## దశ 1: యాక్సెస్‌ను రద్దు చేసే సాధనాలను ఉపయోగించండి
+
+అనేక వెబ్‌సైట్‌లు మీ చిరునామాకు కనెక్ట్ చేయబడిన స్మార్ట్ కాంట్రాక్ట్‌లను వీక్షించడానికి మరియు రద్దు చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. వెబ్‌సైట్‌ను సందర్శించి, మీ వాలెట్‌ను కనెక్ట్ చేయండి:
+
+- [Etherscan](https://etherscan.io/tokenapprovalchecker) (ఇతీరియము)
+- [Blockscout](https://eth.blockscout.com/apps/revokescout) (ఇతీరియము)
+- [Revoke](https://revoke.cash/) (బహుళ నెట్‌వర్క్‌లు)
+- [Unrekt](https://app.unrekt.net/) (బహుళ నెట్‌వర్క్‌లు)
+- [EverRevoke](https://everrise.com/everrevoke/) (బహుళ నెట్‌వర్క్‌లు)
+
+## దశ 2: మీ వాలెట్‌ను కనెక్ట్ చేయండి
+
+మీరు వెబ్‌సైట్‌లో ఉన్న తర్వాత, "వాలెట్‌ను కనెక్ట్ చేయండి"పై క్లిక్ చేయండి. వెబ్‌సైట్ మీ వాలెట్‌ను కనెక్ట్ చేయమని మిమ్మల్ని ప్రాంప్ట్ చేస్తుంది.
+
+మీరు మీ వాలెట్ మరియు వెబ్‌సైట్‌లో ఒకే నెట్‌వర్క్‌ను ఉపయోగిస్తున్నారని నిర్ధారించుకోండి. ఎంచుకున్న నెట్‌వర్క్‌కు సంబంధించిన స్మార్ట్ కాంట్రాక్ట్‌లను మాత్రమే మీరు చూస్తారు. ఉదాహరణకు, మీరు Ethereum మెయిన్‌నెట్‌కు కనెక్ట్ చేస్తే, మీరు ఇతీరియము కాంట్రాక్ట్‌లను మాత్రమే చూస్తారు, Polygon వంటి ఇతర చైన్‌ల నుండి కాంట్రాక్ట్‌లను చూడరు.
+
+## దశ 3: మీరు రద్దు చేయాలనుకుంటున్న స్మార్ట్ కాంట్రాక్ట్‌ను ఎంచుకోండి
+
+మీ టోకెన్‌లకు యాక్సెస్ అనుమతించబడిన అన్ని కాంట్రాక్ట్‌లు మరియు వాటి ఖర్చు పరిమితిని మీరు చూడాలి. మీరు రద్దు చేయాలనుకుంటున్న దాన్ని కనుగొనండి.
+
+ఏ కాంట్రాక్ట్‌ను ఎంచుకోవాలో మీకు తెలియకపోతే, మీరు వాటన్నింటినీ రద్దు చేయవచ్చు. ఇది మీకు ఎలాంటి సమస్యలను సృష్టించదు, కానీ మీరు ఈ కాంట్రాక్ట్‌లలో దేనితోనైనా తదుపరిసారి పరస్పర చర్య జరిపినప్పుడు మీరు కొత్త అనుమతుల సమితిని మంజూరు చేయవలసి ఉంటుంది.
+
+## దశ 4: మీ నిధులకు యాక్సెస్‌ను రద్దు చేయండి
+
+మీరు రద్దు చేయిపై క్లిక్ చేసిన తర్వాత, మీరు మీ వాలెట్‌లో కొత్త లావాదేవీ సూచనను చూడాలి. ఇది ఊహించినదే. రద్దు విజయవంతం కావడానికి మీరు రుసుము చెల్లించవలసి ఉంటుంది. నెట్‌వర్క్‌పై ఆధారపడి, ఇది ప్రాసెస్ చేయడానికి ఒక నిమిషం నుండి చాలా నిమిషాల వరకు పట్టవచ్చు.
+
+కొన్ని నిమిషాల తర్వాత రద్దు చేసే సాధనాన్ని రిఫ్రెష్ చేసి, రద్దు చేసిన కాంట్రాక్ట్ జాబితా నుండి అదృశ్యమైందో లేదో రెండుసార్లు తనిఖీ చేయడానికి మీ వాలెట్‌ను మళ్లీ కనెక్ట్ చేయమని మేము మీకు సలహా ఇస్తున్నాము.
+
+<mark>మీ టోకెన్‌లకు ప్రాజెక్ట్‌లను ఎప్పుడూ అపరిమిత యాక్సెస్ ఇవ్వొద్దని మరియు అన్ని టోకెన్ అలవెన్స్ యాక్సెస్‌ను క్రమం తప్పకుండా రద్దు చేయాలని మేము సిఫార్సు చేస్తున్నాము. టోకెన్ యాక్సెస్‌ను రద్దు చేయడం వల్ల నిధులు నష్టపోకూడదు, ప్రత్యేకించి మీరు పైన జాబితా చేయబడిన సాధనాలను ఉపయోగిస్తే.</mark>
+
+<br />
+
+<Alert variant="update">
+<AlertEmoji text=":eyes:"/>
+<AlertContent className="justify-between flex-row items-center">
+  <div>ఇంకా ఎక్కువ నేర్చుకోవాలని ఉందా?</div>
+  <ButtonLink href="/guides/">
+    మా ఇతర గైడ్‌లను చూడండి
+  </ButtonLink>
+</AlertContent>
+</Alert>
+
+## తరచుగా అడిగే ప్రశ్నలు
+
+### టోకెన్ యాక్సెస్‌ను రద్దు చేయడం వలన స్టేకింగ్, పూలింగ్, లెండింగ్ మొదలైనవి కూడా రద్దు చేయబడతాయా?
+
+లేదు, ఇది మీ [DeFi](/glossary/#defi) వ్యూహాలలో దేనినీ ప్రభావితం చేయదు. మీరు మీ స్థానాల్లోనే ఉంటారు మరియు రివార్డులు మొదలైనవి పొందుతూనే ఉంటారు.
+
+### ఒక ప్రాజెక్ట్ నుండి వాలెట్‌ను డిస్‌కనెక్ట్ చేయడం నా నిధులను ఉపయోగించడానికి అనుమతిని తీసివేయడంతో సమానమా?
+
+లేదు, మీరు ప్రాజెక్ట్ నుండి మీ వాలెట్‌ను డిస్‌కనెక్ట్ చేసినా, మీరు టోకెన్ అలవెన్స్ అనుమతులను మంజూరు చేసి ఉంటే, వారు ఇప్పటికీ ఆ టోకెన్‌లను ఉపయోగించగలరు. మీరు ఆ యాక్సెస్‌ను రద్దు చేయాలి.
+
+### కాంట్రాక్ట్ అనుమతి ఎప్పుడు ముగుస్తుంది?
+
+కాంట్రాక్ట్ అనుమతులపై గడువు తేదీలు లేవు. మీరు కాంట్రాక్ట్ అనుమతులను మంజూరు చేస్తే, అవి మంజూరు చేసిన సంవత్సరాల తర్వాత కూడా ఉపయోగించబడతాయి.
+
+### ప్రాజెక్ట్‌లు అపరిమిత టోకెన్ అలవెన్స్‌ను ఎందుకు సెట్ చేస్తాయి?
+
+అవసరమైన అభ్యర్థనల సంఖ్యను తగ్గించడానికి ప్రాజెక్ట్‌లు తరచుగా ఇలా చేస్తాయి, అంటే వినియోగదారుడు ఒక్కసారి మాత్రమే ఆమోదించాలి మరియు లావాదేవీ రుసుమును ఒక్కసారి మాత్రమే చెల్లించాలి. సౌకర్యవంతంగా ఉన్నప్పటికీ, కాలంతో నిరూపించబడని లేదా ఆడిట్ చేయని సైట్‌లలో, వినియోగదారులు నిర్లక్ష్యంగా ఆమోదించడం ప్రమాదకరం. మీ ప్రమాదాన్ని పరిమితం చేయడానికి ఆమోదించబడిన టోకెన్‌ల మొత్తాన్ని మాన్యువల్‌గా పరిమితం చేయడానికి కొన్ని వాలెట్‌లు మిమ్మల్ని అనుమతిస్తాయి. మరింత సమాచారం కోసం మీ వాలెట్ ప్రొవైడర్‌తో తనిఖీ చేయండి.