Transfer
+``` + +हे घटकाचे HTML (अधिक अचूकपणे, [JSX](https://react.dev/learn/writing-markup-with-jsx)) स्वरूप आहे. + +#### `server/noir/src/main.nr` {#server-noir-src-main-nr} + +[ही फाइल](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/src/main.nr) वास्तविक शून्य-ज्ञान कोड आहे. + +``` +use std::hash::pedersen_hash; +``` + +[पेडरसेन हॅश](https://rya-sge.github.io/access-denied/2024/05/07/pedersen-hash-function/) [Noir मानक लायब्ररी](https://noir-lang.org/docs/noir/standard_library/cryptographic_primitives/hashes#pedersen_hash) सह प्रदान केले आहे. शून्य-ज्ञान पुरावे सामान्यतः हे हॅश फंक्शन वापरतात. मानक हॅश फंक्शन्सच्या तुलनेत [अंकगणित सर्किट्स](https://rareskills.io/post/arithmetic-circuit) मध्ये गणना करणे खूप सोपे आहे. + +``` +use keccak256::keccak256; +use dep::ecrecover; +``` + +ही दोन फंक्शन्स बाह्य लायब्ररी आहेत, जी [`Nargo.toml`](https://github.com/qbzzt/250911-zk-bank/blob/01-manual-zk/server/noir/Nargo.toml) मध्ये परिभाषित आहेत. त्यांची नावे जशी आहेत तशीच त्यांची कार्ये आहेत, एक फंक्शन जे [keccak256 हॅश](https://emn178.github.io/online-tools/keccak_256.html) ची गणना करते आणि एक फंक्शन जे Ethereum स्वाक्षरी सत्यापित करते आणि स्वाक्षरीकर्त्याचा Ethereum ॲड्रेस पुनर्प्राप्त करते. + +``` +global ACCOUNT_NUMBER : u32 = 5; +``` + +Noir [Rust](https://www.rust-lang.org/) पासून प्रेरित आहे. व्हेरिएबल्स, डीफॉल्टनुसार, स्थिर असतात. अशाप्रकारे आम्ही जागतिक कॉन्फिगरेशन स्थिरांक परिभाषित करतो. विशेषतः, `ACCOUNT_NUMBER` ही आम्ही संग्रहित करत असलेल्या खात्यांची संख्या आहे. + +`uGreeter
+Greeter
+ { + !readResults.isError && !readResults.isLoading && ++``` + +`ShowGreeting` घटक तयार करा (खाली स्पष्ट केले आहे), परंतु फक्त जर अभिवादन ब्लॉकचेनमधून यशस्वीरित्या वाचले गेले असेल तरच. + +```tsx + +``` + +हे इनपुट टेक्स्ट फील्ड आहे जिथे वापरकर्ता नवीन अभिवादन सेट करू शकतो. प्रत्येक वेळी जेव्हा वापरकर्ता की दाबतो, तेव्हा आम्ही `greetingChange` ला कॉल करतो जे `setNewGreeting` ला कॉल करते. `setNewGreeting` हे `useState` हुक मधून येत असल्यामुळे, ते `Greeter` घटकाला पुन्हा रेंडर करण्यास प्रवृत्त करते. याचा अर्थ असा: + +- आम्हाला नवीन अभिवादनाचे मूल्य ठेवण्यासाठी `value` निर्दिष्ट करणे आवश्यक आहे, कारण अन्यथा ते डीफॉल्ट, रिक्त स्ट्रिंगमध्ये परत येईल. +- `usePrepareContractWrite` प्रत्येक वेळी `newGreeting` बदलल्यावर कॉल केले जाते, याचा अर्थ असा की तयार केलेल्या व्यवहारामध्ये नेहमीच नवीनतम `newGreeting` असेल. + +```tsx + +``` + +जर `workingTx.write` नसेल तर आम्ही अद्याप अभिवादन अपडेट पाठवण्यासाठी आवश्यक असलेल्या माहितीची वाट पाहत आहोत, म्हणून बटण अक्षम आहे. जर `workingTx.write` मूल्य असेल तर ते व्यवहार पाठवण्यासाठी कॉल करण्याचे फंक्शन आहे. + +```tsx +
+
+```
+
+आम्हाला सर्व माहितीने UI ला अव्यवस्थित करायचे नाही, म्हणून त्यांना पाहणे किंवा बंद करणे शक्य करण्यासाठी, आम्ही [`details`](https://www.w3schools.com/tags/tag_details.asp) टॅग वापरतो.
+
+```tsx
+
+
+}
+```
+
+विविध HTML टॅग्ज संपवा.
+
+##### अंतिम `export` {#the-final-export}
+
+```tsx
+export { Greeter }
+```
+
+`Greeter` घटक हा आहे जो आम्हाला ऍप्लिकेशनसाठी निर्यात करणे आवश्यक आहे.
+
+#### `src/wagmi.ts` {#wagmi-ts}
+
+शेवटी, WAGMI शी संबंधित विविध व्याख्या `src/wagmi.ts` मध्ये आहेत. मी येथे सर्व काही स्पष्ट करणार नाही, कारण त्यातील बहुतेक बॉयलरप्लेट आहे जी तुम्हाला बदलण्याची शक्यता नाही.
+
+येथील कोड [github](https://github.com/qbzzt/20230801-modern-ui/blob/main/src/wagmi.ts) वरील कोड सारखाच नाही कारण नंतर लेखात आम्ही आणखी एक चेन ([Redstone Holesky](https://redstone.xyz/docs/network-info)) जोडतो.
+
+```ts
+import { getDefaultWallets } from '@rainbow-me/rainbowkit'
+import { configureChains, createConfig } from 'wagmi'
+import { holesky, sepolia } from 'wagmi/chains'
+```
+
+ऍप्लिकेशनला समर्थन देणारे ब्लॉकचेन आयात करा. तुम्ही [viem github](https://github.com/wagmi-dev/viem/tree/main/src/chains/definitions) मध्ये समर्थित चेन्सची सूची पाहू शकता.
+
+```ts
+import { publicProvider } from 'wagmi/providers/public'
+
+const walletConnectProjectId = 'c96e690bb92b6311e8e9b2a6a22df575'
+```
+
+[WalletConnect](https://walletconnect.com/) वापरण्यास सक्षम होण्यासाठी तुम्हाला तुमच्या ऍप्लिकेशनसाठी प्रोजेक्ट आयडी आवश्यक आहे. तुम्ही ते [cloud.walletconnect.com](https://cloud.walletconnect.com/sign-in) वर मिळवू शकता.
+
+```ts
+const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia ],
+ [
+ publicProvider(),
+ ],
+)
+
+const { connectors } = getDefaultWallets({
+ appName: 'My wagmi + RainbowKit App',
+ chains,
+ projectId: walletConnectProjectId,
+})
+
+export const config = createConfig({
+ autoConnect: true,
+ connectors,
+ publicClient,
+ webSocketPublicClient,
+})
+
+export { chains }
+```
+
+### दुसरे ब्लॉकचेन जोडणे {#add-blockchain}
+
+आजकाल बरेच [L2 स्केलिंग सोल्यूशन](/layer-2/) आहेत, आणि तुम्ही काहींना समर्थन देऊ इच्छित असाल जे viem अद्याप समर्थन देत नाही. ते करण्यासाठी, तुम्ही `src/wagmi.ts` मध्ये बदल करा. या सूचना [Redstone Holesky](https://redstone.xyz/docs/network-info) कसे जोडायचे हे स्पष्ट करतात.
+
+1. viem वरून `defineChain` प्रकार आयात करा.
+
+ ```ts
+ import { defineChain } from 'viem'
+ ```
+
+2. नेटवर्क व्याख्या जोडा.
+
+ ```ts
+ const redstoneHolesky = defineChain({
+ id: 17_001,
+ name: 'Redstone Holesky',
+ network: 'redstone-holesky',
+ nativeCurrency: {
+ decimals: 18,
+ name: 'Ether',
+ symbol: 'ETH',
+ },
+ rpcUrls: {
+ default: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ public: {
+ http: ['https://rpc.holesky.redstone.xyz'],
+ webSocket: ['wss://rpc.holesky.redstone.xyz/ws'],
+ },
+ },
+ blockExplorers: {
+ default: { name: 'Explorer', url: 'https://explorer.holesky.redstone.xyz' },
+ },
+ })
+ ```
+
+3. `configureChains` कॉलमध्ये नवीन चेन जोडा.
+
+ ```ts
+ const { chains, publicClient, webSocketPublicClient } = configureChains(
+ [ holesky, sepolia, redstoneHolesky ],
+ [ publicProvider(), ],
+ )
+ ```
+
+4. ऍप्लिकेशनला नवीन नेटवर्कवर तुमच्या काँट्रॅक्ट्सचा पत्ता माहित असल्याची खात्री करा. या प्रकरणात, आम्ही `src/components/Greeter.tsx` मध्ये बदल करतो:
+
+ ```ts
+ const contractAddrs : AddressPerBlockchainType = {
+ // Holesky
+ 17000: '0x432d810484AdD7454ddb3b5311f0Ac2E95CeceA8',
+
+ // Redstone Holesky
+ 17001: '0x4919517f82a1B89a32392E1BF72ec827ba9986D3',
+
+ // Sepolia
+ 11155111: '0x7143d5c190F048C8d19fe325b748b081903E3BF0'
+ }
+ ```
+
+## निष्कर्ष {#conclusion}
+
+अर्थात, तुम्हाला `Greeter` साठी युझर इंटरफेस प्रदान करण्याची खरोखर काळजी नाही. तुम्हाला तुमच्या स्वतःच्या काँट्रॅक्ट्ससाठी युझर इंटरफेस तयार करायचा आहे. तुमचे स्वतःचे ऍप्लिकेशन तयार करण्यासाठी, या पायऱ्या चालवा:
+
+1. wagmi ऍप्लिकेशन तयार करण्यासाठी निर्दिष्ट करा.
+
+ ```sh copy
+ pnpm create wagmi
+ ```
+
+2. ऍप्लिकेशनला नाव द्या.
+
+3. **React** फ्रेमवर्क निवडा.
+
+4. **Vite** व्हेरिएंट निवडा.
+
+5. तुम्ही [Rainbow kit जोडू शकता](https://www.rainbowkit.com/docs/installation#manual-setup).
+
+आता जा आणि तुमचे काँट्रॅक्ट्स व्यापक जगासाठी वापरण्यायोग्य बनवा.
+
+[माझ्या कामाबद्दल अधिक माहितीसाठी येथे पहा](https://cryptodocguy.pro/).
+
diff --git a/public/content/translations/mr/developers/tutorials/deploying-your-first-smart-contract/index.md b/public/content/translations/mr/developers/tutorials/deploying-your-first-smart-contract/index.md
new file mode 100644
index 00000000000..56f0da82b3b
--- /dev/null
+++ b/public/content/translations/mr/developers/tutorials/deploying-your-first-smart-contract/index.md
@@ -0,0 +1,101 @@
+---
+title: "तुमचा पहिला स्मार्ट कॉन्ट्रॅक्ट तैनात करणे"
+description: "इथेरियम चाचणी नेटवर्कवर तुमचा पहिला स्मार्ट कॉन्ट्रॅक्ट तैनात करण्याची ओळख"
+author: "jdourlens"
+tags:
+ [
+ "स्मार्ट कॉन्ट्रॅक्ट",
+ "रीमिक्स",
+ "सॉलिडिटी",
+ "डिप्लॉयिंग"
+ ]
+skill: beginner
+lang: mr
+published: 2020-04-03
+source: EthereumDev
+sourceUrl: https://ethereumdev.io/deploying-your-first-smart-contract/
+address: "0x19dE91Af973F404EDF5B4c093983a7c6E3EC8ccE"
+---
+
+मला वाटते की तुम्ही इथेरियम ब्लॉकचेनवर तुमच्या पहिल्या [स्मार्ट कॉन्ट्रॅक्टसोबत](/developers/docs/smart-contracts/) संवाद साधण्यासाठी आणि [तैनात करण्यासाठी](/developers/docs/smart-contracts/deploying/) आमच्याइतकेच उत्सुक आहात.
+
+काळजी करू नका, कारण हा आपला पहिला स्मार्ट कॉन्ट्रॅक्ट आहे, आम्ही तो [स्थानिक चाचणी नेटवर्कवर](/developers/docs/networks/) तैनात करू, त्यामुळे तुम्हाला तो तैनात करण्यासाठी आणि त्याच्यासोबत हवा तितका खेळण्यासाठी काहीही खर्च येणार नाही.
+
+## आपला कॉन्ट्रॅक्ट लिहिणे {#writing-our-contract}
+
+पहिली पायरी म्हणजे [Remix ला भेट देणे](https://remix.ethereum.org/) आणि एक नवीन फाईल तयार करणे. Remix इंटरफेसच्या वरच्या डाव्या भागात एक नवीन फाईल जोडा आणि तुम्हाला हवं असलेलं फाईल नाव टाका.
+
+
+
+नवीन फाईलमध्ये, आम्ही खालील कोड पेस्ट करू.
+
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.17;
+
+contract Counter {
+
+ // गणनेची संख्या ठेवण्यासाठी unsigned int प्रकाराचे सार्वजनिक व्हेरिएबल
+ uint256 public count = 0;
+
+ // आमचा काउंटर वाढवणारे फंक्शन
+ function increment() public {
+ count += 1;
+ }
+
+ // गणनेचे मूल्य मिळवण्यासाठी अनावश्यक गेटर
+ function getCount() public view returns (uint256) {
+ return count;
+ }
+
+}
+```
+
+तुम्हाला प्रोग्रामिंगची सवय असल्यास, हा प्रोग्राम काय करतो याचा तुम्ही सहज अंदाज लावू शकता. येथे ओळीनुसार स्पष्टीकरण दिले आहे:
+
+- ओळ 4: आम्ही `Counter` नावाने एक कॉन्ट्रॅक्ट परिभाषित करतो.
+- ओळ 7: आमचा कॉन्ट्रॅक्ट 0 पासून सुरू होणारा `count` नावाचा एक अनसाईंड इंटिजर संग्रहित करतो.
+- ओळ 10: पहिले फंक्शन कॉन्ट्रॅक्टच्या स्टेटमध्ये बदल करेल आणि आमचे `count` व्हेरिएबल `increment()` करेल.
+- दुसरे फंक्शन फक्त एक गेटर आहे जे स्मार्ट कॉन्ट्रॅक्टच्या बाहेर `count` व्हेरिएबलचे मूल्य वाचण्यास सक्षम करते. लक्षात घ्या की, आम्ही आमचे `count` व्हेरिएबल सार्वजनिक म्हणून परिभाषित केल्यामुळे हे आवश्यक नाही परंतु ते उदाहरण म्हणून दाखवले आहे.
+
+आमच्या पहिल्या सोप्या स्मार्ट कॉन्ट्रॅक्टसाठी एवढेच आहे. तुम्हाला माहीत असेलच, हे Java किंवा C++ सारख्या OOP (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) भाषांमधील क्लाससारखे दिसते. आता आमच्या कॉन्ट्रॅक्टसोबत खेळण्याची वेळ आली आहे.
+
+## आपला कॉन्ट्रॅक्ट तैनात करणे {#deploying-our-contract}
+
+आपण आपला पहिला स्मार्ट कॉन्ट्रॅक्ट लिहिला असल्यामुळे, आता आपण त्याच्यासोबत खेळण्यासाठी तो ब्लॉकचेनवर तैनात करू.
+
+[ब्लॉकचेनवर स्मार्ट कॉन्ट्रॅक्ट तैनात करणे](/developers/docs/smart-contracts/deploying/) म्हणजे प्रत्यक्षात कोणतेही प्राप्तकर्ते निर्दिष्ट न करता संकलित स्मार्ट कॉन्ट्रॅक्टचा कोड असलेला व्यवहार पाठवणे.
+
+आपण प्रथम डाव्या बाजूला असलेल्या कंपाइल आयकॉनवर क्लिक करून [कॉन्ट्रॅक्ट कंपाइल करू](/developers/docs/smart-contracts/compiling/):
+
+
+
+नंतर कंपाइल बटणावर क्लिक करा:
+
+
+
+तुम्ही "ऑटो कंपाइल" पर्याय निवडू शकता जेणेकरून तुम्ही टेक्स्ट एडिटरवर सामग्री सेव्ह करता तेव्हा कॉन्ट्रॅक्ट नेहमी कंपाइल होईल.
+
+नंतर "तैनात करा आणि व्यवहार चालवा" स्क्रीनवर नेव्हिगेट करा:
+
+
+
+एकदा तुम्ही "तैनात करा आणि व्यवहार चालवा" स्क्रीनवर आलात की, तुमच्या कॉन्ट्रॅक्टचे नाव दिसत असल्याची खात्री करा आणि तैनात करा वर क्लिक करा. तुम्ही पृष्ठाच्या शीर्षस्थानी पाहू शकता की, सध्याचे वातावरण "JavaScript VM" आहे, याचा अर्थ असा की जलद आणि कोणत्याही शुल्काशिवाय चाचणी घेण्यासाठी आम्ही स्थानिक चाचणी ब्लॉकचेनवर आपला स्मार्ट कॉन्ट्रॅक्ट तैनात करू आणि त्याच्याशी संवाद साधू.
+
+
+
+एकदा तुम्ही "तैनात करा" बटणावर क्लिक केल्यावर, तुम्हाला तुमचा कॉन्ट्रॅक्ट तळाशी दिसेल. त्याचा विस्तार करण्यासाठी डावीकडील बाणावर क्लिक करा जेणेकरून आम्हाला आमच्या कॉन्ट्रॅक्टची सामग्री दिसेल. हे आमचे व्हेरिएबल `counter`, आमचे `increment()` फंक्शन आणि गेटर `getCounter()` आहे.
+
+तुम्ही `count` किंवा `getCount` बटणावर क्लिक केल्यास, ते प्रत्यक्षात कॉन्ट्रॅक्टच्या `count` व्हेरिएबलची सामग्री प्राप्त करेल आणि प्रदर्शित करेल. आपण अद्याप `increment` फंक्शनला कॉल केलेला नसल्यामुळे, ते 0 प्रदर्शित करेल.
+
+
+
+आता बटणावर क्लिक करून `increment` फंक्शनला कॉल करूया. तुम्हाला विंडोच्या तळाशी झालेल्या व्यवहारांचे लॉग दिसतील. तुम्ही `increment` बटणाऐवजी डेटा पुनर्प्राप्त करण्यासाठी बटण दाबत असाल तेव्हा लॉग वेगळे असल्याचे तुम्हाला दिसेल. कारण ब्लॉकचेनवर डेटा वाचण्यासाठी कोणत्याही व्यवहारांची (लिखाण) किंवा शुल्काची आवश्यकता नसते. कारण फक्त ब्लॉकचेनच्या स्टेटमध्ये बदल करण्यासाठी व्यवहार करणे आवश्यक आहे:
+
+
+
+आपल्या `increment()` फंक्शनला कॉल करण्यासाठी व्यवहार निर्माण करणारे इंक्रीमेंट बटण दाबल्यानंतर, आपण काउंट किंवा गेटकाउंट बटणावर परत क्लिक केल्यास, आपल्याला आपल्या स्मार्ट कॉन्ट्रॅक्टची नवीन अपडेटेड स्टेट वाचायला मिळेल, ज्यात काउंट व्हेरिएबल 0 पेक्षा मोठे असेल.
+
+
+
+पुढील ट्युटोरियलमध्ये, आपण [आपल्या स्मार्ट कॉन्ट्रॅक्टमध्ये इव्हेंट्स कसे जोडू शकता](/developers/tutorials/logging-events-smart-contracts/) हे पाहू. लॉगिंग इव्हेंट्स हा तुमचा स्मार्ट कॉन्ट्रॅक्ट डीबग करण्याचा आणि फंक्शन कॉल करताना काय होत आहे हे समजून घेण्याचा एक सोयीस्कर मार्ग आहे.
diff --git a/public/content/translations/mr/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md b/public/content/translations/mr/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
new file mode 100644
index 00000000000..5e53eaf3cfc
--- /dev/null
+++ b/public/content/translations/mr/developers/tutorials/develop-and-test-dapps-with-a-multi-client-local-eth-testnet/index.md
@@ -0,0 +1,372 @@
+---
+title: "स्थानिक, मल्टी-क्लायंट टेस्टनेटवर dApp कसे विकसित आणि चाचणी करावे"
+description: "हे मार्गदर्शक तुम्हाला dApp तैनात आणि चाचणी करण्यासाठी टेस्टनेट वापरण्यापूर्वी, मल्टी-क्लायंट स्थानिक Ethereum टेस्टनेट कसे इन्स्टॅन्शिएट आणि कॉन्फिगर करावे यासाठी मार्गदर्शन करेल."
+author: "Tedi Mitiku"
+tags:
+ [
+ "क्लायंट्स",
+ "नोड्स",
+ "स्मार्ट कॉन्ट्रॅक्ट",
+ "कंपोझेबिलिटी",
+ "कन्सेंसस लेयर",
+ "एक्झिक्यूशन लेयर",
+ "चाचणी"
+ ]
+skill: intermediate
+lang: mr
+published: 2023-04-11
+---
+
+## प्रस्तावना {#introduction}
+
+हे मार्गदर्शक तुम्हाला कॉन्फिगर करण्यायोग्य स्थानिक Ethereum टेस्टनेट इन्स्टॅन्शिएट करणे, त्यावर एक स्मार्ट कॉन्ट्रॅक्ट तैनात करणे आणि तुमच्या dApp विरुद्ध चाचण्या चालवण्यासाठी टेस्टनेट वापरण्याच्या प्रक्रियेत मार्गदर्शन करते. हे मार्गदर्शक अशा dApp डेव्हलपर्ससाठी डिझाइन केले आहे ज्यांना लाइव्ह टेस्टनेट किंवा मेननेटवर तैनात करण्यापूर्वी त्यांचे dApps स्थानिक पातळीवर वेगवेगळ्या नेटवर्क कॉन्फिगरेशनवर विकसित आणि चाचणी करायचे आहेत.
+
+या मार्गदर्शकामध्ये, तुम्ही हे कराल:
+
+- [Kurtosis](https://www.kurtosis.com/) वापरून [`eth-network-package`](https://github.com/kurtosis-tech/eth-network-package) सह स्थानिक Ethereum टेस्टनेट इन्स्टॅन्शिएट करा,
+- dApp कंपाईल, तैनात आणि चाचणी करण्यासाठी तुमचे Hardhat dApp डेव्हलपमेंट एन्व्हायर्नमेंट स्थानिक टेस्टनेटशी कनेक्ट करा, आणि
+- विविध नेटवर्क कॉन्फिगरेशनवर डेव्हलपमेंट आणि टेस्टिंग वर्कफ्लो सक्षम करण्यासाठी, नोड्सची संख्या आणि विशिष्ट EL/CL क्लायंट पेअरिंग्ज यासारख्या पॅरामीटर्ससह स्थानिक टेस्टनेट कॉन्फिगर करा.
+
+### Kurtosis काय आहे? {#what-is-kurtosis}
+
+[Kurtosis](https://www.kurtosis.com/) ही मल्टी-कंटेनर चाचणी एन्व्हायर्नमेंट कॉन्फिगर करण्यासाठी डिझाइन केलेली एक कंपोझेबल बिल्ड सिस्टीम आहे. हे विशेषतः डेव्हलपर्सना पुनरुत्पादक एन्व्हायर्नमेंट तयार करण्यास सक्षम करते ज्यांना डायनॅमिक सेटअप लॉजिकची आवश्यकता असते, जसे की ब्लॉकचेन टेस्टनेट्स.
+
+या मार्गदर्शकामध्ये, Kurtosis eth-network-package [`geth`](https://geth.ethereum.org/) एक्झिक्यूशन लेअर (EL) क्लायंट, तसेच [`teku`](https://consensys.io/teku), [`lighthouse`](https://lighthouse.sigmaprime.io/), आणि [`lodestar`](https://lodestar.chainsafe.io/) कन्सेंसस लेअर (CL) क्लायंट्सच्या सपोर्टसह एक स्थानिक Ethereum टेस्टनेट सुरू करतो. हे पॅकेज Hardhat Network, Ganache, आणि Anvil सारख्या फ्रेमवर्कमधील नेटवर्क्ससाठी एक कॉन्फिगर करण्यायोग्य आणि कंपोझेबल पर्याय म्हणून काम करते. Kurtosis डेव्हलपर्सना ते वापरत असलेल्या टेस्टनेट्सवर अधिक नियंत्रण आणि लवचिकता देते, आणि हे एक प्रमुख कारण आहे की [Ethereum फाउंडेशनने द मर्जची चाचणी घेण्यासाठी Kurtosis चा वापर केला](https://www.kurtosis.com/blog/testing-the-ethereum-merge) आणि नेटवर्क अपग्रेडच्या चाचणीसाठी त्याचा वापर सुरू ठेवला आहे.
+
+## Kurtosis सेटअप करणे {#setting-up-kurtosis}
+
+पुढे जाण्यापूर्वी, तुमच्याकडे हे असल्याची खात्री करा:
+
+- तुमच्या स्थानिक मशीनवर [डॉकर इंजिन इंस्टॉल आणि सुरू केले आहे](https://docs.kurtosis.com/install/#i-install--start-docker)
+- [Kurtosis CLI इंस्टॉल केले आहे](https://docs.kurtosis.com/install#ii-install-the-cli) (किंवा तुमच्याकडे आधीच CLI इंस्टॉल असल्यास, ते नवीनतम रिलीझवर अपग्रेड केले आहे)
+- [Node.js](https://nodejs.org/en), [yarn](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable), आणि [npx](https://www.npmjs.com/package/npx) (तुमच्या dApp एन्व्हायर्नमेंटसाठी) इंस्टॉल केले आहे
+
+## स्थानिक Ethereum टेस्टनेट इन्स्टॅन्शिएट करणे {#instantiate-testnet}
+
+स्थानिक Ethereum टेस्टनेट सुरू करण्यासाठी, चालवा:
+
+```python
+kurtosis --enclave local-eth-testnet run github.com/kurtosis-tech/eth-network-package
+```
+
+टीप: ही कमांड `--enclave` फ्लॅग वापरून तुमच्या नेटवर्कला नाव देते: "local-eth-testnet".
+
+Kurtosis सूचनांचा अर्थ लावणे, प्रमाणित करणे आणि नंतर कार्यान्वित करण्याचे काम करत असताना पडद्यामागे घेत असलेले टप्पे प्रिंट करेल. शेवटी, तुम्हाला खालीलप्रमाणे दिसणारे आउटपुट दिसेल:
+
+```python
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+INFO[2023-04-04T18:09:44-04:00] || Created enclave: local-eth-testnet ||
+INFO[2023-04-04T18:09:44-04:00] ======================================================
+Name: local-eth-testnet
+UUID: 39372d756ae8
+Status: RUNNING
+Creation Time: Tue, 04 Apr 2023 18:09:03 EDT
+
+========================================= Files Artifacts =========================================
+UUID Name
+d4085a064230 cl-genesis-data
+1c62cb792e4c el-genesis-data
+bd60489b73a7 genesis-generation-config-cl
+b2e593fe5228 genesis-generation-config-el
+d552a54acf78 geth-prefunded-keys
+5f7e661eb838 prysm-password
+054e7338bb59 validator-keystore-0
+
+========================================== User Services ==========================================
+UUID Name Ports Status
+e20f129ee0c5 cl-client-0-beacon http: 4000/tcp -> {attrs.name}
+
+ {JSON.stringify(attrs.object, null, 2)}
+```
+
+बहुतेक फील्ड [`JSON.stringify`](https://www.w3schools.com/js/js_json_stringify.asp) वापरून प्रदर्शित केले जातात.
+
+```tsx
+
+ { funs.length > 0 &&
+ <>
+ Functions:
+ -
+```
+
+अपवाद फंक्शन्स आहेत, जे [JSON मानकाचा](https://www.json.org/json-en.html) भाग नाहीत, म्हणून ते स्वतंत्रपणे प्रदर्शित करावे लागतील.
+
+```tsx
+ {funs.map((f, i) =>
+```
+
+JSX मध्ये, `{` कर्ली ब्रॅकेट्स `}` मधील कोड JavaScript म्हणून अर्थ लावला जातो. मग, `(` रेग्युलर ब्रॅकेट्स `)` मधील कोडचा पुन्हा JSX म्हणून अर्थ लावला जातो.
+
+```tsx
+ (
- {f} ) + )} +``` + +React ला [DOM ट्री](https://www.w3schools.com/js/js_htmldom.asp) मधील टॅगसाठी वेगळे आयडेंटिफायर असणे आवश्यक आहे. याचा अर्थ असा की एकाच टॅगच्या चाइल्ड्सना (या प्रकरणात, [अनऑर्डर्ड लिस्ट](https://www.w3schools.com/tags/tag_ul.asp)), वेगळ्या `key` अॅट्रिब्युट्सची आवश्यकता असते. + +```tsx +
Hello ${loginResponse.extract.nameID}
+ + + `) + res.send(); +``` + +वापरकर्त्याला दाखवण्यासाठी की आम्हाला लॉगिन मिळाले आहे, एक HTML प्रतिसाद पाठवा. + +```typescript + } catch (err) { + console.error('Error processing SAML response:', err); + res.status(400).send('SAML authentication failed'); + } + } +) +``` + +अयशस्वी झाल्यास वापरकर्त्याला कळवा. + +```typescript +spRouter.get('/login', +``` + +जेव्हा ब्राउझर हे पृष्ठ मिळवण्याचा प्रयत्न करतो तेव्हा एक लॉगिन विनंती तयार करा. हे वरील क्रम आकृतीमधील पायरी 1 साठी हँडलर आहे. + +```typescript + async (req, res) => { + const loginRequest = await sp.createLoginRequest(idp, "post") +``` + +लॉगिन विनंती पोस्ट करण्यासाठी माहिती मिळवा. + +```typescript + res.send(` + + + +``` + +हे पृष्ठ फॉर्म (खाली पहा) आपोआप सबमिट करते. यामुळे वापरकर्त्याला पुनर्निर्देशित होण्यासाठी काहीही करण्याची गरज नाही. हे वरील क्रम आकृतीमधील पायरी 2 आहे. + +```typescript + + + + `) + } +) + +app.use(express.urlencoded({extended: true})) +``` + +[हे मिडलवेअर](https://expressjs.com/en/5x/api.html#express.urlencoded) [HTTP विनंती](https://www.tutorialspoint.com/http/http_requests.htm) चा मुख्य भाग वाचतो. डीफॉल्टनुसार एक्सप्रेस त्याकडे दुर्लक्ष करते, कारण बहुतेक विनंत्यांसाठी त्याची आवश्यकता नसते. आम्हाला त्याची आवश्यकता आहे कारण POST मुख्य भाग वापरतो. + +```typescript +app.use(`/${config.spDir}`, spRouter) +``` + +सर्व्हिस प्रोव्हायडर डिरेक्टरी (`/sp`) मध्ये राउटर माउंट करा. + +```typescript +app.get("/", (req, res) => { + res.send(` + + + + + + `) +}) +``` + +जर ब्राउझरला रूट डिरेक्टरी मिळवण्याचा प्रयत्न केल्यास, त्याला लॉगिन पेजची लिंक द्या. + +```typescript +app.listen(config.spPort, () => { + console.log(`service provider is running on http://${config.spHostname}:${config.spPort}`) +}) +``` + +या एक्सप्रेस ॲप्लिकेशनसह `spPort` ऐका. + +#### src/idp.mts + +हा आयडेंटिटी प्रोव्हायडर आहे. हे सर्व्हिस प्रोव्हायडरसारखेच आहे, खालील स्पष्टीकरण वेगळ्या भागांसाठी आहेत. + +```typescript +const xmlParser = new (await import("fast-xml-parser")).XMLParser( + { + ignoreAttributes: false, // Preserve attributes + attributeNamePrefix: "@_", // Prefix for attributes + } +) +``` + +आम्हाला सर्व्हिस प्रोव्हायडरकडून मिळालेली XML विनंती वाचणे आणि समजून घेणे आवश्यक आहे. + +```typescript +const getLoginPage = requestId => ` +``` + +हे फंक्शन वरील क्रम आकृतीमधील पायरी 4 मध्ये परत आलेल्या स्वयंचलित-सबमिट केलेल्या फॉर्मसह पृष्ठ तयार करते. + +```typescript + + +Login page
+ + + + +const idpRouter = express.Router() + +idpRouter.post("/loginSubmitted", async (req, res) => { + const loginResponse = await idp.createLoginResponse( +``` + +हे वरील क्रम आकृतीमधील पायरी 5 साठी हँडलर आहे. [`idp.createLoginResponse`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L73-L125) लॉगिन प्रतिसाद तयार करते. + +```typescript + sp, + { + authnContextClassRef: 'urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport', + audience: sp.entityID, +``` + +श्रोता सर्व्हिस प्रोव्हायडर आहे. + +```typescript + extract: { + request: { + id: req.body.requestId + } + }, +``` + +विनंतीमधून काढलेली माहिती. विनंतीमधील आपल्याला महत्त्वाचा असलेला एक पॅरामीटर म्हणजे requestId, जो सर्व्हिस प्रोव्हायडरला विनंत्या आणि त्यांचे प्रतिसाद जुळवू देतो. + +```typescript + signingKey: { privateKey: idpPrivateKey, publicKey: config.idpCert } // Ensure signing +``` + +प्रतिसादावर स्वाक्षरी करण्यासाठी डेटा मिळवण्यासाठी आम्हाला `signingKey` ची आवश्यकता आहे. सर्व्हिस प्रोव्हायडर स्वाक्षरी नसलेल्या विनंत्यांवर विश्वास ठेवत नाही. + +```typescript + }, + "post", + { + email: req.body.email +``` + +हे फिल्ड आम्ही सर्व्हिस प्रोव्हायडरला परत पाठवत असलेल्या वापरकर्ता माहितीसह आहे. + +```typescript + } + ); + + res.send(` + + + + + + + + `) +}) +``` + +पुन्हा, स्वयंचलित-सबमिट केलेला फॉर्म वापरा. हे वरील क्रम आकृतीमधील पायरी 6 आहे. + +```typescript + +// IdP endpoint for login requests +idpRouter.post(`/login`, +``` + +हा एंडपॉईंट आहे जो सर्व्हिस प्रोव्हायडरकडून लॉगिन विनंती प्राप्त करतो. हे वरील क्रम आकृतीमधील पायरी 3 साठी हँडलर आहे. + +```typescript + async (req, res) => { + try { + // Workaround because I couldn't get parseLoginRequest to work. + // const loginRequest = await idp.parseLoginRequest(sp, 'post', req) + const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8')) + res.send(getLoginPage(samlRequest["samlp:AuthnRequest"]["@_ID"])) +``` + +आपण प्रमाणीकरण विनंतीचा आयडी वाचण्यासाठी [`idp.parseLoginRequest`](https://github.com/tngan/samlify/blob/master/src/entity-idp.ts#L127-L144) वापरू शकले पाहिजे. तथापि, मला ते काम करायला जमले नाही आणि त्यावर जास्त वेळ घालवणे योग्य नव्हते म्हणून मी फक्त एक [सामान्य-उद्देशीय XML पार्सर](https://www.npmjs.com/package/fast-xml-parser) वापरतो. आम्हाला आवश्यक असलेली माहिती `Please sign
+ ++ + + +` +} +``` + +उरलेले फक्त स्टँडर्ड HTML आहे. + +```typescript +idpRouter.get("/signature/:nonce/:account/:signature", async (req, res) => { +``` + +हे क्रम आकृतीमधील पायरी 5 साठी हँडलर आहे. + +```typescript + const requestId = nonces[req.params.nonce] + if (requestId === undefined) { + res.send("Bad nonce") + return ; + } + + nonces[req.params.nonce] = undefined +``` + +रिक्वेस्ट आयडी मिळवा, आणि `nonces` मधून नॉन्स हटवा जेणेकरून त्याचा पुन्हा वापर होणार नाही याची खात्री करा. + +```typescript + try { +``` + +सिग्नेचर अवैध असण्याचे अनेक मार्ग असल्यामुळे, आपण हे `try ...` मध्ये गुंडाळतो. कोणत्याही फेकलेल्या त्रुटी पकडण्यासाठी `catch` ब्लॉक. + +```typescript + const validSignature = await verifyMessage({ + address: req.params.account, + message: `${loginPrompt}${req.params.nonce}`, + signature: req.params.signature + }) +``` + +क्रम आकृतीमधील पायरी 5.5 लागू करण्यासाठी [`verifyMessage`](https://viem.sh/docs/actions/public/verifyMessage#verifymessage) वापरा. + +```typescript + if (!validSignature) + throw("Bad signature") + } catch (err) { + res.send("Error:" + err) + return ; + } +``` + +हँडलरचा उर्वरित भाग एका लहान बदलाशिवाय, आपण पूर्वी `/loginSubmitted` हँडलरमध्ये जे केले आहे त्याच्या समतुल्य आहे. + +```typescript + const loginResponse = await idp.createLoginResponse( + . + . + . + { + email: req.params.account + "@bad.email.address" + } + ); +``` + +आमच्याकडे खरा ईमेल अॅड्रेस नाही (तो आम्हाला पुढील विभागात मिळेल), म्हणून आतासाठी आम्ही Ethereum अॅड्रेस परत करतो आणि तो ईमेल अॅड्रेस नाही असे स्पष्टपणे चिन्हांकित करतो. + +```typescript +// IdP endpoint for login requests +idpRouter.post(`/login`, + async (req, res) => { + try { + // Workaround because I couldn't get parseLoginRequest to work. + // const loginRequest = await idp.parseLoginRequest(sp, 'post', req) + const samlRequest = xmlParser.parse(Buffer.from(req.body.SAMLRequest, 'base64').toString('utf-8')) + res.send(getSignaturePage(samlRequest["samlp:AuthnRequest"]["@_ID"])) + } catch (err) { + console.error('Error processing SAML response:', err); + res.status(400).send('SAML authentication failed'); + } + } +) +``` + +`getLoginPage` ऐवजी, आता पायरी 3 हँडलरमध्ये `getSignaturePage` वापरा. + +## ईमेल अॅड्रेस मिळवणे + +पुढील पायरी ईमेल अॅड्रेस मिळवणे आहे, जो सर्व्हिस प्रोव्हायडरने मागितलेला ओळखकर्ता आहे. ते करण्यासाठी, आम्ही [Ethereum Attestation Service (EAS)](https://attest.org/) वापरतो. + +अटेस्टेशन्स मिळवण्याचा सर्वात सोपा मार्ग म्हणजे [GraphQL API](https://docs.attest.org/docs/developer-tools/api) वापरणे. आम्ही ही क्वेरी वापरतो: + +``` +query GetAttestationsByRecipient { + attestations( + where: { + recipient: { equals: "${getAddress(ethAddr)}" } + schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" } + } + take: 1 + ) { + data + id + attester + } +} +``` + +या [`schemaId`](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) मध्ये फक्त एक ई-मेल अॅड्रेस समाविष्ट आहे. ही क्वेरी या स्कीमाच्या अटेस्टेशन्ससाठी विचारते. अटेस्टेशनच्या विषयाला `recipient` म्हणतात. तो नेहमी एक Ethereum अॅड्रेस असतो. + +चेतावणी: आपण येथे अटेस्टेशन्स मिळवत असलेल्या पद्धतीत दोन सुरक्षा समस्या आहेत. + +- आपण API एंडपॉईंट, `https://optimism.easscan.org/graphql` वर जात आहोत, जो एक सेंट्रलाइज्ड घटक आहे. आपण `id` अॅट्रिब्यूट मिळवू शकतो आणि नंतर अटेस्टेशन वास्तविक आहे की नाही हे तपासण्यासाठी ऑनचेन तपासणी करू शकतो, परंतु API एंडपॉईंट अजूनही अटेस्टेशन्सबद्दल न सांगता सेन्सॉर करू शकतो. + + ही समस्या सोडवणे अशक्य नाही, आपण स्वतःचा GraphQL एंडपॉईंट चालवू शकतो आणि चेन लॉगमधून अटेस्टेशन्स मिळवू शकतो, परंतु ते आमच्या उद्देशांसाठी जास्त आहे. + +- आपण अटेस्टॉरच्या ओळखीकडे पाहत नाही. कोणीही आम्हाला खोटी माहिती देऊ शकतो. वास्तविक जगातील अंमलबजावणीमध्ये आमच्याकडे विश्वासार्ह अटेस्टॉरचा एक सेट असेल आणि आम्ही फक्त त्यांच्या अटेस्टेशन्स पाहू. + +हे कृतीत पाहण्यासाठी, विद्यमान IdP आणि SP थांबवा आणि हे कमांड चालवा: + +```sh +git checkout email-address +pnpm install +pnpm start +``` + +नंतर तुमचा ई-मेल अॅड्रेस द्या. तुमच्याकडे ते करण्याचे दोन मार्ग आहेत: + +- प्रायव्हेट की वापरून वॉलेट आयात करा आणि चाचणीसाठी `0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80` ही प्रायव्हेट की वापरा. + +- तुमच्या स्वतःच्या ई-मेल अॅड्रेससाठी एक अटेस्टेशन जोडा: + + 1. [अटेस्टेशन एक्सप्लोररमधील स्कीमावर](https://optimism.easscan.org/schema/view/0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977) ब्राउझ करा. + + 2. **स्कीमासह अटेस्ट करा** वर क्लिक करा. + + 3. प्राप्तकर्ता म्हणून तुमचा Ethereum अॅड्रेस, ईमेल अॅड्रेस म्हणून तुमचा ई-मेल अॅड्रेस टाका आणि **ऑनचेन** निवडा. नंतर **अटेस्टेशन तयार करा** वर क्लिक करा. + + 4. तुमच्या वॉलेटमध्ये व्यवहाराला मंजुरी द्या. गॅससाठी पैसे देण्यासाठी तुम्हाला [Optimism Blockchain](https://app.optimism.io/bridge/deposit) वर काही ETH ची आवश्यकता असेल. + +एकतर, तुम्ही हे केल्यानंतर [http://localhost:3000](http://localhost:3000) वर ब्राउझ करा आणि निर्देशांचे पालन करा. जर तुम्ही चाचणीची प्रायव्हेट की आयात केली असेल, तर तुम्हाला मिळणारा ई-मेल `test_addr_0@example.com` आहे. जर तुम्ही तुमचा स्वतःचा अॅड्रेस वापरला असेल, तर तो तुम्ही अटेस्ट केलेला असावा. + +### तपशीलवार स्पष्टीकरण + + + +नवीन पायऱ्या GraphQL कम्युनिकेशन, पायऱ्या 5.6 आणि 5.7 आहेत. + +पुन्हा, येथे `idp.mts` चे बदललेले भाग आहेत. + +```typescript +import { GraphQLClient } from 'graphql-request' +import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk' +``` + +आपल्याला आवश्यक असलेल्या लायब्ररी आयात करा. + +```typescript +const graphqlEndpointUrl = "https://optimism.easscan.org/graphql" +``` + +[प्रत्येक ब्लॉकचेनसाठी एक वेगळा एंडपॉईंट](https://docs.attest.org/docs/developer-tools/api) आहे. + +```typescript +const graphqlClient = new GraphQLClient(graphqlEndpointUrl, { fetch }) +``` + +एक नवीन `GraphQLClient` क्लायंट तयार करा जो आपण एंडपॉईंटवर क्वेरी करण्यासाठी वापरू शकतो. + +```typescript +const graphqlSchema = 'string emailAddress' +const graphqlEncoder = new SchemaEncoder(graphqlSchema) +``` + +GraphQL आपल्याला फक्त बाइट्ससह एक अपारदर्शक डेटा ऑब्जेक्ट देतो. ते समजून घेण्यासाठी आपल्याला स्कीमाची आवश्यकता आहे. + +```typescript +const ethereumAddressToEmail = async ethAddr => { +``` + +Ethereum अॅड्रेसवरून ई-मेल अॅड्रेसवर जाण्यासाठी एक फंक्शन. + +```typescript + const query = ` + query GetAttestationsByRecipient { +``` + +ही एक GraphQL क्वेरी आहे. + +```typescript + attestations( +``` + +आम्ही अटेस्टेशन्स शोधत आहोत. + +```typescript + where: { + recipient: { equals: "${getAddress(ethAddr)}" } + schemaId: { equals: "0xfa2eff59a916e3cc3246f9aec5e0ca00874ae9d09e4678e5016006f07622f977" } + } +``` + +आम्हाला हवी असलेली अटेस्टेशन्स आमच्या स्कीमामध्ये आहेत, जिथे प्राप्तकर्ता `getAddress(ethAddr)` आहे. [`getAddress`](https://viem.sh/docs/utilities/getAddress#getaddress) फंक्शन खात्री करते की आमच्या अॅड्रेसमध्ये योग्य [चेकसम](https://github.com/ethereum/ercs/blob/master/ERCS/erc-55.md) आहे. हे आवश्यक आहे कारण GraphQL केस-सिग्निफिकेंट आहे. "0xBAD060A7", "0xBad060A7", आणि "0xbad060a7" ही वेगवेगळी मूल्ये आहेत. + +```typescript + take: 1 +``` + +आपल्याला कितीही अटेस्टेशन्स सापडले तरी, आम्हाला फक्त पहिलेच हवे आहे. + +```typescript + ) { + data + id + attester + } + }` +``` + +आम्हाला मिळवायचे असलेले फिल्ड्स. + +- `attester`: ज्या अॅड्रेसने अटेस्टेशन सादर केले. सामान्यतः याचा वापर अटेस्टेशनवर विश्वास ठेवायचा की नाही हे ठरवण्यासाठी केला जातो. +- `id`: अटेस्टेशन आयडी. तुम्ही GraphQL क्वेरीमधून मिळालेली माहिती योग्य आहे की नाही हे तपासण्यासाठी [अटेस्टेशन ऑनचेन वाचण्यासाठी](https://optimism.blockscout.com/address/0x4200000000000000000000000000000000000021?tab=read_proxy&source_address=0x4E0275Ea5a89e7a3c1B58411379D1a0eDdc5b088#0xa3112a64) हे मूल्य वापरू शकता. +- `data`: स्कीमा डेटा (या प्रकरणात, ई-मेल अॅड्रेस). + +```typescript + const queryResult = await graphqlClient.request(query) + + if (queryResult.attestations.length == 0) + return "no_address@available.is" +``` + +जर अटेस्टेशन नसेल, तर एक असे मूल्य परत करा जे स्पष्टपणे चुकीचे आहे, परंतु सर्व्हिस प्रोव्हायडरला ते वैध वाटेल. + +```typescript + const attestationDataFields = graphqlEncoder.decodeData(queryResult.attestations[0].data) + return attestationDataFields[0].value.value +} +``` + +जर मूल्य असेल, तर डेटा डीकोड करण्यासाठी `decodeData` वापरा. आम्हाला ते प्रदान करत असलेला मेटाडेटा नको, फक्त मूल्यच हवे आहे. + +```typescript + const loginResponse = await idp.createLoginResponse( + sp, + { + . + . + . + }, + "post", + { + email: await ethereumAddressToEmail(req.params.account) + } + ); +``` + +ई-मेल अॅड्रेस मिळवण्यासाठी नवीन फंक्शन वापरा. + +## विकेंद्रीकरणाचे काय? + +या कॉन्फिगरेशनमध्ये वापरकर्ते स्वतःला दुसरे कोणीतरी असल्याचे भासवू शकत नाहीत, जोपर्यंत आपण Ethereum ते ई-मेल अॅड्रेस मॅपिंगसाठी विश्वासार्ह अटेस्टर्सवर अवलंबून आहोत. तथापि, आमचा ओळख प्रदाता अजूनही एक केंद्रीकृत घटक आहे. ज्याच्याकडे आयडेंटिटी प्रोव्हायडरची प्रायव्हेट की आहे तो सर्व्हिस प्रोव्हायडरला खोटी माहिती पाठवू शकतो. + +[मल्टी-पार्टी कम्प्युटेशन (MPC)](https://en.wikipedia.org/wiki/Secure_multi-party_computation) वापरून एक उपाय असू शकतो. मी भविष्यातील ट्युटोरियलमध्ये त्याबद्दल लिहिण्याची आशा करतो. + +## निष्कर्ष + +लॉग ऑन स्टँडर्डचा अवलंब, जसे की Ethereum सिग्नेचर, कोंबडी आणि अंड्याच्या समस्येला सामोरे जातो. सर्व्हिस प्रोव्हायडर शक्य तितक्या विस्तृत बाजारपेठेत आवाहन करू इच्छितात. वापरकर्ते त्यांच्या लॉग ऑन स्टँडर्डला सपोर्ट करण्याची चिंता न करता सेवांमध्ये प्रवेश करू इच्छितात. +अॅडॉप्टर्स तयार करणे, जसे की Ethereum IdP, आपल्याला या अडथळ्यावर मात करण्यास मदत करू शकते. + +[माझ्या कामाबद्दल अधिक माहितीसाठी येथे पहा](https://cryptodocguy.pro/). diff --git a/public/content/translations/mr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md b/public/content/translations/mr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md new file mode 100644 index 00000000000..30aa0f8a9a5 --- /dev/null +++ b/public/content/translations/mr/developers/tutorials/getting-started-with-ethereum-development-using-alchemy/index.md @@ -0,0 +1,156 @@ +--- +title: "Ethereum डेव्हलपमेंटसोबत सुरुवात करणे" +description: "हे Ethereum डेव्हलपमेंटची सुरुवात करण्यासाठी नवशिक्यांचे मार्गदर्शक आहे. आम्ही तुम्हाला API एंडपॉइंट तयार करण्यापासून, कमांड लाइन रिक्वेस्ट करण्यापर्यंत, ते तुमचे पहिले web3 स्क्रिप्ट लिहिण्यापर्यंत घेऊन जाऊ! ब्लॉकचेन डेव्हलपमेंट अनुभवाची आवश्यकता नाही!" +author: "Elan Halpern" +tags: + [ + "javascript", + "ethers.js", + "नोड्स", + "querying", + "alchemy" + ] +skill: beginner +lang: mr +published: 2020-10-30 +source: Medium +sourceUrl: https://medium.com/alchemy-api/getting-started-with-ethereum-development-using-alchemy-c3d6a45c567f +--- + + + +हे Ethereum डेव्हलपमेंटची सुरुवात करण्यासाठी नवशिक्यांचे मार्गदर्शक आहे. या ट्युटोरियलसाठी आम्ही [Alchemy](https://alchemyapi.io/) वापरणार आहोत, जे Maker, 0x, MyEtherWallet, Dharma आणि Kyber सह 70% आघाडीच्या ब्लॉकचेन ॲप्समधील लाखो वापरकर्त्यांना सामर्थ्य देणारे, अग्रगण्य ब्लॉकचेन डेव्हलपर प्लॅटफॉर्म आहे. Alchemy आम्हाला Ethereum चेनवर एका API एंडपॉइंटमध्ये प्रवेश देईल जेणेकरून आम्ही व्यवहार (transactions) वाचू आणि लिहू शकू. + +आम्ही तुम्हाला Alchemy वर साइन अप करण्यापासून ते तुमचे पहिले web3 स्क्रिप्ट लिहिण्यापर्यंत घेऊन जाऊ! ब्लॉकचेन डेव्हलपमेंट अनुभवाची आवश्यकता नाही! + +## १. मोफत Alchemy खात्यासाठी साइन अप करा {#sign-up-for-a-free-alchemy-account} + +Alchemy वर खाते तयार करणे सोपे आहे, [येथे विनामूल्य साइन अप करा](https://auth.alchemy.com/). + +## २. Alchemy ॲप तयार करा {#create-an-alchemy-app} + +Ethereum चेनशी संवाद साधण्यासाठी आणि Alchemy ची उत्पादने वापरण्यासाठी, तुमच्या रिक्वेस्ट प्रमाणित करण्याकरिता तुम्हाला एका API की ची आवश्यकता आहे. + +तुम्ही [डॅशबोर्डवरून API की तयार करू शकता](https://dashboard.alchemy.com/). नवीन की तयार करण्यासाठी, खाली दर्शविल्याप्रमाणे “ॲप तयार करा” (Create App) वर नेव्हिगेट करा: + +[_ShapeShift_](https://shapeshift.com/) _यांचे त्यांचा डॅशबोर्ड दाखवण्याची परवानगी दिल्याबद्दल विशेष आभार!_ + + + +तुमची नवीन की मिळवण्यासाठी “ॲप तयार करा” (Create App) अंतर्गत तपशील भरा. तुम्ही पूर्वी तयार केलेले ॲप्स आणि तुमच्या टीमने बनवलेले ॲप्स देखील येथे पाहू शकता. कोणत्याही ॲपसाठी विद्यमान की मिळवण्यासाठी “की पाहा” (View Key) वर क्लिक करा. + + + +तुम्ही “ॲप्स” (Apps) वर फिरवून आणि एक निवडून विद्यमान API की देखील मिळवू शकता. तुम्ही येथे “की पाहा” (View Key) करू शकता, तसेच विशिष्ट डोमेन व्हाइटलिस्ट करण्यासाठी, अनेक डेव्हलपर टूल्स पाहण्यासाठी, आणि ॲनालिटिक्स पाहण्यासाठी “ॲप संपादित करा” (Edit App) देखील वापरू शकता. + + + +## ३. कमांड लाइनवरून रिक्वेस्ट करा {#make-a-request-from-the-command-line} + +JSON-RPC आणि curl वापरून Alchemy द्वारे Ethereum ब्लॉकचेनशी संवाद साधा. + +मॅन्युअल रिक्वेस्टसाठी, आम्ही `POST` रिक्वेस्टद्वारे `JSON-RPC` शी संवाद साधण्याची शिफारस करतो. फक्त `Content-Type: application/json` हेडर आणि तुमची क्वेरी `POST` बॉडी म्हणून खालील फील्डसह पास करा: + +- `jsonrpc`: JSON-RPC आवृत्ती—सध्या, फक्त `2.0` समर्थित आहे. +- `method`: ETH API पद्धत. [API संदर्भ पाहा.](https://docs.alchemyapi.io/documentation/alchemy-api-reference/json-rpc) +- `params`: पद्धतीला पास करण्यासाठी पॅरामीटर्सची यादी. +- `id`: तुमच्या रिक्वेस्टचा ID. हे प्रतिसादाद्वारे परत केले जाईल जेणेकरून प्रतिसाद कोणत्या रिक्वेस्टचा आहे याचा तुम्ही मागोवा ठेवू शकाल. + +सध्याची गॅस किंमत मिळवण्यासाठी तुम्ही कमांड लाइनवरून चालवू शकता असे एक उदाहरण येथे आहे: + +```bash +curl https://eth-mainnet.alchemyapi.io/v2/demo \ +-X POST \ +-H "Content-Type: application/json" \ +-d '{"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":73}' +``` + +_**टीप:** [https://eth-mainnet.alchemyapi.io/v2/demo](https://eth-mainnet.alchemyapi.io/jsonrpc/demo) ला तुमच्या स्वतःच्या API की `https://eth-mainnet.alchemyapi.io/v2/**your-api-key` ने बदला._ + +**परिणाम:** + +```json +{ "id": 73,"jsonrpc": "2.0","result": "0x09184e72a000" // 10000000000000 } +``` + +## ४. तुमचा Web3 क्लायंट सेट अप करा {#set-up-your-web3-client} + +**तुमच्याकडे विद्यमान क्लायंट असल्यास,** तुमचा सध्याचा नोड प्रोव्हायडर URL तुमच्या API की सह Alchemy URL मध्ये बदला: `“https://eth-mainnet.alchemyapi.io/v2/your-api-key"` + +**_टीप:_** खालील स्क्रिप्ट्स **नोड संदर्भात** चालवणे किंवा **फाईलमध्ये सेव्ह करणे** आवश्यक आहे, कमांड लाइनवरून चालवू नये. तुमच्याकडे आधीपासून Node किंवा npm इंस्टॉल केलेले नसल्यास, मॅकसाठी हे द्रुत [सेट-अप मार्गदर्शक](https://app.gitbook.com/@alchemyapi/s/alchemy/guides/alchemy-for-macs) पाहा. + +अशा अनेक [Web3 लायब्ररीज](https://docs.alchemyapi.io/guides/getting-started#other-web3-libraries) आहेत ज्या तुम्ही Alchemy सह समाकलित करू शकता, तथापि, आम्ही [Alchemy Web3](https://docs.alchemy.com/reference/api-overview) वापरण्याची शिफारस करतो, जे web3.js साठी एक ड्रॉप-इन रिप्लेसमेंट आहे, आणि जे Alchemy सोबत अखंडपणे काम करण्यासाठी तयार आणि कॉन्फिगर केले आहे. हे स्वयंचलित पुन्हा प्रयत्न (automatic retries) आणि मजबूत WebSocket समर्थन यासारखे अनेक फायदे प्रदान करते. + +AlchemyWeb3.js इंस्टॉल करण्यासाठी, **तुमच्या प्रोजेक्ट डिरेक्टरीमध्ये नेव्हिगेट करा** आणि चालवा: + +**Yarn सह:** + +``` +yarn add @alch/alchemy-web3 +``` + +**NPM सह:** + +``` +npm install @alch/alchemy-web3 +``` + +Alchemy च्या नोड इन्फ्रास्ट्रक्चरशी संवाद साधण्यासाठी, NodeJS मध्ये चालवा किंवा हे जावास्क्रिप्ट फाईलमध्ये जोडा: + +```js +const { createAlchemyWeb3 } = require("@alch/alchemy-web3") +const web3 = createAlchemyWeb3( + "https://eth-mainnet.alchemyapi.io/v2/your-api-key" +) +``` + +## ५. तुमची पहिली Web3 स्क्रिप्ट लिहा! {#write-your-first-web3-script} + +आता थोडे web3 प्रोग्रामिंग करून पाहण्यासाठी, आपण Ethereum मेननेटवरून नवीनतम ब्लॉक नंबर प्रिंट करणारी एक साधी स्क्रिप्ट लिहूया. + +**१.** **तुम्ही आधीच केले नसेल तर, तुमच्या टर्मिनलमध्ये एक नवीन प्रोजेक्ट डिरेक्टरी तयार करा आणि त्यात cd करा:** + +``` +mkdir web3-example +cd web3-example +``` + +**२.** **तुम्ही आधीच केली नसेल तर तुमच्या प्रोजेक्टमध्ये Alchemy web3 (किंवा कोणतीही web3) डिपेन्डन्सी इंस्टॉल करा:** + +``` +npm install @alch/alchemy-web3 +``` + +**३.** **`index.js` नावाची फाईल तयार करा आणि खालील सामग्री जोडा:** + +> तुम्ही शेवटी `demo` ला तुमच्या Alchemy HTTP API की ने बदलले पाहिजे. + +```js +async function main() { + const { createAlchemyWeb3 } = require("@alch/alchemy-web3") + const web3 = createAlchemyWeb3("https://eth-mainnet.alchemyapi.io/v2/demo") + const blockNumber = await web3.eth.getBlockNumber() + console.log("नवीनतम ब्लॉक नंबर आहे " + blockNumber) +} +main() +``` + +async गोष्टींशी अपरिचित आहात? ही [मीडियम पोस्ट](https://medium.com/better-programming/understanding-async-await-in-javascript-1d81bb079b2c) पाहा. + +\*\*4. **node वापरून ते तुमच्या टर्मिनलमध्ये चालवा** + +``` +node index.js +``` + +\*\*5. **तुम्हाला आता तुमच्या कन्सोलमध्ये नवीनतम ब्लॉक नंबर आउटपुट दिसेल!** + +``` +नवीनतम ब्लॉक नंबर आहे 11043912 +``` + +**व्वा!** अभिनंदन! **तुम्ही Alchemy वापरून तुमची पहिली web3 स्क्रिप्ट नुकतीच लिहिली आहे 🎉** + +पुढे काय करायचे याची खात्री नाही? आमच्या [हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट मार्गदर्शक](https://www.alchemy.com/docs/hello-world-smart-contract) मध्ये तुमचा पहिला स्मार्ट कॉन्ट्रॅक्ट तैनात (deploy) करून आणि काही solidity प्रोग्रामिंग करून पाहा, किंवा [डॅशबोर्ड डेमो ॲप](https://docs.alchemyapi.io/tutorials/demo-app) सह तुमचे डॅशबोर्ड ज्ञान तपासा! + +_[Alchemy सह विनामूल्य साइन अप करा](https://auth.alchemy.com/), आमचे [दस्तऐवजीकरण](https://www.alchemy.com/docs/) पाहा, आणि नवीनतम बातम्यांसाठी, आम्हाला [Twitter](https://twitter.com/AlchemyPlatform) वर फॉलो करा_. diff --git a/public/content/translations/mr/developers/tutorials/guide-to-smart-contract-security-tools/index.md b/public/content/translations/mr/developers/tutorials/guide-to-smart-contract-security-tools/index.md new file mode 100644 index 00000000000..075df7fff4b --- /dev/null +++ b/public/content/translations/mr/developers/tutorials/guide-to-smart-contract-security-tools/index.md @@ -0,0 +1,102 @@ +--- +title: "स्मार्ट कॉन्ट्रॅक्ट सुरक्षा साधनांसाठी मार्गदर्शक" +description: "तीन वेगवेगळ्या चाचणी आणि प्रोग्राम विश्लेषण तंत्रांचे अवलोकन" +author: "Trailofbits" +lang: mr +tags: [ "सॉलिडिटी", "स्मार्ट कॉन्ट्रॅक्ट", "सुरक्षा" ] +skill: intermediate +published: 2020-09-07 +source: Building secure contracts +sourceUrl: https://github.com/crytic/building-secure-contracts/tree/master/program-analysis +--- + +आम्ही तीन विशिष्ट चाचणी आणि प्रोग्राम विश्लेषण तंत्र वापरणार आहोत: + +- **[Slither](/developers/tutorials/how-to-use-slither-to-find-smart-contract-bugs/) सह स्थिर विश्लेषण.** प्रोग्रामचे सर्व मार्ग एकाच वेळी अंदाजित आणि विश्लेषित केले जातात, वेगवेगळ्या प्रोग्राम प्रस्तुतीकरणाद्वारे (उदा., कंट्रोल-फ्लो-ग्राफ) +- **[Echidna](/developers/tutorials/how-to-use-echidna-to-test-smart-contracts/) सह फझिंग.** व्यवहारांच्या छद्म-यादृच्छिक निर्मितीसह कोड कार्यान्वित केला जातो. फझर दिलेल्या गुणधर्माचे उल्लंघन करण्यासाठी व्यवहारांचा क्रम शोधण्याचा प्रयत्न करेल. +- **[Manticore](/developers/tutorials/how-to-use-manticore-to-find-smart-contract-bugs/) सह प्रतीकात्मक अंमलबजावणी.** एक औपचारिक पडताळणी तंत्र, जे प्रत्येक अंमलबजावणी मार्गाला गणितीय सूत्रात अनुवादित करते, ज्यावर मर्यादा तपासल्या जाऊ शकतात. + +प्रत्येक तंत्राचे फायदे आणि तोटे आहेत, आणि ते [विशिष्ट प्रकरणांमध्ये](#determining-security-properties) उपयुक्त ठरेल: + +| तंत्र | टूल | वापर | वेग | चुकलेले बग्स | खोटे अलार्म | +| ---------------------- | --------- | -------------------------------- | ------ | ------------- | ----------- | +| स्थिर विश्लेषण | Slither | CLI आणि स्क्रिप्ट्स | सेकंद | मध्यम | कमी | +| फझिंग | Echidna | Solidity गुणधर्म | मिनिटे | कमी | काहीही नाही | +| प्रतीकात्मक अंमलबजावणी | Manticore | Solidity गुणधर्म आणि स्क्रिप्ट्स | तास | काहीही नाही\* | काहीही नाही | + +\* जर सर्व मार्ग टाइमआउटशिवाय शोधले गेले तर + +**Slither** काही सेकंदात कॉन्ट्रॅक्ट्सचे विश्लेषण करते, तथापि, स्थिर विश्लेषणामुळे खोटे अलार्म येऊ शकतात आणि ते जटिल तपासणीसाठी (उदा., अंकगणितीय तपासणी) कमी योग्य असेल. अंगभूत डिटेक्टरमध्ये पुश-बटण प्रवेशासाठी API द्वारे Slither चालवा किंवा वापरकर्ता-परिभाषित तपासणीसाठी API द्वारे चालवा. + +**Echidna** ला चालण्यासाठी काही मिनिटे लागतात आणि ते फक्त खरे सकारात्मक परिणाम देईल. Echidna वापरकर्त्याने प्रदान केलेले सुरक्षा गुणधर्म तपासते, जे Solidity मध्ये लिहिलेले आहेत. हे यादृच्छिक शोधावर आधारित असल्यामुळे बग्स चुकवू शकते. + +**Manticore** सर्वात "जड" विश्लेषण करते. Echidna प्रमाणेच, Manticore वापरकर्त्याने प्रदान केलेले गुणधर्म सत्यापित करते. त्याला चालण्यासाठी जास्त वेळ लागेल, पण ते एका गुणधर्माची वैधता सिद्ध करू शकते आणि खोटे अलार्म कळवणार नाही. + +## सुचवलेले कार्यप्रवाह {#suggested-workflow} + +आता कोणतेही सोपे बग्स नाहीत किंवा नंतर येणार नाहीत याची खात्री करण्यासाठी Slither च्या अंगभूत डिटेक्टरने सुरुवात करा. वारसा, व्हेरिएबल अवलंबित्व आणि संरचनात्मक समस्यांशी संबंधित गुणधर्म तपासण्यासाठी Slither वापरा. जसजसा कोडबेस वाढेल, तसतसे स्टेट मशीनचे अधिक जटिल गुणधर्म तपासण्यासाठी Echidna वापरा. Solidity कडून अनुपलब्ध संरक्षणांसाठी सानुकूल तपासणी विकसित करण्यासाठी Slither ला पुन्हा भेट द्या, जसे की फंक्शन ओव्हरराइड होण्यापासून संरक्षण. शेवटी, महत्त्वपूर्ण सुरक्षा गुणधर्मांची लक्ष्यित पडताळणी करण्यासाठी Manticore वापरा, उदा., अंकगणितीय ऑपरेशन्स. + +- सामान्य समस्या शोधण्यासाठी Slither चा CLI वापरा +- आपल्या कॉन्ट्रॅक्टच्या उच्च-स्तरीय सुरक्षा गुणधर्मांची चाचणी करण्यासाठी Echidna वापरा +- सानुकूल स्थिर तपासणी लिहिण्यासाठी Slither वापरा +- जेव्हा तुम्हाला महत्त्वपूर्ण सुरक्षा गुणधर्मांची सखोल खात्री हवी असेल तेव्हा Manticore वापरा + +**युनिट चाचण्यांवर एक टीप**. उच्च-गुणवत्तेचे सॉफ्टवेअर तयार करण्यासाठी युनिट चाचण्या आवश्यक आहेत. तथापि, ही तंत्रे सुरक्षा त्रुटी शोधण्यासाठी सर्वात योग्य नाहीत. ते सामान्यतः कोडच्या सकारात्मक वर्तनाची चाचणी करण्यासाठी वापरले जातात (म्हणजे, कोड सामान्य संदर्भात अपेक्षेप्रमाणे कार्य करतो), तर सुरक्षा त्रुटी विकसकांनी विचारात न घेतलेल्या एज केसेसमध्ये असतात. आमच्या डझनभर स्मार्ट कॉन्ट्रॅक्ट सुरक्षा पुनरावलोकनांच्या अभ्यासात, [युनिट टेस्ट कव्हरेजचा आमच्या क्लायंटच्या कोडमध्ये आढळलेल्या सुरक्षा त्रुटींच्या संख्येवर किंवा तीव्रतेवर कोणताही परिणाम झाला नाही](https://blog.trailofbits.com/2019/08/08/246-findings-from-our-smart-contract-audits-an-executive-summary/). + +## सुरक्षा गुणधर्म निश्चित करणे {#determining-security-properties} + +आपल्या कोडची प्रभावीपणे चाचणी आणि पडताळणी करण्यासाठी, आपण लक्ष देण्याची आवश्यकता असलेली क्षेत्रे ओळखली पाहिजेत. तुमची सुरक्षेवर खर्च होणारी संसाधने मर्यादित असल्याने, तुमच्या प्रयत्नांना अनुकूल करण्यासाठी तुमच्या कोडबेसमधील कमकुवत किंवा उच्च-मूल्य असलेल्या भागांची व्याप्ती करणे महत्त्वाचे आहे. थ्रेट मॉडेलिंग मदत करू शकते. पुनरावलोकन करण्याचा विचार करा: + +- [रॅपिड रिस्क असेसमेंट्स](https://infosec.mozilla.org/guidelines/risk/rapid_risk_assessment.html) (वेळ कमी असताना आमचा प्राधान्याचा दृष्टिकोन) +- [डेटा-सेंट्रिक सिस्टम थ्रेट मॉडेलिंगसाठी मार्गदर्शक](https://csrc.nist.gov/pubs/sp/800/154/ipd) (उर्फ NIST 800-154) +- [शोस्टॅक थ्रेट मॉडेलिंग](https://www.amazon.com/Threat-Modeling-Designing-Adam-Shostack/dp/1118809998) +- [STRIDE](https://wikipedia.org/wiki/STRIDE_\(security\)) / [DREAD](https://wikipedia.org/wiki/DREAD_\(risk_assessment_model\)) +- [PASTA](https://wikipedia.org/wiki/Threat_model#P.A.S.T.A.) +- [असर्शन्सचा वापर](https://blog.regehr.org/archives/1091) + +### घटक {#components} + +तुम्हाला काय तपासायचे आहे हे जाणून घेतल्याने तुम्हाला योग्य साधन निवडण्यातही मदत होईल. + +स्मार्ट कॉन्ट्रॅक्टसाठी वारंवार संबंधित असलेल्या व्यापक क्षेत्रांमध्ये यांचा समावेश आहे: + +- **स्टेट मशीन.** बहुतेक कॉन्ट्रॅक्ट्स स्टेट मशीन म्हणून सादर केले जाऊ शकतात. हे तपासण्याचा विचार करा की (१) कोणतीही अवैध स्थिती गाठली जाऊ शकत नाही, (२) जर एखादी स्थिती वैध असेल तर ती गाठली जाऊ शकते, आणि (३) कोणतीही स्थिती कॉन्ट्रॅक्टला अडकवत नाही. + + - स्टेट-मशीन स्पेसिफिकेशन्सची चाचणी घेण्यासाठी Echidna आणि Manticore ही पसंतीची साधने आहेत. + +- **प्रवेश नियंत्रणे.** जर तुमच्या सिस्टममध्ये विशेषाधिकार असलेले वापरकर्ते असतील (उदा., मालक, नियंत्रक, ...) तुम्ही हे सुनिश्चित केले पाहिजे की (१) प्रत्येक वापरकर्ता केवळ अधिकृत कृती करू शकतो आणि (२) कोणताही वापरकर्ता अधिक विशेषाधिकार असलेल्या वापरकर्त्याच्या कृतींना ब्लॉक करू शकत नाही. + + - Slither, Echidna आणि Manticore योग्य प्रवेश नियंत्रणे तपासू शकतात. उदाहरणार्थ, Slither हे तपासू शकते की केवळ व्हाइटलिस्ट केलेल्या फंक्शन्समध्ये onlyOwner मॉडिफायरची कमतरता आहे. Echidna आणि Manticore अधिक जटिल प्रवेश नियंत्रणासाठी उपयुक्त आहेत, जसे की कॉन्ट्रॅक्टने विशिष्ट स्थितीत पोहोचल्यास दिलेली परवानगी. + +- **अंकगणितीय ऑपरेशन्स.** अंकगणितीय ऑपरेशन्सची सुदृढता तपासणे महत्त्वाचे आहे. ओव्हरफ्लो/अंडरफ्लो टाळण्यासाठी सर्वत्र `SafeMath` वापरणे हे एक चांगले पाऊल आहे, तथापि, आपण तरीही इतर अंकगणितीय त्रुटींचा विचार केला पाहिजे, ज्यात राउंडिंग समस्या आणि कॉन्ट्रॅक्टला अडकवणाऱ्या त्रुटींचा समावेश आहे. + + - Manticore येथे सर्वोत्तम पर्याय आहे. जर अंकगणित SMT सॉल्व्हरच्या कार्यक्षेत्राबाहेर असेल तर Echidna वापरला जाऊ शकतो. + +- **वारसा अचूकता.** Solidity कॉन्ट्रॅक्ट्स मोठ्या प्रमाणावर एकाधिक वारसावर अवलंबून असतात. शॅडोइंग फंक्शनमध्ये `super` कॉल चुकणे आणि c3 लिनिअरायझेशन क्रमाचा चुकीचा अर्थ लावणे यासारख्या चुका सहजपणे येऊ शकतात. + + - या समस्या शोधण्याची खात्री करण्यासाठी Slither हे साधन आहे. + +- **बाह्य संवाद.** कॉन्ट्रॅक्ट्स एकमेकांशी संवाद साधतात, आणि काही बाह्य कॉन्ट्रॅक्ट्सवर विश्वास ठेवला जाऊ नये. उदाहरणार्थ, जर तुमचा कॉन्ट्रॅक्ट बाह्य ऑरेकल्सवर अवलंबून असेल, तर उपलब्ध ऑरेकल्सपैकी अर्धे जरी तडजोड केले गेले तरी तो सुरक्षित राहील का? + + - तुमच्या कॉन्ट्रॅक्ट्ससह बाह्य संवादांची चाचणी करण्यासाठी Manticore आणि Echidna सर्वोत्तम पर्याय आहेत. Manticore मध्ये बाह्य कॉन्ट्रॅक्ट्सना स्टब करण्यासाठी एक अंगभूत यंत्रणा आहे. + +- **मानक अनुरूपता.** Ethereum मानकांच्या (उदा., ERC20) डिझाइनमध्ये त्रुटींचा इतिहास आहे. तुम्ही ज्या मानकावर तयार करत आहात त्याच्या मर्यादांबद्दल जागरूक रहा. + - Slither, Echidna, आणि Manticore तुम्हाला दिलेल्या मानकापासून विचलन शोधण्यात मदत करतील. + +### साधन निवड चीटशीट {#tool-selection-cheatsheet} + +| घटक | साधने | उदाहरणे | +| ------------------ | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| स्टेट मशीन | Echidna, Manticore | | +| प्रवेश नियंत्रण | Slither, Echidna, Manticore | [Slither व्यायाम 2](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise2.md), [Echidna व्यायाम 2](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-2.md) | +| अंकगणितीय ऑपरेशन्स | Manticore, Echidna | [Echidna व्यायाम 1](https://github.com/crytic/building-secure-contracts/blob/master/program-analysis/echidna/exercises/Exercise-1.md), [Manticore व्यायाम 1 - 3](https://github.com/crytic/building-secure-contracts/tree/master/program-analysis/manticore/exercises) | +| वारसा अचूकता | Slither | [Slither व्यायाम 1](https://github.com/crytic/slither/blob/7f54c8b948c34fb35e1d61adaa1bd568ca733253/docs/src/tutorials/exercise1.md) | +| बाह्य संवाद | Manticore, Echidna | | +| मानक अनुरूपता | Slither, Echidna, Manticore | [`slither-erc`](https://github.com/crytic/slither/wiki/ERC-Conformance) | + +तुमच्या ध्येयांनुसार इतर क्षेत्रांची तपासणी करणे आवश्यक असेल, परंतु लक्ष केंद्रित करण्याची ही स्थूल-दाणेदार क्षेत्रे कोणत्याही स्मार्ट कॉन्ट्रॅक्ट सिस्टमसाठी एक चांगली सुरुवात आहेत. + +आमच्या सार्वजनिक ऑडिटमध्ये सत्यापित किंवा चाचणी केलेल्या गुणधर्मांची उदाहरणे आहेत. वास्तविक-जगातील सुरक्षा गुणधर्मांचे पुनरावलोकन करण्यासाठी खालील अहवालांमधील `स्वयंचलित चाचणी आणि पडताळणी` विभाग वाचण्याचा विचार करा: + +- [0x](https://github.com/trailofbits/publications/blob/master/reviews/0x-protocol.pdf) +- [Balancer](https://github.com/trailofbits/publications/blob/master/reviews/BalancerCore.pdf) diff --git a/public/content/translations/mr/developers/tutorials/hello-world-smart-contract-fullstack/index.md b/public/content/translations/mr/developers/tutorials/hello-world-smart-contract-fullstack/index.md new file mode 100644 index 00000000000..70432814ee9 --- /dev/null +++ b/public/content/translations/mr/developers/tutorials/hello-world-smart-contract-fullstack/index.md @@ -0,0 +1,1540 @@ +--- +title: "नवशिक्यांसाठी हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट - फुलस्टॅक" +description: "Ethereum वर एक साधे स्मार्ट कॉन्ट्रॅक्ट लिहिण्यावर आणि उपयोजित करण्यावर एक प्रास्ताविक ट्युटोरियल." +author: "nstrike2" +tags: + [ + "सॉलिडिटी", + "hardhat", + "alchemy", + "स्मार्ट कॉन्ट्रॅक्ट", + "डिप्लॉयिंग", + "ब्लॉक एक्सप्लोरर", + "frontend", + "व्यवहार" + ] +skill: beginner +lang: mr +published: 2021-10-25 +--- + +तुम्ही ब्लॉकचेन डेव्हलपमेंटसाठी नवीन असाल आणि तुम्हाला कोठून सुरुवात करावी किंवा स्मार्ट कॉन्ट्रॅक्ट कसे तैनात करावे आणि त्यांच्याशी संवाद कसा साधावा हे माहित नसेल, तर हे मार्गदर्शक तुमच्यासाठी आहे. आम्ही [MetaMask](https://metamask.io), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org), आणि [Alchemy](https://alchemy.com/eth) वापरून Goerli टेस्ट नेटवर्कवर एक साधे, स्मार्ट कॉन्ट्रॅक्ट तयार करणे आणि तैनात करण्याच्या प्रक्रियेतून जाऊ. + +हे ट्युटोरियल पूर्ण करण्यासाठी तुम्हाला Alchemy खात्याची आवश्यकता असेल. [विनामूल्य खात्यासाठी साइन अप करा](https://www.alchemy.com/). + +तुम्हाला कोणत्याही क्षणी प्रश्न असल्यास, [Alchemy Discord](https://discord.gg/gWuC7zB) मध्ये संपर्क साधा! + +## भाग १ - Hardhat वापरून तुमचे स्मार्ट कॉन्ट्रॅक्ट तयार करा आणि तैनात करा {#part-1} + +### Ethereum नेटवर्कशी कनेक्ट करा {#connect-to-the-ethereum-network} + +Ethereum चेनला विनंत्या करण्याचे अनेक मार्ग आहेत. साधेपणासाठी, आम्ही Alchemy वर एक विनामूल्य खाते वापरू, जे एक ब्लॉकचेन डेव्हलपर प्लॅटफॉर्म आणि API आहे, जे आम्हाला स्वतः नोड न चालवता Ethereum चेनशी संवाद साधण्याची परवानगी देते. Alchemy मध्ये देखरेख आणि विश्लेषणासाठी डेव्हलपर टूल्स देखील आहेत; आम्ही या ट्युटोरियलमध्ये आमच्या स्मार्ट कॉन्ट्रॅक्ट तैनातीमध्ये काय चालले आहे हे समजून घेण्यासाठी त्यांचा फायदा घेऊ. + +### तुमचे ॲप आणि API की तयार करा {#create-your-app-and-api-key} + +एकदा तुम्ही Alchemy खाते तयार केल्यावर, तुम्ही ॲप तयार करून API की तयार करू शकता. यामुळे तुम्हाला Goerli टेस्टनेटवर विनंत्या करण्याची परवानगी मिळेल. तुम्ही टेस्टनेटशी परिचित नसल्यास, तुम्ही [नेटवर्क निवडण्याबाबत Alchemy चे मार्गदर्शक](https://www.alchemy.com/docs/choosing-a-web3-network) वाचू शकता. + +Alchemy डॅशबोर्डवर, नेव्हिगेशन बारमधील **ॲप्स** ड्रॉपडाउन शोधा आणि **ॲप तयार करा** वर क्लिक करा. + + + +तुमच्या ॲपला '_Hello World_' असे नाव द्या आणि एक लहान वर्णन लिहा. तुमचे पर्यावरण म्हणून **स्टेजिंग** आणि तुमचे नेटवर्क म्हणून **Goerli** निवडा. + + + +_टीप: **Goerli** निवडण्याची खात्री करा, अन्यथा हे ट्युटोरियल कार्य करणार नाही._ + +**ॲप तयार करा** वर क्लिक करा. तुमचे ॲप खालील टेबलमध्ये दिसेल. + +### एक Ethereum खाते तयार करा {#create-an-ethereum-account} + +तुम्हाला व्यवहार पाठवण्यासाठी आणि प्राप्त करण्यासाठी Ethereum खात्याची आवश्यकता आहे. आम्ही MetaMask वापरू, जो ब्राउझरमधील एक व्हर्च्युअल वॉलेट आहे, जो वापरकर्त्यांना त्यांच्या Ethereum खात्याचा पत्ता व्यवस्थापित करू देतो. + +तुम्ही [येथे](https://metamask.io/download) विनामूल्य MetaMask खाते डाउनलोड आणि तयार करू शकता. तुम्ही खाते तयार करत असताना, किंवा तुमच्याकडे आधीपासूनच खाते असल्यास, वरच्या उजवीकडील “Goerli टेस्ट नेटवर्क” वर स्विच करण्याची खात्री करा (जेणेकरून आपण खऱ्या पैशांशी व्यवहार करत नाही आहोत). + +### पायरी ४: फॉसेटमधून इथर जोडा {#step-4-add-ether-from-a-faucet} + +तुमचे स्मार्ट कॉन्ट्रॅक्ट टेस्ट नेटवर्कवर तैनात करण्यासाठी, तुम्हाला काही बनावट ETH ची आवश्यकता असेल. Goerli नेटवर्कवर ETH मिळवण्यासाठी, Goerli फॉसेटवर जा आणि तुमच्या Goerli खात्याचा पत्ता प्रविष्ट करा. लक्षात ठेवा की Goerli फॉसेट अलीकडे थोडे अविश्वसनीय असू शकतात - प्रयत्न करण्यासाठी पर्यायांची सूची पाहण्यासाठी [टेस्ट नेटवर्क पृष्ठ](/developers/docs/networks/#goerli) पहा: + +_टीप: नेटवर्कमधील गर्दीमुळे, यास थोडा वेळ लागू शकतो._ +`` + +### पायरी 5: तुमची शिल्लक तपासा {#step-5-check-your-balance} + +तुमच्या वॉलेटमध्ये ETH आहे की नाही हे पुन्हा तपासण्यासाठी, चला [Alchemy च्या कंपोझर टूल](https://composer.alchemyapi.io/?composer_state=%7B%22network%22%3A0%2C%22methodName%22%3A%22eth_getBalance%22%2C%22paramValues%22%3A%5B%22%22%2C%22latest%22%5D%7D) वापरून [eth_getBalance](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_getbalance) विनंती करूया. हे आमच्या वॉलेटमधील ETH ची रक्कम परत करेल. अधिक जाणून घेण्यासाठी [कंपोझर टूल कसे वापरावे यावरील Alchemy चे छोटे ट्युटोरियल](https://youtu.be/r6sjRxBZJuU) पहा. + +तुमचा MetaMask खात्याचा पत्ता इनपुट करा आणि **विनंती पाठवा** वर क्लिक करा. तुम्हाला खालील कोड स्निपेटसारखा प्रतिसाद दिसेल. + +```json +{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" } +``` + +> _टीप: हा निकाल ETH मध्ये नाही, तर wei मध्ये आहे. Wei चा वापर इथरच्या सर्वात लहान मूल्यांकनासाठी केला जातो._ + +हुश्श! आपले बनावट पैसे तिथे आहेत. + +### पायरी 6: आपला प्रकल्प सुरू करा {#step-6-initialize-our-project} + +प्रथम, आपल्याला आपल्या प्रकल्पासाठी एक फोल्डर तयार करण्याची आवश्यकता असेल. तुमच्या कमांड लाइनवर नेव्हिगेट करा आणि खालील इनपुट करा. + +``` +mkdir hello-world +cd hello-world +``` + +आता आपण आपल्या प्रोजेक्ट फोल्डरमध्ये आहोत, आपण प्रोजेक्ट सुरू करण्यासाठी `npm init` वापरू. + +> तुमच्याकडे अद्याप npm इंस्टॉल केलेले नसल्यास, [Node.js आणि npm इंस्टॉल करण्यासाठी या सूचनांचे](https://docs.alchemyapi.io/alchemy/guides/alchemy-for-macs#1-install-nodejs-and-npm) पालन करा. + +या ट्युटोरियलच्या उद्देशासाठी, तुम्ही आरंभीकरणाच्या प्रश्नांची उत्तरे कशी देता याने काही फरक पडत नाही. संदर्भासाठी आम्ही ते कसे केले ते येथे आहे: + +``` +पॅकेजचे नाव: (hello-world) +आवृत्ती: (1.0.0) +वर्णन: हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट +एंट्री पॉइंट: (index.js) +चाचणी कमांड: +git रेपॉजिटरी: +कीवर्ड: +लेखक: +परवाना: (ISC) + +/Users/.../.../.../hello-world/package.json मध्ये लिहिणार आहात: + +{ + "name": "hello-world", + "version": "1.0.0", + "description": "हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "author": "", + "license": "ISC" +} +``` + +package.json ला मंजूर करा आणि आपण पुढे जाण्यास तयार आहोत! + +### पायरी 7: Hardhat डाउनलोड करा {#step-7-download-hardhat} + +Hardhat हे तुमचे Ethereum सॉफ्टवेअर संकलित (compile), उपयोजित (deploy), चाचणी (test) आणि डीबग (debug) करण्यासाठी एक विकास वातावरण आहे. हे डेव्हलपर्सना थेट चेनवर उपयोजित करण्यापूर्वी स्थानिक पातळीवर स्मार्ट कॉन्ट्रॅक्ट्स आणि dApps तयार करताना मदत करते. + +आपल्या `hello-world` प्रोजेक्टमध्ये चालवा: + +``` +npm install --save-dev hardhat +``` + +[इन्स्टॉलेशन सूचनांविषयी](https://hardhat.org/getting-started/#overview) अधिक तपशीलांसाठी हे पेज पहा. + +### पायरी 8: Hardhat प्रकल्प तयार करा {#step-8-create-hardhat-project} + +आमच्या `hello-world` प्रकल्प फोल्डरमध्ये, चालवा: + +``` +npx hardhat +``` + +त्यानंतर तुम्हाला एक स्वागत संदेश आणि तुम्हाला काय करायचे आहे यासाठी पर्याय दिसेल. “create an empty hardhat.config.js” निवडा: + +``` +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 + +👷 Hardhat v2.0.11 मध्ये आपले स्वागत आहे 👷 + +तुम्ही काय करू इच्छिता? … +एक नमुना प्रकल्प तयार करा +❯ एक रिक्त hardhat.config.js तयार करा +बाहेर पडा +``` + +हे प्रकल्पात `hardhat.config.js` फाइल तयार करेल. आपण हे नंतर ट्युटोरियलमध्ये आपल्या प्रकल्पासाठी सेटअप निर्दिष्ट करण्यासाठी वापरू. + +### पायरी 9: प्रकल्प फोल्डर जोडा {#step-9-add-project-folders} + +प्रकल्प संघटित ठेवण्यासाठी, चला दोन नवीन फोल्डर तयार करूया. कमांड लाइनमध्ये, तुमच्या `hello-world` प्रकल्पाच्या रूट डिरेक्टरीमध्ये नेव्हिगेट करा आणि टाइप करा: + +``` +mkdir contracts +mkdir scripts +``` + +- `contracts/` मध्ये आपण आपली हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट कोड फाईल ठेवू +- `scripts/` मध्ये आपण आपले कॉन्ट्रॅक्ट उपयोजित करण्यासाठी आणि त्याच्याशी संवाद साधण्यासाठी स्क्रिप्ट्स ठेवू + +### पायरी 10: आमचे कॉन्ट्रॅक्ट लिहा {#step-10-write-our-contract} + +तुम्ही स्वतःला विचारत असाल की, आपण कोड कधी लिहिणार आहोत? वेळ झाली आहे! + +तुमच्या आवडत्या एडिटरमध्ये हॅलो-वर्ल्ड प्रकल्प उघडा. स्मार्ट कॉन्ट्रॅक्ट सामान्यतः Solidity मध्ये लिहिले जातात, जे आपण आपले स्मार्ट कॉन्ट्रॅक्ट लिहिण्यासाठी वापरू. + +1. `contracts` फोल्डरवर नेव्हिगेट करा आणि `HelloWorld.sol` नावाची नवीन फाइल तयार करा +2. खाली एक नमुना हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट आहे जो आपण या ट्युटोरियलसाठी वापरणार आहोत. खालील मजकूर `HelloWorld.sol` फाइलमध्ये कॉपी करा. + +_टीप: हे कॉन्ट्रॅक्ट काय करते हे समजून घेण्यासाठी टिप्पण्या वाचण्याची खात्री करा._ + +``` +// सिमेंटिक व्हर्जनिंग वापरून, Solidity ची आवृत्ती निर्दिष्ट करते. +// अधिक जाणून घ्या: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma +pragma solidity >=0.7.3; + +// `HelloWorld` नावाचे एक कॉन्ट्रॅक्ट परिभाषित करते. +// एक कॉन्ट्रॅक्ट म्हणजे फंक्शन्स आणि डेटा (त्याची स्थिती) यांचा संग्रह. एकदा तैनात झाल्यावर, एक कॉन्ट्रॅक्ट Ethereum ब्लॉकचेनवर एका विशिष्ट पत्त्यावर राहते. अधिक जाणून घ्या: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html +contract HelloWorld { + + //जेव्हा अपडेट फंक्शन कॉल केले जाते तेव्हा उत्सर्जित होते + //स्मार्ट कॉन्ट्रॅक्ट इव्हेंट्स हे तुमच्या कॉन्ट्रॅक्टसाठी तुमच्या ॲपच्या फ्रंट-एंडला ब्लॉकचेनवर काहीतरी घडल्याचे कळवण्याचा एक मार्ग आहे, जे काही विशिष्ट इव्हेंट्ससाठी 'ऐकत' असू शकते आणि ते घडल्यावर कारवाई करू शकते. + event UpdatedMessages(string oldStr, string newStr); + + // `string` प्रकारचा `message` नावाचा एक स्टेट व्हेरिएबल घोषित करते. + // स्टेट व्हेरिएबल्स असे व्हेरिएबल्स आहेत ज्यांची मूल्ये कॉन्ट्रॅक्ट स्टोरेजमध्ये कायमस्वरूपी संग्रहित केली जातात. `public` कीवर्ड व्हेरिएबल्सला कॉन्ट्रॅक्टच्या बाहेरून प्रवेशयोग्य बनवतो आणि एक फंक्शन तयार करतो ज्याला इतर कॉन्ट्रॅक्ट्स किंवा क्लायंट मूल्यामध्ये प्रवेश करण्यासाठी कॉल करू शकतात. + string public message; + + // अनेक वर्ग-आधारित ऑब्जेक्ट-ओरिएंटेड भाषांप्रमाणे, कंस्ट्रक्टर एक विशेष फंक्शन आहे जे फक्त कॉन्ट्रॅक्ट निर्मितीवर कार्यान्वित होते. + // कंस्ट्रक्टरचा वापर कॉन्ट्रॅक्टचा डेटा सुरू करण्यासाठी केला जातो. अधिक जाणून घ्या:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors + constructor(string memory initMessage) { + + // एक स्ट्रिंग युक्तिवाद `initMessage` स्वीकारते आणि कॉन्ट्रॅक्टच्या `message` स्टोरेज व्हेरिएबलमध्ये मूल्य सेट करते). + message = initMessage; + } + + // एक सार्वजनिक फंक्शन जे स्ट्रिंग युक्तिवाद स्वीकारते आणि `message` स्टोरेज व्हेरिएबल अपडेट करते. + function update(string memory newMessage) public { + string memory oldMsg = message; + message = newMessage; + emit UpdatedMessages(oldMsg, newMessage); + } +} +``` + +हे एक मूलभूत स्मार्ट कॉन्ट्रॅक्ट आहे जे निर्मितीच्या वेळी एक संदेश संग्रहित करते. `update` फंक्शनला कॉल करून ते अपडेट केले जाऊ शकते. + +### पायरी 11: MetaMask आणि Alchemy ला तुमच्या प्रकल्पाशी कनेक्ट करा {#step-11-connect-metamask-alchemy-to-your-project} + +आपण MetaMask वॉलेट, Alchemy खाते तयार केले आहे आणि आपले स्मार्ट कॉन्ट्रॅक्ट लिहिले आहे, आता या तिन्हीना जोडण्याची वेळ आली आहे. + +तुमच्या वॉलेटमधून पाठवलेल्या प्रत्येक व्यवहारासाठी तुमच्या युनिक खाजगी की वापरून स्वाक्षरी आवश्यक असते. आमच्या प्रोग्रामला ही परवानगी देण्यासाठी, आम्ही आमची खाजगी की एका पर्यावरण फाइलमध्ये सुरक्षितपणे संग्रहित करू शकतो. आम्ही येथे Alchemy साठी एक API की देखील संग्रहित करू. + +> व्यवहार पाठवण्याबद्दल अधिक जाणून घेण्यासाठी, वेब3 वापरून व्यवहार पाठवण्यावरील [हे ट्युटोरियल](https://www.alchemy.com/docs/hello-world-smart-contract#step-11-connect-metamask--alchemy-to-your-project) पहा. + +प्रथम, तुमच्या प्रोजेक्ट डिरेक्टरीमध्ये dotenv पॅकेज इंस्टॉल करा: + +``` +npm install dotenv --save +``` + +मग, प्रकल्पाच्या रूट डिरेक्टरीमध्ये `.env` फाइल तयार करा. तुमची MetaMask खाजगी की आणि HTTP Alchemy API URL त्यात जोडा. + +तुमच्या पर्यावरण फाइलचे नाव `.env` असणे आवश्यक आहे अन्यथा ती पर्यावरण फाइल म्हणून ओळखली जाणार नाही. + +त्याला `process.env` किंवा `.env-custom` किंवा दुसरे काहीही नाव देऊ नका. + +- तुमची खाजगी की निर्यात करण्यासाठी [या सूचनांचे](https://metamask.zendesk.com/hc/en-us/articles/360015289632-How-to-Export-an-Account-Private-Key) पालन करा +- HTTP Alchemy API URL मिळवण्यासाठी खाली पहा + + + +तुमचे `.env` असे दिसले पाहिजे: + +``` +API_URL = "https://eth-goerli.alchemyapi.io/v2/your-api-key" +PRIVATE_KEY = "your-metamask-private-key" +``` + +हे प्रत्यक्षात आपल्या कोडशी जोडण्यासाठी, आपण या व्हेरिएबल्सचा संदर्भ आपल्या `hardhat.config.js` फाईलमध्ये पायरी १३ वर देऊ. + +### पायरी १२: Ethers.js इंस्टॉल करा {#step-12-install-ethersjs} + +Ethers.js ही एक लायब्ररी आहे जी अधिक वापरकर्ता-अनुकूल पद्धतींसह [मानक JSON-RPC पद्धती](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc) रॅप करून Ethereum शी संवाद साधणे आणि विनंत्या करणे सोपे करते. + +Hardhat आम्हाला अतिरिक्त टूलिंग आणि विस्तारित कार्यक्षमतेसाठी [प्लगइन्स](https://hardhat.org/plugins/) समाकलित करण्याची परवानगी देतो. आम्ही कॉन्ट्रॅक्ट उपयोजनासाठी [Ethers प्लगइन](https://hardhat.org/docs/plugins/official-plugins#hardhat-ethers) चा फायदा घेऊ. + +आपल्या प्रोजेक्ट डिरेक्टरीमध्ये टाइप करा: + +```bash +npm install --save-dev @nomiclabs/hardhat-ethers "ethers@^5.0.0" +``` + +### पायरी 13: hardhat.config.js अपडेट करा {#step-13-update-hardhat-configjs} + +आतापर्यंत आपण अनेक डिपेंडेंसी आणि प्लगइन जोडले आहेत, आता आपल्याला `hardhat.config.js` अद्यतनित करण्याची आवश्यकता आहे जेणेकरून आपल्या प्रोजेक्टला त्या सर्वांबद्दल माहिती मिळेल. + +तुमचे `hardhat.config.js` याप्रमाणे दिसण्यासाठी अद्यतनित करा: + +```javascript +/** + * @type import('hardhat/config').HardhatUserConfig + */ + +require("dotenv").config() +require("@nomiclabs/hardhat-ethers") + +const { API_URL, PRIVATE_KEY } = process.env + +module.exports = { + solidity: "0.7.3", + defaultNetwork: "goerli", + networks: { + hardhat: {}, + goerli: { + url: API_URL, + accounts: [`0x${PRIVATE_KEY}`], + }, + }, +} +``` + +### पायरी 14: आमचे कॉन्ट्रॅक्ट कंपाईल करा {#step-14-compile-our-contract} + +आतापर्यंत सर्व काही कार्यरत आहे याची खात्री करण्यासाठी, चला आमचा कॉन्ट्रॅक्ट संकलित करूया. `compile` कार्य हे बिल्ट-इन हार्डहॅट कार्यांपैकी एक आहे. + +कमांड लाइनमधून चालवा: + +```bash +npx hardhat compile +``` + +तुम्हाला `SPDX license identifier not provided in source file` बद्दल चेतावणी मिळू शकते, परंतु त्याबद्दल काळजी करण्याची गरज नाही — आशा आहे की इतर सर्व काही चांगले दिसेल! नसल्यास, तुम्ही नेहमी [Alchemy discord](https://discord.gg/u72VCg3) मध्ये संदेश पाठवू शकता. + +### पायरी 15: आमची उपयोजन स्क्रिप्ट लिहा {#step-15-write-our-deploy-script} + +आता आमचा कॉन्ट्रॅक्ट लिहिला आहे आणि आमची कॉन्फिगरेशन फाइल तयार आहे, आता आमच्या कॉन्ट्रॅक्टची उपयोजन स्क्रिप्ट लिहिण्याची वेळ आली आहे. + +`scripts/` फोल्डरवर नेव्हिगेट करा आणि `deploy.js` नावाची एक नवीन फाइल तयार करा, त्यात खालील सामग्री जोडा: + +```javascript +async function main() { + const HelloWorld = await ethers.getContractFactory("HelloWorld") + + // उपयोजन सुरू करा, एक प्रॉमिस परत करा जे कॉन्ट्रॅक्ट ऑब्जेक्टमध्ये निराकरण करते + const hello_world = await HelloWorld.deploy("Hello World!") + console.log("Contract deployed to address:", hello_world.address) +} + +main() + .then(() => process.exit(0)) + .catch((error) => { + console.error(error) + process.exit(1) + }) +``` + +Hardhat त्यांच्या [कॉन्ट्रॅक्ट्स ट्यूटोरियल](https://hardhat.org/tutorial/testing-contracts.html#writing-tests) मध्ये या प्रत्येक कोड ओळी काय करते हे आश्चर्यकारकपणे स्पष्ट करते, आम्ही त्यांचे स्पष्टीकरण येथे स्वीकारले आहे. + +```javascript +const HelloWorld = await ethers.getContractFactory("HelloWorld") +``` + +ethers.js मधील `ContractFactory` हे नवीन स्मार्ट कॉन्ट्रॅक्ट्स तैनात करण्यासाठी वापरले जाणारे एक ॲबस्ट्रॅक्शन आहे, म्हणून येथे `HelloWorld` हे आमच्या हॅलो वर्ल्ड कॉन्ट्रॅक्टच्या उदाहरणांसाठी एक [फॅक्टरी](https://en.wikipedia.org/wiki/Factory_\(object-oriented_programming\)) आहे. `hardhat-ethers` प्लगइन वापरताना `ContractFactory` आणि `Contract`, उदाहरणे डीफॉल्टनुसार पहिल्या स्वाक्षरीकर्त्याशी (मालक) जोडलेली असतात. + +```javascript +const hello_world = await HelloWorld.deploy() +``` + +`ContractFactory` वर `deploy()` कॉल केल्याने उपयोजन सुरू होईल आणि एक `Promise` परत येईल जो `Contract` ऑब्जेक्टमध्ये निराकरण करतो. हे ते ऑब्जेक्ट आहे ज्यामध्ये आमच्या प्रत्येक स्मार्ट कॉन्ट्रॅक्ट फंक्शनसाठी एक पद्धत आहे. + +### पायरी १६: आपले कॉन्ट्रॅक्ट उपयोजित करा {#step-16-deploy-our-contract} + +आम्ही अखेरीस आमचा स्मार्ट कॉन्ट्रॅक्ट उपयोजित करण्यास तयार आहोत! कमांड लाइनवर नेव्हिगेट करा आणि चालवा: + +```bash +npx hardhat run scripts/deploy.js --network goerli +``` + +तुम्हाला त्यानंतर असे काहीतरी दिसेल: + +```bash +Contract deployed to address: 0x6cd7d44516a20882cEa2DE9f205bF401c0d23570 +``` + +**कृपया हा पत्ता सेव्ह करा**. आम्ही ट्युटोरियलमध्ये नंतर याचा वापर करू. + +जर आपण [Goerli etherscan](https://goerli.etherscan.io) वर गेलो आणि आपला कॉन्ट्रॅक्ट पत्ता शोधला तर आपण पाहू शकू की ते यशस्वीरित्या तैनात केले गेले आहे. व्यवहार असा काहीतरी दिसेल: + + + +`From` पत्ता तुमच्या MetaMask खात्याच्या पत्त्याशी जुळला पाहिजे आणि `To` पत्त्यावर **कॉन्ट्रॅक्ट निर्मिती** असे लिहिलेले असेल. जर आपण व्यवहारात क्लिक केले तर आपल्याला `To` फील्डमध्ये आपला कॉन्ट्रॅक्ट पत्ता दिसेल. + + + +अभिनंदन! तुम्ही नुकतेच Ethereum टेस्टनेटवर एक स्मार्ट कॉन्ट्रॅक्ट तैनात केले आहे. + +पडद्यामागे काय चालले आहे हे समजून घेण्यासाठी, चला आपल्या [Alchemy डॅशबोर्ड](https://dashboard.alchemy.com/explorer) मधील एक्सप्लोरर टॅबवर नेव्हिगेट करूया. तुमच्याकडे एकापेक्षा जास्त Alchemy ॲप्स असल्यास ॲपनुसार फिल्टर करा आणि **Hello World** निवडा. + + + +येथे तुम्हाला काही JSON-RPC पद्धती दिसतील ज्या Hardhat/Ethers ने `.deploy()` फंक्शन कॉल केल्यावर आपल्यासाठी पडद्यामागे बनवल्या आहेत. येथे दोन महत्त्वाच्या पद्धती आहेत [`eth_sendRawTransaction`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_sendrawtransaction), जे आमचे कॉन्ट्रॅक्ट Goerli चेनवर लिहिण्याची विनंती आहे, आणि [`eth_getTransactionByHash`](https://docs.alchemyapi.io/alchemy/documentation/alchemy-api-reference/json-rpc#eth_gettransactionbyhash), जे हॅश दिल्यावर आमच्या व्यवहाराबद्दल माहिती वाचण्याची विनंती आहे. व्यवहार पाठवण्याबद्दल अधिक जाणून घेण्यासाठी, [Web3 वापरून व्यवहार पाठवण्यावरील आमचे ट्युटोरियल](/developers/tutorials/sending-transactions-using-web3-and-alchemy/) पहा. + +## भाग २: तुमच्या स्मार्ट कॉन्ट्रॅक्टशी संवाद साधा {#part-2-interact-with-your-smart-contract} + +आता आपण यशस्वीरित्या Goerli नेटवर्कवर एक स्मार्ट कॉन्ट्रॅक्ट तैनात केले आहे, चला त्याच्याशी संवाद कसा साधायचा हे शिकूया. + +### एक interact.js फाइल तयार करा {#create-a-interactjs-file} + +ही ती फाईल आहे जिथे आपण आपली संवाद स्क्रिप्ट लिहू. आम्ही Ethers.js लायब्ररी वापरणार आहोत जी तुम्ही आधी भाग १ मध्ये इन्स्टॉल केली होती. + +`scripts/` फोल्डरमध्ये, `interact.js` नावाची नवीन फाइल तयार करा आणि खालील कोड जोडा: + +```javascript +// interact.js + +const API_KEY = process.env.API_KEY +const PRIVATE_KEY = process.env.PRIVATE_KEY +const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS +``` + +### तुमची .env फाईल अपडेट करा {#update-your-env-file} + +आम्ही नवीन पर्यावरण व्हेरिएबल्स वापरणार आहोत, म्हणून आम्हाला त्यांना `.env` फाइलमध्ये परिभाषित करणे आवश्यक आहे जी [आम्ही आधी तयार केली होती](#step-11-connect-metamask-&-alchemy-to-your-project). + +आम्हाला आमच्या Alchemy `API_KEY` आणि `CONTRACT_ADDRESS` साठी एक परिभाषा जोडावी लागेल जिथे तुमचे स्मार्ट कॉन्ट्रॅक्ट तैनात केले होते. + +तुमची `.env` फाइल अशी काहीतरी दिसली पाहिजे: + +```bash +# .env + +API_URL = "https://eth-goerli.alchemyapi.io/v2/
+ 
+
+
+
+)
+```
+
+तुम्ही हा कोड काळजीपूर्वक स्कॅन केल्यास, तुम्हाला दिसेल की आम्ही आमच्या UI मध्ये आमचे विविध स्टेट व्हेरिएबल्स कुठे वापरतो:
+
+- ओळी ६-१२ वर, जर वापरकर्त्याचे वॉलेट कनेक्ट केलेले असेल (म्हणजे, `walletAddress.length > 0`), तर आम्ही "walletButton" आयडी असलेल्या बटणामध्ये वापरकर्त्याच्या `walletAddress` ची एक संक्षिप्त आवृत्ती प्रदर्शित करतो; अन्यथा ते फक्त "वॉलेट कनेक्ट करा" असे म्हणते.
+- ओळ १७ वर, आम्ही स्मार्ट कॉन्ट्रॅक्टमध्ये संग्रहित केलेला सध्याचा संदेश प्रदर्शित करतो, जो `message` स्ट्रिंगमध्ये कॅप्चर केला जातो.
+- ओळी २३-२६ वर, टेक्स्ट फील्डमधील इनपुट बदलल्यावर आमचे `newMessage` स्टेट व्हेरिएबल अपडेट करण्यासाठी आम्ही [नियंत्रित घटक](https://legacy.reactjs.org/docs/forms.html#controlled-components) वापरतो.
+
+आमच्या स्टेट व्हेरिएबल्स व्यतिरिक्त, तुम्हाला दिसेल की `publishButton` आणि `walletButton` आयडी असलेली बटणे क्लिक केल्यावर अनुक्रमे `connectWalletPressed` आणि `onUpdatePressed` फंक्शन्स कॉल केली जातात.
+
+शेवटी, चला पाहूया की हा `HelloWorld.js` घटक कुठे जोडला आहे.
+
+तुम्ही `App.js` फाइलवर गेल्यास, जी React मधील मुख्य घटक आहे जी इतर सर्व घटकांसाठी कंटेनर म्हणून काम करते, तुम्हाला दिसेल की आमचा `HelloWorld.js` घटक ओळ ७ वर इंजेक्ट केला आहे.
+
+शेवटचे पण महत्त्वाचे, चला तुमच्यासाठी प्रदान केलेली आणखी एक फाइल पाहूया, `interact.js` फाइल.
+
+#### `interact.js` फाइल {#the-interact-js-file}
+
+कारण आम्हाला [M-V-C](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) पॅराडाइमचे पालन करायचे आहे, आम्हाला एक वेगळी फाइल हवी आहे ज्यात आमच्या डॅपच्या तर्कशास्त्र, डेटा आणि नियमांचे व्यवस्थापन करण्यासाठी आमची सर्व फंक्शन्स असतील, आणि नंतर ती फंक्शन्स आमच्या फ्रंटएंडवर (आमचा `HelloWorld.js` घटक) निर्यात करता येतील.
+
+👆🏽हाच आमच्या `interact.js` फाइलचा नेमका उद्देश आहे!
+
+तुमच्या `src` डिरेक्टरीमधील `util` फोल्डरवर नेव्हिगेट करा, आणि तुम्हाला दिसेल की आम्ही `interact.js` नावाची फाइल समाविष्ट केली आहे ज्यात आमची सर्व स्मार्ट कॉन्ट्रॅक्ट संवाद आणि वॉलेट फंक्शन्स आणि व्हेरिएबल्स असतील.
+
+```javascript
+// interact.js
+
+//export const helloWorldContract;
+
+export const loadCurrentMessage = async () => {}
+
+export const connectWallet = async () => {}
+
+const getCurrentWalletConnected = async () => {}
+
+export const updateMessage = async (message) => {}
+```
+
+तुम्हाला फाइलच्या शीर्षस्थानी दिसेल की आम्ही `helloWorldContract` ऑब्जेक्टवर टिप्पणी केली आहे. नंतर या ट्युटोरियलमध्ये, आम्ही या ऑब्जेक्टवरील टिप्पणी काढून टाकू आणि या व्हेरिएबलमध्ये आमचे स्मार्ट कॉन्ट्रॅक्ट इन्स्टँटिएट करू, जे आम्ही नंतर आमच्या `HelloWorld.js` घटकामध्ये निर्यात करू.
+
+आमच्या `helloWorldContract` ऑब्जेक्टनंतरची चार अंमलबजावणी न केलेली फंक्शन्स खालीलप्रमाणे करतात:
+
+- `loadCurrentMessage` - हे फंक्शन स्मार्ट कॉन्ट्रॅक्टमध्ये संग्रहित केलेला सध्याचा संदेश लोड करण्याच्या तर्कशास्त्राचे व्यवस्थापन करते. ते [Alchemy Web3 API](https://github.com/alchemyplatform/alchemy-web3) वापरून हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्टला _वाचण्याचा_ कॉल करेल.
+- `connectWallet` - हे फंक्शन वापरकर्त्याचे MetaMask आमच्या डॅपशी कनेक्ट करेल.
+- `getCurrentWalletConnected` - हे फंक्शन तपासेल की Ethereum खाते आधीपासूनच आमच्या डॅपशी पेज लोडवर कनेक्ट केलेले आहे की नाही आणि त्यानुसार आमचे UI अपडेट करेल.
+- `updateMessage` - हे फंक्शन स्मार्ट कॉन्ट्रॅक्टमध्ये संग्रहित केलेला संदेश अपडेट करेल. हे हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्टला _लिहिण्याचा_ कॉल करेल, त्यामुळे वापरकर्त्याच्या MetaMask वॉलेटला संदेश अपडेट करण्यासाठी Ethereum व्यवहारावर स्वाक्षरी करावी लागेल.
+
+आता आम्हाला समजले आहे की आम्ही कशावर काम करत आहोत, चला पाहूया की आमच्या स्मार्ट कॉन्ट्रॅक्टमधून कसे वाचायचे!
+
+### पायरी ३: तुमच्या स्मार्ट कॉन्ट्रॅक्टमधून वाचा {#step-3-read-from-your-smart-contract}
+
+तुमच्या स्मार्ट कॉन्ट्रॅक्टमधून वाचण्यासाठी, तुम्हाला यशस्वीरित्या सेट अप करावे लागेल:
+
+- Ethereum चेनशी एक API कनेक्शन
+- तुमच्या स्मार्ट कॉन्ट्रॅक्टचे एक लोड केलेले उदाहरण
+- तुमच्या स्मार्ट कॉन्ट्रॅक्ट फंक्शनला कॉल करण्यासाठी एक फंक्शन
+- तुम्ही स्मार्ट कॉन्ट्रॅक्टमधून वाचत असलेल्या डेटामध्ये बदल झाल्यावर अपडेट्ससाठी पाहण्यासाठी एक श्रोता
+
+हे खूप पायऱ्या वाटू शकतात, पण काळजी करू नका! आम्ही तुम्हाला त्या प्रत्येक पायरीतून कसे जायचे हे टप्प्याटप्प्याने सांगू! :\)
+
+#### Ethereum चेनशी एक API कनेक्शन स्थापित करा {#establish-an-api-connection-to-the-ethereum-chain}
+
+तर लक्षात आहे का, या ट्युटोरियलच्या भाग २ मध्ये, आम्ही आमच्या स्मार्ट कॉन्ट्रॅक्टमधून वाचण्यासाठी आमची [Alchemy Web3 की वापरली होती](https://docs.alchemy.com/alchemy/tutorials/hello-world-smart-contract/interacting-with-a-smart-contract#step-1-install-web3-library)? तुमच्या डॅपमध्ये चेनवरून वाचण्यासाठी तुम्हाला Alchemy Web3 की ची देखील आवश्यकता असेल.
+
+तुमच्याकडे आधीपासून नसल्यास, प्रथम [Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) इन्स्टॉल करा, तुमच्या `starter-files` च्या रूट डिरेक्टरीवर नेव्हिगेट करून आणि तुमच्या टर्मिनलमध्ये खालील चालवून:
+
+```text
+npm install @alch/alchemy-web3
+```
+
+[Alchemy Web3](https://github.com/alchemyplatform/alchemy-web3) हे [Web3.js](https://docs.web3js.org/) च्या सभोवतालचे एक रॅपर आहे, जे एक वेब3 डेव्हलपर म्हणून तुमचे जीवन सोपे करण्यासाठी वर्धित API पद्धती आणि इतर महत्त्वपूर्ण फायदे प्रदान करते. हे कमीत कमी कॉन्फिगरेशन आवश्यक करण्यासाठी डिझाइन केलेले आहे जेणेकरून आपण आपल्या ॲपमध्ये लगेचच त्याचा वापर सुरू करू शकता!
+
+मग, तुमच्या प्रकल्प डिरेक्टरीमध्ये [dotenv](https://www.npmjs.com/package/dotenv) पॅकेज इन्स्टॉल करा, जेणेकरून आम्ही आमची API की मिळवल्यानंतर ती संग्रहित करण्यासाठी आमच्याकडे एक सुरक्षित जागा असेल.
+
+```text
+npm install dotenv --save
+```
+
+आमच्या डॅपसाठी, **आम्ही आमची HTTP API की ऐवजी आमची Websockets API की वापरणार आहोत**, कारण ते आम्हाला एक श्रोता सेट करण्याची परवानगी देईल जो स्मार्ट कॉन्ट्रॅक्टमध्ये संग्रहित केलेला संदेश बदलल्यावर ओळखतो.
+
+एकदा तुमच्याकडे तुमची API की आल्यावर, तुमच्या रूट डिरेक्टरीमध्ये `.env` फाइल तयार करा आणि त्यात तुमची Alchemy Websockets url जोडा. त्यानंतर, तुमची `.env` फाइल अशी दिसेल:
+
+```javascript
+REACT_APP_ALCHEMY_KEY = wss://eth-goerli.ws.alchemyapi.io/v2/Current Message:
+{message}
+ +New Message:
+ +
+ setNewMessage(e.target.value)}
+ value={newMessage}
+ />
+
+
+{status}
+ + ++ {" "} + 🦊 + तुम्ही तुमच्या ब्राउझरमध्ये MetaMask, एक व्हर्च्युअल Ethereum वॉलेट, इंस्टॉल करणे आवश्यक आहे. + +
+ + ), + } + } +} +``` + +तर या मोठ्या कोड ब्लॉकचा नेमका काय उपयोग आहे? + +बरं, प्रथम, ते तुमच्या ब्राउझरमध्ये `window.ethereum` सक्षम आहे की नाही हे तपासते. + +`window.ethereum` हे MetaMask आणि इतर वॉलेट प्रदात्यांद्वारे इंजेक्ट केलेले एक ग्लोबल API आहे जे वेबसाइट्सना वापरकर्त्यांच्या Ethereum खात्यांची विनंती करण्याची परवानगी देते. मंजूर झाल्यास, ते वापरकर्ता कनेक्ट केलेल्या ब्लॉकचेनमधून डेटा वाचू शकते, आणि वापरकर्त्याला संदेश आणि व्यवहारांवर स्वाक्षरी करण्याचे सुचवू शकते. अधिक माहितीसाठी [MetaMask डॉक्स](https://docs.metamask.io/guide/ethereum-provider.html#table-of-contents) तपासा! + +जर `window.ethereum` उपस्थित _नसेल_, तर याचा अर्थ MetaMask स्थापित नाही. यामुळे एक JSON ऑब्जेक्ट परत येतो, जिथे परत केलेला `address` एक रिकामा स्ट्रिंग असतो आणि `status` JSX ऑब्जेक्ट वापरकर्त्याला MetaMask स्थापित करणे आवश्यक असल्याचे सांगतो. + +आता जर `window.ethereum` उपस्थित _असेल_, तर गोष्टी मनोरंजक होतात. + +try/catch लूप वापरून, आम्ही [`window.ethereum.request({ method: "eth_requestAccounts" });`](https://docs.metamask.io/guide/rpc-api.html#eth-requestaccounts) कॉल करून MetaMask शी कनेक्ट करण्याचा प्रयत्न करू. हे फंक्शन कॉल केल्याने ब्राउझरमध्ये MetaMask उघडेल, जिथे वापरकर्त्याला त्यांचे वॉलेट तुमच्या dapp शी कनेक्ट करण्यास सांगितले जाईल. + +- जर वापरकर्त्याने कनेक्ट करणे निवडले, तर `method: "eth_requestAccounts"` एक ॲरे परत करेल ज्यात डॅपशी कनेक्ट केलेल्या वापरकर्त्याच्या सर्व खात्यांचे पत्ते असतील. एकूणच, आमचे `connectWallet` फंक्शन एक JSON ऑब्जेक्ट परत करेल ज्यात या ॲरेमधील _पहिला_ `address` (ओळ 9 पहा) आणि एक `status` संदेश असेल जो वापरकर्त्याला स्मार्ट कॉन्ट्रॅक्टला संदेश लिहिण्यास सांगेल. +- जर वापरकर्त्याने कनेक्शन नाकारले, तर JSON ऑब्जेक्टमध्ये परत केलेल्या `address` साठी एक रिकामा स्ट्रिंग आणि एक `status` संदेश असेल जो वापरकर्त्याने कनेक्शन नाकारले असल्याचे दर्शवेल. + +आता आम्ही हे `connectWallet` फंक्शन लिहिले आहे, पुढची पायरी म्हणजे ते आमच्या `HelloWorld.js` घटकामध्ये कॉल करणे. + +#### `connectWallet` फंक्शन तुमच्या `HelloWorld.js` UI घटकामध्ये जोडा {#add-the-connectWallet-function-to-your-HelloWorld-js-ui-component} + +`HelloWorld.js` मधील `connectWalletPressed` फंक्शनवर नेव्हिगेट करा, आणि ते खालीलप्रमाणे अपडेट करा: + +```javascript +// HelloWorld.js + +const connectWalletPressed = async () => { + const walletResponse = await connectWallet() + setStatus(walletResponse.status) + setWallet(walletResponse.address) +} +``` + +आमच्या `HelloWorld.js` घटकामधून `interact.js` फाइलमधून आमची बहुतेक कार्यक्षमता कशी दूर केली जाते हे लक्षात घ्या? हे असे आहे की आम्ही M-V-C पॅराडाइमचे पालन करतो! + +`connectWalletPressed` मध्ये, आम्ही फक्त आमच्या आयात केलेल्या `connectWallet` फंक्शनला एक await कॉल करतो आणि त्याच्या प्रतिसादाचा वापर करून, आम्ही आमचे `status` आणि `walletAddress` व्हेरिएबल्स त्यांच्या स्टेट हुक्सद्वारे अपडेट करतो. + +आता, चला दोन्ही फायली (`HelloWorld.js` आणि `interact.js`) सेव्ह करूया आणि आतापर्यंत आमच्या UI ची चाचणी घेऊया. + +तुमचा ब्राउझर [http://localhost:3000/](http://localhost:3000/) पेजवर उघडा, आणि पेजच्या वरच्या उजवीकडील "वॉलेट कनेक्ट करा" बटण दाबा. + +तुमच्याकडे MetaMask स्थापित असल्यास, तुम्हाला तुमचे वॉलेट तुमच्या dapp शी जोडण्यास सांगितले जाईल. कनेक्ट करण्याची आमंत्रणे स्वीकारा. + +तुम्हाला दिसेल की वॉलेट बटण आता तुमचा पत्ता कनेक्ट झाला आहे हे दर्शवते! व्वा 🔥 + +पुढे, पृष्ठ रिफ्रेश करण्याचा प्रयत्न करा... हे विचित्र आहे. आमचे वॉलेट बटण आम्हाला MetaMask कनेक्ट करण्यास सांगत आहे, जरी ते आधीच कनेक्ट केलेले असले तरी... + +तथापि, घाबरू नका! आम्ही ते सहजपणे सोडवू शकतो (समजले?) `getCurrentWalletConnected` अंमलात आणून, जे तपासेल की पत्ता आधीपासूनच आमच्या डॅपशी कनेक्ट केलेला आहे की नाही आणि त्यानुसार आमचे UI अपडेट करेल! + +#### `getCurrentWalletConnected` फंक्शन {#the-getcurrentwalletconnected-function} + +`interact.js` फाइलमधील तुमचे `getCurrentWalletConnected` फंक्शन खालीलप्रमाणे अपडेट करा: + +```javascript +// interact.js + +export const getCurrentWalletConnected = async () => { + if (window.ethereum) { + try { + const addressArray = await window.ethereum.request({ + method: "eth_accounts", + }) + if (addressArray.length > 0) { + return { + address: addressArray[0], + status: "👆🏽 वरील टेक्स्ट-फील्डमध्ये एक संदेश लिहा.", + } + } else { + return { + address: "", + status: "🦊 वरच्या उजव्या बटणाचा वापर करून MetaMask शी कनेक्ट करा.", + } + } + } catch (err) { + return { + address: "", + status: "😥 " + err.message, + } + } + } else { + return { + address: "", + status: ( + ++ {" "} + 🦊 + तुम्ही तुमच्या ब्राउझरमध्ये MetaMask, एक व्हर्च्युअल Ethereum वॉलेट, इंस्टॉल करणे आवश्यक आहे. + +
+ + ), + } + } +} +``` + +हा कोड आम्ही मागील पायरीमध्ये लिहिलेल्या `connectWallet` फंक्शनसारखाच _खूप_ आहे. + +मुख्य फरक असा आहे की `eth_requestAccounts` या पद्धतीला कॉल करण्याऐवजी, जे वापरकर्त्याला त्यांचे वॉलेट कनेक्ट करण्यासाठी MetaMask उघडते, येथे आपण `eth_accounts` ही पद्धत कॉल करतो, जी सध्या आपल्या dapp शी कनेक्ट केलेल्या MetaMask ॲड्रेसची एक ॲरे परत करते. + +हे फंक्शन कृतीत पाहण्यासाठी, चला ते आमच्या `HelloWorld.js` घटकाच्या `useEffect` फंक्शनमध्ये कॉल करूया: + +```javascript +// HelloWorld.js + +useEffect(async () => { + const message = await loadCurrentMessage() + setMessage(message) + addSmartContractListener() + + const { address, status } = await getCurrentWalletConnected() + setWallet(address) + setStatus(status) +}, []) +``` + +लक्षात घ्या, आम्ही आमच्या `getCurrentWalletConnected` च्या कॉलच्या प्रतिसादाचा वापर आमचे `walletAddress` आणि `status` स्टेट व्हेरिएबल्स अपडेट करण्यासाठी करतो. + +आता तुम्ही हा कोड जोडला आहे, चला आमचे ब्राउझर विंडो रिफ्रेश करून पाहूया. + +छान! बटण तुम्हाला कनेक्ट झाल्याचे सांगेल आणि तुमच्या कनेक्ट केलेल्या वॉलेटच्या ॲड्रेसचे पूर्वावलोकन दाखवेल - जरी तुम्ही रिफ्रेश केले तरी! + +#### `addWalletListener` अंमलात आणा {#implement-addwalletlistener} + +आमच्या dapp वॉलेट सेटअपमधील शेवटची पायरी म्हणजे वॉलेट लिसनर लागू करणे जेणेकरून आमच्या वॉलेटची स्थिती बदलल्यावर आमचे UI अपडेट होईल, जसे की वापरकर्ता डिस्कनेक्ट झाल्यावर किंवा खाती बदलल्यावर. + +तुमच्या `HelloWorld.js` फाइलमध्ये, तुमचे `addWalletListener` फंक्शन खालीलप्रमाणे सुधारित करा: + +```javascript +// HelloWorld.js + +function addWalletListener() { + if (window.ethereum) { + window.ethereum.on("accountsChanged", (accounts) => { + if (accounts.length > 0) { + setWallet(accounts[0]) + setStatus("👆🏽 वरील टेक्स्ट-फील्डमध्ये एक संदेश लिहा.") + } else { + setWallet("") + setStatus("🦊 वरच्या उजव्या बटणाचा वापर करून MetaMask शी कनेक्ट करा.") + } + }) + } else { + setStatus( ++ {" "} + 🦊 + तुम्ही तुमच्या ब्राउझरमध्ये MetaMask, एक व्हर्च्युअल Ethereum वॉलेट, इंस्टॉल करणे आवश्यक आहे. + +
+ ) + } +} +``` + +मला खात्री आहे की तुम्हाला या टप्प्यावर काय चालले आहे हे समजून घेण्यासाठी आमच्या मदतीची गरज नाही, परंतु संपूर्णतेच्या उद्देशाने, चला ते पटकन पाहूया: + +- प्रथम, आमचे फंक्शन तपासते की `window.ethereum` सक्षम आहे का (म्हणजे MetaMask स्थापित आहे का). + - जर ते नसेल, तर आम्ही फक्त आमचे `status` स्टेट व्हेरिएबल एका JSX स्ट्रिंगवर सेट करतो जे वापरकर्त्याला MetaMask स्थापित करण्यास सांगते. + - जर ते सक्षम असेल, तर आम्ही ओळ 3 वर `window.ethereum.on("accountsChanged")` हा लिसनर सेट करतो जो MetaMask वॉलेटमधील स्टेट बदलांसाठी ऐकतो, ज्यात वापरकर्ता dapp शी अतिरिक्त खाते जोडतो, खाती बदलतो किंवा खाते डिस्कनेक्ट करतो. जर किमान एक खाते कनेक्ट केलेले असेल, तर `walletAddress` स्टेट व्हेरिएबल लिसनरद्वारे परत केलेल्या `accounts` ॲरेमधील पहिले खाते म्हणून अपडेट केले जाते. अन्यथा, `walletAddress` एक रिकामा स्ट्रिंग म्हणून सेट केला जातो. + +शेवटचे पण महत्त्वाचे, आम्ही ते आमच्या `useEffect` फंक्शनमध्ये कॉल करणे आवश्यक आहे: + +```javascript +// HelloWorld.js + +useEffect(async () => { + const message = await loadCurrentMessage() + setMessage(message) + addSmartContractListener() + + const { address, status } = await getCurrentWalletConnected() + setWallet(address) + setStatus(status) + + addWalletListener() +}, []) +``` + +आणि झाले! आम्ही आमच्या सर्व वॉलेट कार्यक्षमतेचे प्रोग्रामिंग यशस्वीरित्या पूर्ण केले आहे! आता आमच्या शेवटच्या कार्याकडे: आमच्या स्मार्ट कॉन्ट्रॅक्टमध्ये संग्रहित केलेला संदेश अपडेट करणे! + +### पायरी ६: `updateMessage` फंक्शन अंमलात आणा {#step-6-implement-the-updateMessage-function} + +ठीक आहे मित्रांनो, आपण अंतिम टप्प्यात आलो आहोत! तुमच्या `interact.js` फाइलच्या `updateMessage` मध्ये, आम्ही खालील गोष्टी करणार आहोत: + +1. आम्हाला आमच्या स्मार्ट संपर्कात प्रकाशित करायचा असलेला संदेश वैध असल्याची खात्री करा +2. MetaMask वापरून आमच्या व्यवहारावर स्वाक्षरी करा +3. या फंक्शनला आमच्या `HelloWorld.js` फ्रंटएंड घटकामधून कॉल करा + +याला जास्त वेळ लागणार नाही; चला हा डॅप पूर्ण करूया! + +#### इनपुट एरर हाताळणी {#input-error-handling} + +स्वाभाविकच, फंक्शनच्या सुरुवातीला काही प्रकारचे इनपुट त्रुटी हाताळणी असणे अर्थपूर्ण आहे. + +आम्ही इच्छितो की जर MetaMask विस्तार स्थापित नसेल, कोणतेही वॉलेट कनेक्ट केलेले नसेल (म्हणजे, पास केलेला `address` एक रिकामा स्ट्रिंग आहे), किंवा `message` एक रिकामा स्ट्रिंग असेल तर आमचे फंक्शन लवकर परत यावे. चला `updateMessage` मध्ये खालील त्रुटी हाताळणी जोडूया: + +```javascript +// interact.js + +export const updateMessage = async (address, message) => { + if (!window.ethereum || address === null) { + return { + status: + "💡 ब्लॉकचेनवरील संदेश अपडेट करण्यासाठी तुमचे MetaMask वॉलेट कनेक्ट करा.", + } + } + + if (message.trim() === "") { + return { + status: "❌ तुमचा संदेश रिकामा स्ट्रिंग असू शकत नाही.", + } + } +} +``` + +आता त्यात योग्य इनपुट त्रुटी हाताळणी आहे, MetaMask द्वारे व्यवहारावर स्वाक्षरी करण्याची वेळ आली आहे! + +#### आमच्या व्यवहारावर स्वाक्षरी करणे {#signing-our-transaction} + +तुम्ही आधीपासूनच पारंपरिक वेब3 Ethereum व्यवहारांशी परिचित असाल, तर आम्ही पुढे लिहिणारा कोड खूप परिचित असेल. तुमच्या इनपुट त्रुटी हाताळणी कोडच्या खाली, `updateMessage` मध्ये खालील जोडा: + +```javascript +// interact.js + +//व्यवहार पॅरामीटर्स सेट करा +const transactionParameters = { + to: contractAddress, // कॉन्ट्रॅक्ट प्रकाशनांशिवाय आवश्यक. + from: address, // वापरकर्त्याच्या सक्रिय पत्त्याशी जुळले पाहिजे. + data: helloWorldContract.methods.update(message).encodeABI(), +} + +//व्यवहारावर स्वाक्षरी करा +try { + const txHash = await window.ethereum.request({ + method: "eth_sendTransaction", + params: [transactionParameters], + }) + return { + status: ( + + ✅{" "} + + Etherscan वर तुमच्या व्यवहाराची स्थिती पहा! + ++ ℹ️ एकदा नेटवर्कद्वारे व्यवहाराची पडताळणी झाल्यावर, संदेश आपोआप अपडेट होईल. + + ), + } +} catch (error) { + return { + status: "😥 " + error.message, + } +} +``` + +चला पाहूया की काय चालले आहे. प्रथम, आम्ही आमचे व्यवहार पॅरामीटर्स सेट करतो, जिथे: + +- `to` प्राप्तकर्ता ॲड्रेस (आमचा स्मार्ट कॉन्ट्रॅक्ट) निर्दिष्ट करतो +- `from` व्यवहाराच्या स्वाक्षरीकर्त्याला निर्दिष्ट करते, आम्ही आमच्या फंक्शनमध्ये पास केलेला `address` व्हेरिएबल +- `data` मध्ये आमच्या हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्टच्या `update` पद्धतीचा कॉल आहे, जो आमचा `message` स्ट्रिंग व्हेरिएबल इनपुट म्हणून घेतो + +मग, आम्ही एक await कॉल करतो, `window.ethereum.request`, जिथे आम्ही MetaMask ला व्यवहारावर स्वाक्षरी करण्यास सांगतो. लक्षात घ्या, ओळी ११ आणि १२ वर, आम्ही आमची eth पद्धत, `eth_sendTransaction` निर्दिष्ट करत आहोत आणि आमचे `transactionParameters` पास करत आहोत. + +या टप्प्यावर, MetaMask ब्राउझरमध्ये उघडेल आणि वापरकर्त्याला व्यवहारावर सही करण्यास किंवा नाकारण्यास सांगेल. + +- जर व्यवहार यशस्वी झाला, तर फंक्शन एक JSON ऑब्जेक्ट परत करेल जिथे `status` JSX स्ट्रिंग वापरकर्त्याला त्यांच्या व्यवहाराबद्दल अधिक माहितीसाठी Etherscan तपासण्यास सांगते. +- जर व्यवहार अयशस्वी झाला, तर फंक्शन एक JSON ऑब्जेक्ट परत करेल जिथे `status` स्ट्रिंग त्रुटी संदेश प्रसारित करते. + +एकत्रितपणे, आमचे `updateMessage` फंक्शन असे दिसले पाहिजे: + +```javascript +// interact.js + +export const updateMessage = async (address, message) => { + //इनपुट त्रुटी हाताळणी + if (!window.ethereum || address === null) { + return { + status: + "💡 ब्लॉकचेनवरील संदेश अपडेट करण्यासाठी तुमचे MetaMask वॉलेट कनेक्ट करा.", + } + } + + if (message.trim() === "") { + return { + status: "❌ तुमचा संदेश रिकामा स्ट्रिंग असू शकत नाही.", + } + } + + //व्यवहार पॅरामीटर्स सेट करा + const transactionParameters = { + to: contractAddress, // कॉन्ट्रॅक्ट प्रकाशनांशिवाय आवश्यक. + from: address, // वापरकर्त्याच्या सक्रिय पत्त्याशी जुळले पाहिजे. + data: helloWorldContract.methods.update(message).encodeABI(), + } + + //व्यवहारावर स्वाक्षरी करा + try { + const txHash = await window.ethereum.request({ + method: "eth_sendTransaction", + params: [transactionParameters], + }) + return { + status: ( + + ✅{" "} + + Etherscan वर तुमच्या व्यवहाराची स्थिती पहा! + +
+ ℹ️ एकदा नेटवर्कद्वारे व्यवहाराची पडताळणी झाल्यावर, संदेश आपोआप अपडेट होईल. + + ), + } + } catch (error) { + return { + status: "😥 " + error.message, + } + } +} +``` + +शेवटचे पण महत्त्वाचे, आम्हाला आमचे `updateMessage` फंक्शन आमच्या `HelloWorld.js` घटकाशी कनेक्ट करणे आवश्यक आहे. + +#### `updateMessage` ला `HelloWorld.js` फ्रंटएंडशी कनेक्ट करा {#connect-updatemessage-to-the-helloworld-js-frontend} + +आमच्या `onUpdatePressed` फंक्शनने आयात केलेल्या `updateMessage` फंक्शनला एक await कॉल करावा आणि आमचा व्यवहार यशस्वी झाला की अयशस्वी हे दर्शविण्यासाठी `status` स्टेट व्हेरिएबल सुधारित करावे: + +```javascript +// HelloWorld.js + +const onUpdatePressed = async () => { + const { status } = await updateMessage(walletAddress, newMessage) + setStatus(status) +} +``` + +हे खूप स्वच्छ आणि सोपे आहे. आणि अंदाज लावा... तुमचा डॅप पूर्ण झाला आहे!!! + +पुढे जा आणि **अपडेट** बटणाची चाचणी घ्या! + +### तुमचा स्वतःचा सानुकूल डॅप बनवा {#make-your-own-custom-dapp} + +व्वा, तुम्ही ट्युटोरियलच्या शेवटपर्यंत पोहोचलात! रिकॅप करण्यासाठी, तुम्ही शिकलात की कसे: + +- तुमच्या डॅप प्रकल्पाला MetaMask वॉलेट कनेक्ट करा +- [Alchemy Web3](https://docs.alchemy.com/alchemy/documentation/alchemy-web3) API वापरून तुमच्या स्मार्ट कॉन्ट्रॅक्टमधून डेटा वाचा +- MetaMask वापरून Ethereum व्यवहारांवर स्वाक्षरी करा + +आता तुम्ही तुमचा स्वतःचा सानुकूल डॅप प्रकल्प तयार करण्यासाठी या ट्युटोरियलमधील कौशल्ये लागू करण्यासाठी पूर्णपणे सुसज्ज आहात! नेहमीप्रमाणे, तुम्हाला काही प्रश्न असल्यास, [Alchemy Discord](https://discord.gg/gWuC7zB) मध्ये मदतीसाठी आमच्याशी संपर्क साधण्यास अजिबात संकोच करू नका. 🧙♂️ + +एकदा तुम्ही हे ट्युटोरियल पूर्ण केल्यावर, आम्हाला Twitter [@alchemyplatform](https://twitter.com/AlchemyPlatform) वर टॅग करून तुमचा अनुभव कसा होता किंवा तुमचा काही अभिप्राय असल्यास आम्हाला कळवा! diff --git a/public/content/translations/mr/developers/tutorials/hello-world-smart-contract/index.md b/public/content/translations/mr/developers/tutorials/hello-world-smart-contract/index.md new file mode 100644 index 00000000000..637ec6384c2 --- /dev/null +++ b/public/content/translations/mr/developers/tutorials/hello-world-smart-contract/index.md @@ -0,0 +1,366 @@ +--- +title: "नवशिक्यांसाठी हॅलो वर्ल्ड स्मार्ट कॉन्ट्रॅक्ट" +description: "Ethereum वर एक साधे स्मार्ट कॉन्ट्रॅक्ट लिहिण्यावर आणि उपयोजित करण्यावर एक प्रास्ताविक ट्युटोरियल." +author: "elanh" +tags: + [ + "सॉलिडिटी", + "hardhat", + "alchemy", + "स्मार्ट कॉन्ट्रॅक्ट", + "डिप्लॉयिंग" + ] +skill: beginner +lang: mr +published: 2021-03-31 +--- + +जर तुम्ही ब्लॉकचेन डेव्हलपमेंटमध्ये नवीन असाल आणि कुठून सुरुवात करावी हे माहित नसेल, किंवा जर तुम्हाला फक्त स्मार्ट कॉन्ट्रॅक्ट कसे उपयोजित करायचे आणि त्यांच्याशी संवाद कसा साधायचा हे समजून घ्यायचे असेल, तर हा मार्गदर्शक तुमच्यासाठी आहे. आपण व्हर्च्युअल वॉलेट [MetaMask](https://metamask.io/), [Solidity](https://docs.soliditylang.org/en/v0.8.0/), [Hardhat](https://hardhat.org/), आणि [Alchemy](https://www.alchemy.com/eth) वापरून सेपोलिया टेस्ट नेटवर्कवर एक साधे स्मार्ट कॉन्ट्रॅक्ट तयार करण्याची आणि उपयोजित करण्याची प्रक्रिया पाहू (यापैकी कशाचाही अर्थ तुम्हाला अजून समजत नसेल, तर काळजी करू नका, आम्ही ते स्पष्ट करू). + +या ट्युटोरियलच्या [भाग २](https://docs.alchemy.com/docs/interacting-with-a-smart-contract) मध्ये, एकदा आपले स्मार्ट कॉन्ट्रॅक्ट येथे उपयोजित झाल्यावर आपण त्याच्याशी संवाद कसा साधू शकतो हे पाहू, आणि [भाग ३](https.www.alchemy.com/docs/submitting-your-smart-contract-to-etherscan) मध्ये आपण ते Etherscan वर कसे प्रकाशित करायचे हे पाहू. + +तुम्हाला कोणत्याही वेळी प्रश्न पडल्यास [Alchemy Discord](https://discord.gg/gWuC7zB) मध्ये मोकळेपणाने संपर्क साधा! + +## पायरी १: Ethereum नेटवर्कशी कनेक्ट करा {#step-1} + +Ethereum चेनला विनंत्या करण्याचे अनेक मार्ग आहेत. सोपेपणासाठी, आपण Alchemy वर एक विनामूल्य खाते वापरू, जो एक ब्लॉकचेन डेव्हलपर प्लॅटफॉर्म आणि API आहे, ज्यामुळे आपल्याला आपले स्वतःचे नोड्स चालवल्याशिवाय Ethereum चेनशी संवाद साधता येतो. या प्लॅटफॉर्ममध्ये मॉनिटरिंग आणि ॲनालिटिक्ससाठी डेव्हलपर साधने देखील आहेत, ज्यांचा आपण या ट्युटोरियलमध्ये फायदा घेऊ, जेणेकरून आपल्या स्मार्ट कॉन्ट्रॅक्टच्या उपयोजनात पडद्यामागे काय चालले आहे हे समजेल. जर तुमचे आधीच Alchemy खाते नसेल, तर [तुम्ही येथे विनामूल्य साइन अप करू शकता](https://dashboard.alchemy.com/signup). + +## पायरी २: तुमचे ॲप (आणि API की) तयार करा {#step-2} + +एकदा तुम्ही Alchemy खाते तयार केल्यावर, तुम्ही ॲप तयार करून API की तयार करू शकता. हे आम्हाला Sepolia चाचणी नेटवर्कवर विनंत्या करण्याची परवानगी देईल. जर तुम्ही टेस्टनेटशी परिचित नसाल, तर [हे पृष्ठ](/developers/docs/networks/) पहा. + +1. तुमच्या Alchemy डॅशबोर्डमधील "Create new app" पृष्ठावर जाण्यासाठी नेव्ह बारमध्ये "Select an app" निवडा आणि "Create new app" वर क्लिक करा. + + + +2. तुमच्या ॲपला “Hello World” असे नाव द्या, एक छोटे वर्णन द्या, आणि एक उपयोग-केस निवडा, उदा., "Infra & Tooling." पुढे, "Ethereum" साठी शोधा आणि नेटवर्क निवडा. + + + +3. पुढे जाण्यासाठी "Next" वर क्लिक करा, नंतर “Create app” आणि बस्स! तुमचे ॲप नेव्ह बार ड्रॉपडाउन मेन्यूमध्ये दिसले पाहिजे, जिथे कॉपी करण्यासाठी API की उपलब्ध असेल. + +## पायरी ३: एक Ethereum खाते (पत्ता) तयार करा {#step-3} + +आम्हाला व्यवहार पाठवण्यासाठी आणि प्राप्त करण्यासाठी Ethereum खात्याची आवश्यकता आहे. या ट्यूटोरियलसाठी, आम्ही MetaMask वापरू, जे ब्राउझरमधील एक व्हर्च्युअल वॉलेट आहे, जे तुमचा Ethereum खाते पत्ता व्यवस्थापित करण्यासाठी वापरले जाते. [व्यवहारांविषयी](/developers/docs/transactions/) अधिक. + +तुम्ही MetaMask डाउनलोड करू शकता आणि [येथे](https://metamask.io/download) विनामूल्य Ethereum खाते तयार करू शकता. तुम्ही खाते तयार करत असताना, किंवा तुमचे खाते आधीच असल्यास, नेटवर्क ड्रॉपडाउन मेनू वापरून "Sepolia" टेस्ट नेटवर्कवर स्विच केल्याची खात्री करा (जेणेकरून आपण खऱ्या पैशांशी व्यवहार करणार नाही). + +जर तुम्हाला Sepolia सूचीबद्ध दिसत नसेल, तर मेन्यूमध्ये जा, नंतर Advanced मध्ये जाऊन खाली स्क्रोल करा आणि "Show test networks" चालू करण्यासाठी टॉगल करा. नेटवर्क निवड मेन्यूमध्ये, टेस्टनेटची सूची शोधण्यासाठी "Custom" टॅब निवडा आणि "Sepolia" निवडा. + + + +## पायरी ४: फॉसेटमधून इथर मिळवा {#step-4} + +आपले स्मार्ट कॉन्ट्रॅक्ट टेस्ट नेटवर्कवर उपयोजित करण्यासाठी, आपल्याला काही बनावट Eth ची आवश्यकता असेल. Sepolia ETH मिळवण्यासाठी, विविध फॉसेटची सूची पाहण्यासाठी तुम्ही [Sepolia नेटवर्क तपशील](/developers/docs/networks/#sepolia) वर जाऊ शकता. एक काम करत नसल्यास, दुसरा प्रयत्न करा, कारण ते कधीकधी रिकामे होऊ शकतात. नेटवर्क ट्रॅफिकमुळे तुमचा बनावट ETH मिळण्यास थोडा वेळ लागू शकतो. त्यानंतर लवकरच तुमच्या Metamask खात्यात ETH दिसेल! + +## पायरी ५: तुमची शिल्लक तपासा {#step-5} + +आपली शिल्लक आहे की नाही, हे पुन्हा तपासण्यासाठी, चला [Alchemy च्या कंपोझर टूल](https://sandbox.alchemy.com/?network=ETH_SEPOLIA&method=eth_getBalance&body.id=1&body.jsonrpc=2.0&body.method=eth_getBalance&body.params%5B0%5D=&body.params%5B1%5D=latest) वापरून एक [eth_getBalance](/developers/docs/apis/json-rpc/#eth_getbalance) विनंती करूया. हे आमच्या वॉलेटमधील ETH ची रक्कम परत करेल. तुम्ही तुमच्या MetaMask खात्याचा पत्ता इनपुट केल्यानंतर आणि “Send Request” वर क्लिक केल्यानंतर, तुम्हाला असा प्रतिसाद दिसेल: + +```json +{ "jsonrpc": "2.0", "id": 0, "result": "0x2B5E3AF16B1880000" } +``` + +> **टीप:** हा निकाल ETH मध्ये नसून wei मध्ये आहे. Wei हे इथरचे सर्वात लहान एकक म्हणून वापरले जाते. wei चे ETH मध्ये रूपांतर असे आहे: 1 eth = 1018 wei. म्हणून जर आपण 0x2B5E3AF16B1880000 चे दशांश मध्ये रूपांतर केले, तर आपल्याला 5\*10¹⁸ मिळतात जे 5 ETH च्या बरोबर आहे. +> +> हुश्श! आपले बनावट पैसे पूर्णपणे तिथे आहेत
.env कमिट करू नका! कृपया तुमची .env फाईल कोणासोबतही शेअर किंवा उघड करू नका, कारण असे केल्याने तुम्ही तुमची गुपिते धोक्यात आणत आहात याची खात्री करा. जर तुम्ही व्हर्जन कंट्रोल वापरत असाल, तर तुमची .env फाईल gitignore फाईलमध्ये जोडा.
+