గోప్యతను కాపాడే యాప్-నిర్దిష్ట ప్లాస్మాను వ్రాయండి

పరిచయం

రోలప్‌లుకు భిన్నంగా, ప్లాస్మాలు సమగ్రత కోసం ఇతీరియము మెయిన్‌నెట్‌ను ఉపయోగిస్తాయి, కానీ లభ్యత కోసం కాదు. ఈ వ్యాసంలో, మేము ప్లాస్మా లాగా ప్రవర్తించే ఒక అప్లికేషన్‌ను వ్రాస్తాము, ఇతీరియము సమగ్రతకు (అనధికార మార్పులు లేవు) హామీ ఇస్తుంది కానీ లభ్యతకు కాదు (ఒక కేంద్రీకృత భాగం డౌన్ అయి మొత్తం వ్యవస్థను నిలిపివేయవచ్చు).

మేము ఇక్కడ వ్రాసే అప్లికేషన్ ఒక గోప్యతను కాపాడే బ్యాంకు. వివిధ చిరునామాలకు బ్యాలెన్స్‌లతో ఖాతాలు ఉన్నాయి, మరియు వారు ఇతర ఖాతాలకు డబ్బు (ETH) పంపవచ్చు. బ్యాంకు స్థితి (ఖాతాలు మరియు వాటి బ్యాలెన్స్‌లు) మరియు లావాదేవీల హాష్‌లను పోస్ట్ చేస్తుంది, కానీ అసలు బ్యాలెన్స్‌లను ఆఫ్‌చైన్‌లో ఉంచుతుంది, అక్కడ అవి ప్రైవేట్‌గా ఉండగలవు.

డిజైన్

ఇది ఉత్పత్తికి-సిద్ధమైన వ్యవస్థ కాదు, కానీ ఒక బోధనా సాధనం. అందువల్ల, ఇది అనేక సరళీకరణ అంచనాలతో వ్రాయబడింది.

• స్థిర ఖాతా పూల్. నిర్దిష్ట సంఖ్యలో ఖాతాలు ఉన్నాయి, మరియు ప్రతి ఖాతా ముందుగా నిర్ణయించిన చిరునామాకు చెందినది. ఇది చాలా సరళమైన వ్యవస్థను చేస్తుంది ఎందుకంటే జీరో-కనౌలెడ్జి రుజువులలో వేరియబుల్-సైజ్ డేటా నిర్మాణాలను నిర్వహించడం కష్టం. ఉత్పత్తికి-సిద్ధమైన వ్యవస్థ కోసం, మనం స్థితి హాష్‌గా మెర్కిల్ రూట్‌ను ఉపయోగించవచ్చు మరియు అవసరమైన బ్యాలెన్స్‌ల కోసం మెర్కిల్ రుజువులను అందించవచ్చు.

• మెమరీ నిల్వ. ఒక ఉత్పత్తి వ్యవస్థలో, పునఃప్రారంభం అయినప్పుడు వాటిని భద్రపరచడానికి మనం అన్ని ఖాతా బ్యాలెన్స్‌లను డిస్క్‌కు వ్రాయాలి. ఇక్కడ, సమాచారం కేవలం పోయినా పర్వాలేదు.

• బదిలీలు మాత్రమే. ఒక ఉత్పత్తి వ్యవస్థకు బ్యాంకులోకి ఆస్తులను డిపాజిట్ చేయడానికి మరియు వాటిని విత్‌డ్రా చేయడానికి ఒక మార్గం అవసరం. కానీ ఇక్కడ ఉద్దేశ్యం కేవలం భావనను వివరించడం, కాబట్టి ఈ బ్యాంకు బదిలీలకు పరిమితం చేయబడింది.

జీరో-కనౌలెడ్జి రుజువులు

ప్రాథమిక స్థాయిలో, ఒక జీరో-కనౌలెడ్జి రుజువు ప్రూవర్‌కు కొన్ని డేటా, Data_private తెలుసని చూపిస్తుంది, అలాంటి డేటాకు పబ్లిక్ డేటా, Data_public మరియు Data_private మధ్య ఒక సంబంధం Relationship ఉంటుంది. వెరిఫైయర్‌కు Relationship మరియు Data_public తెలుసు.

గోప్యతను కాపాడటానికి, మనకు స్థితులు మరియు లావాదేవీలు ప్రైవేట్‌గా ఉండాలి. కానీ సమగ్రతను నిర్ధారించడానికి, మనకు స్థితుల క్రిప్టోగ్రాఫిక్ హాష్ (opens in a new tab) పబ్లిక్‌గా ఉండాలి. లావాదేవీలను సమర్పించే వ్యక్తులకు ఆ లావాదేవీలు నిజంగా జరిగాయని నిరూపించడానికి, మనం లావాదేవీ హాష్‌లను కూడా పోస్ట్ చేయాలి.

చాలా సందర్భాలలో, Data_private జీరో-కనౌలెడ్జి రుజువు ప్రోగ్రామ్‌కు ఇన్‌పుట్, మరియు Data_public అవుట్‌పుట్.

_Data_private_లో ఈ ఫీల్డులు:

• State_n, పాత స్థితి
• State_n+1, కొత్త స్థితి
• Transaction, పాత స్థితి నుండి కొత్త స్థితికి మార్చే ఒక లావాదేవీ. ఈ లావాదేవీలో ఈ ఫీల్డులను చేర్చాలి:
  • బదిలీని స్వీకరించే గమ్యస్థాన చిరునామా
  • బదిలీ చేయబడుతున్న మొత్తం
  • ప్రతి లావాదేవీ ఒకసారి మాత్రమే ప్రాసెస్ చేయబడుతుందని నిర్ధారించడానికి నాన్స్. మూల చిరునామా లావాదేవీలో ఉండవలసిన అవసరం లేదు, ఎందుకంటే దానిని సంతకం నుండి తిరిగి పొందవచ్చు.
• సంతకం, లావాదేవీని నిర్వహించడానికి అధికారం పొందిన ఒక సంతకం. మా విషయంలో, లావాదేవీని నిర్వహించడానికి అధికారం పొందిన ఏకైక చిరునామా మూల చిరునామా. మా జీరో-కనౌలెడ్జి వ్యవస్థ పనిచేసే విధానం కారణంగా, ఇతీరియము సంతకంతో పాటు మాకు ఖాతా యొక్క పబ్లిక్ కీ కూడా అవసరం.

_Data_public_లో ఇవి ఫీల్డులు:

• Hash(State_n) పాత స్థితి యొక్క హాష్
• Hash(State_n+1) కొత్త స్థితి యొక్క హాష్
• Hash(Transaction) State_n నుండి _State_n+1_కి స్థితిని మార్చే లావాదేవీ యొక్క హాష్.

ఈ సంబంధం అనేక పరిస్థితులను తనిఖీ చేస్తుంది:

• పబ్లిక్ హాష్‌లు నిజంగా ప్రైవేట్ ఫీల్డులకు సరైన హాష్‌లు.
• లావాదేవీ, పాత స్థితికి వర్తింపజేసినప్పుడు, కొత్త స్థితికి దారితీస్తుంది.
• సంతకం లావాదేవీ యొక్క మూల చిరునామా నుండి వస్తుంది.

క్రిప్టోగ్రాఫిక్ హాష్ ఫంక్షన్ల లక్షణాల కారణంగా, ఈ పరిస్థితులను నిరూపించడం సమగ్రతను నిర్ధారించడానికి సరిపోతుంది.

డేటా స్ట్రక్చర్‌లు

ప్రాథమిక డేటా నిర్మాణం సర్వర్ ద్వారా నిర్వహించబడే స్థితి. ప్రతి ఖాతా కోసం, సర్వర్ ఖాతా బ్యాలెన్స్ మరియు నాన్స్ (opens in a new tab)ను ట్రాక్ చేస్తుంది, ఇది రీప్లే దాడులను (opens in a new tab) నివారించడానికి ఉపయోగించబడుతుంది.

భాగాలు

ఈ వ్యవస్థకు రెండు భాగాలు అవసరం:

• లావాదేవీలను స్వీకరించి, వాటిని ప్రాసెస్ చేసి, జీరో-కనౌలెడ్జి రుజువులతో పాటు చైన్‌కు హాష్‌లను పోస్ట్ చేసే సర్వర్.
• హాష్‌లను నిల్వ చేసే మరియు స్థితి మార్పులు చట్టబద్ధమైనవని నిర్ధారించడానికి జీరో-కనౌలెడ్జి రుజువులను ధృవీకరించే స్మార్ట్ కాంట్రాక్ట్.

డేటా మరియు నియంత్రణ ప్రవాహం

ఒక ఖాతా నుండి మరొక ఖాతాకు బదిలీ చేయడానికి వివిధ భాగాలు సంభాషించే మార్గాలు ఇవి.

1. ఒక వెబ్ బ్రౌజర్, సంతకం చేసినవారి ఖాతా నుండి వేరొక ఖాతాకు బదిలీ కోసం అడుగుతూ సంతకం చేసిన లావాదేవీని సమర్పిస్తుంది.

2. సర్వర్ లావాదేవీ చెల్లుబాటు అయ్యేదని ధృవీకరిస్తుంది:

   • సంతకం చేసినవారికి బ్యాంకులో తగినంత బ్యాలెన్సుతో ఒక ఖాతా ఉంది.
   • స్వీకర్తకు బ్యాంకులో ఒక ఖాతా ఉంది.

3. సర్వర్, సంతకం చేసినవారి బ్యాలెన్స్ నుండి బదిలీ చేయబడిన మొత్తాన్ని తీసివేసి, స్వీకర్త బ్యాలెన్సుకు జోడించడం ద్వారా కొత్త స్థితిని గణిస్తుంది.

4. సర్వర్, స్థితి మార్పు చెల్లుబాటు అయ్యేదని రుజువు చేసే జీరో-కనౌలెడ్జి రుజువును గణిస్తుంది.

5. సర్వర్ ఇతీరియముకు ఒక లావాదేవీని సమర్పిస్తుంది, అందులో ఇవి ఉంటాయి:

   • కొత్త స్థితి హాష్
   • లావాదేవీ హాష్ (కాబట్టి లావాదేవీ పంపినవారు అది ప్రాసెస్ చేయబడిందని తెలుసుకోవచ్చు)
   • కొత్త స్థితికి మార్పు చెల్లుబాటు అయ్యేదని నిరూపించే జీరో-కనౌలెడ్జి రుజువు

6. స్మార్ట్ కాంట్రాక్ట్ జీరో-కనౌలెడ్జి రుజువును ధృవీకరిస్తుంది.

7. జీరో-కనౌలెడ్జి రుజువు సరిపోలితే, స్మార్ట్ కాంట్రాక్ట్ ఈ చర్యలను చేస్తుంది:

   • ప్రస్తుత స్థితి హాష్‌ను కొత్త స్థితి హాష్‌కి నవీకరించండి
   • కొత్త స్థితి హాష్ మరియు లావాదేవీ హాష్‌తో ఒక లాగ్ ఎంట్రీని జారీ చేయండి

ఉపకరణాలు

క్లయింట్-సైడ్ కోడ్ కోసం, మేము Vite (opens in a new tab), React (opens in a new tab), Viem (opens in a new tab), మరియు Wagmi (opens in a new tab)ని ఉపయోగించబోతున్నాము. ఇవి పరిశ్రమ-ప్రామాణిక ఉపకరణాలు; మీకు వాటితో పరిచయం లేకపోతే, మీరు ఈ ట్యుటోరియల్ను ఉపయోగించవచ్చు.

సర్వర్‌లో అధిక భాగం జావాస్క్రిప్ట్‌లో Node (opens in a new tab) ఉపయోగించి వ్రాయబడింది. జీరో-కనౌలెడ్జి భాగం Noir (opens in a new tab)లో వ్రాయబడింది. మాకు వెర్షన్ 1.0.0-beta.10 అవసరం, కాబట్టి మీరు Noirని సూచించిన విధంగా ఇన్‌స్టాల్ చేసిన (opens in a new tab) తర్వాత, రన్ చేయండి:

1noirup -v 1.0.0-beta.10

మనం ఉపయోగించే బ్లాక్ చైను anvil, ఇది Foundry (opens in a new tab)లో భాగమైన ఒక స్థానిక పరీక్ష బ్లాక్ చైను.

అమలు

ఇది ఒక సంక్లిష్టమైన వ్యవస్థ కాబట్టి, మేము దానిని దశలవారీగా అమలు చేస్తాము.

దశ 1 - మాన్యువల్ జీరో కనౌలెడ్జి

మొదటి దశ కోసం, మేము బ్రౌజర్‌లో ఒక లావాదేవీకి సంతకం చేసి, ఆపై మాన్యువల్‌గా జీరో-కనౌలెడ్జి రుజువుకు సమాచారాన్ని అందిస్తాము. జీరో-కనౌలెడ్జి కోడ్ ఆ సమాచారాన్ని server/noir/Prover.tomlలో పొందాలని ఆశిస్తుంది (ఇక్కడ డాక్యుమెంట్ చేయబడింది here (opens in a new tab)).

చర్యలో చూడటానికి:

1. మీరు నోడ్స్ (opens in a new tab) మరియు Noir (opens in a new tab) ఇన్‌స్టాల్ చేసుకున్నారని నిర్ధారించుకోండి. Node (opens in a new tab) మరియు Noir (opens in a new tab) ఇన్‌స్టాల్ చేయబడిందని నిర్ధారించుకోండి. ప్రాధాన్యంగా, వాటిని macOS, Linux, లేదా WSL (opens in a new tab) వంటి UNIX సిస్టమ్‌లో ఇన్‌స్టాల్ చేయండి.

2. దశ 1 కోడ్‌ను డౌన్‌లోడ్ చేసి, క్లయింట్ కోడ్‌ను అందించడానికి వెబ్ సర్వర్‌ను ప్రారంభించండి.

   1git clone https://github.com/qbzzt/250911-zk-bank.git -b 01-manual-zk
   2cd 250911-zk-bank
   3cd client
   4npm install
   5npm run dev
   

   మీకు ఇక్కడ ఒక వెబ్ సర్వర్ అవసరం కావడానికి కారణం, కొన్ని రకాల మోసాలను నివారించడానికి, అనేక వాలెట్‌లు (MetaMask వంటివి) డిస్క్ నుండి నేరుగా అందించబడిన ఫైల్‌లను అంగీకరించవు

3. వాలెట్‌తో ఒక బ్రౌజర్‌ను తెరవండి.

4. వాలెట్‌లో, కొత్త పాస్‌ఫ్రేజ్‌ను నమోదు చేయండి. గమనించండి ఇది మీ ప్రస్తుత పాస్‌ఫ్రేజ్‌ను తొలగిస్తుంది, కాబట్టి మీకు బ్యాకప్ ఉందని నిర్ధారించుకోండి.

   పాస్‌ఫ్రేజ్ test test test test test test test test test test test junk, ఇది ఆన్విల్ కోసం డిఫాల్ట్ పరీక్ష పాస్‌ఫ్రేజ్.

5. క్లయింట్-సైడ్ కోడ్‌కు (opens in a new tab) బ్రౌజ్ చేయండి.

6. వాలెట్‌కు కనెక్ట్ అవ్వండి మరియు మీ గమ్యస్థాన ఖాతా మరియు మొత్తాన్ని ఎంచుకోండి.

7. Sign క్లిక్ చేసి, లావాదేవీపై సంతకం చేయండి.

8. Prover.toml శీర్షిక క్రింద, మీరు టెక్స్ట్ కనుగొంటారు. server/noir/Prover.tomlను ఆ టెక్స్ట్‌తో భర్తీ చేయండి.

9. జీరో-కనౌలెడ్జి రుజువును అమలు చేయండి.

   1cd ../server/noir
   2nargo execute
   

   అవుట్‌పుట్ ఇలా ఉండాలి

   1ori@CryptoDocGuy:~/noir/250911-zk-bank/server/noir$ nargo execute
   2
   3[zkBank] Circuit witness successfully solved
   4[zkBank] Witness saved to target/zkBank.gz
   5[zkBank] Circuit output: (0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b, 0x0cfc0a67cb7308e4e9b254026b54204e34f6c8b041be207e64c5db77d95dd82d, 0x450cf9da6e180d6159290554ae3d8787, 0x6d8bc5a15b9037e52fb59b6b98722a85)
   

10. సందేశం సరిగ్గా హాష్ చేయబడిందో లేదో చూడటానికి వెబ్ బ్రౌజర్‌లో మీరు చూసే హాష్‌తో చివరి రెండు విలువలను పోల్చండి.

server/noir/Prover.toml

ఈ ఫైల్ (opens in a new tab) Noir ఆశించే సమాచార ఫార్మాట్‌ను చూపిస్తుంది.

1message="send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 500 finney (milliEth) 0                             "

సందేశం టెక్స్ట్ ఫార్మాట్‌లో ఉంది, ఇది వినియోగదారుకు అర్థం చేసుకోవడానికి సులభం చేస్తుంది (ఇది సంతకం చేసేటప్పుడు అవసరం) మరియు Noir కోడ్ పార్స్ చేయడానికి సులభం చేస్తుంది. మొత్తం ఒక వైపు భిన్న బదిలీలను ప్రారంభించడానికి మరియు మరోవైపు సులభంగా చదవడానికి వీలుగా ఫిన్నీలలో కోట్ చేయబడింది. చివరి సంఖ్య నాన్స్ (opens in a new tab).

స్ట్రింగ్ 100 అక్షరాల పొడవు ఉంటుంది. జీరో-కనౌలెడ్జి రుజువులు వేరియబుల్-సైజ్ డేటాను సరిగ్గా నిర్వహించవు, కాబట్టి తరచుగా డేటాను ప్యాడ్ చేయడం అవసరం.

1pubKeyX=["0x83",...,"0x75"]
2pubKeyY=["0x35",...,"0xa5"]
3signature=["0xb1",...,"0x0d"]

ఈ మూడు పారామితులు స్థిర-పరిమాణ బైట్ శ్రేణులు.

1[[accounts]]
2address="0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
3balance=100_000
4nonce=0
5
6[[accounts]]
7address="0x70997970C51812dc3A010C7d01b50e0d17dc79C8"
8balance=100_000
9nonce=0
అన్నీ చూపించు

నిర్మాణాల శ్రేణిని పేర్కొనడానికి ఇది మార్గం. ప్రతి ఎంట్రీ కోసం, మేము చిరునామా, బ్యాలెన్స్ (మిల్లీఈటీహెచ్‌లో, అంటే, ఫిన్నీ (opens in a new tab)), మరియు తదుపరి నాన్స్ విలువను పేర్కొంటాము.

client/src/Transfer.tsx

ఈ ఫైల్ (opens in a new tab) క్లయింట్-సైడ్ ప్రాసెసింగ్‌ను అమలు చేస్తుంది మరియు server/noir/Prover.toml ఫైల్‌ను ఉత్పత్తి చేస్తుంది (జీరో-కనౌలెడ్జి పారామితులను కలిగి ఉన్నది).

మరింత ఆసక్తికరమైన భాగాల వివరణ ఇక్కడ ఉంది.

1export default attrs =>  {

ఈ ఫంక్షన్ Transfer React కాంపోనెంట్‌ను సృష్టిస్తుంది, దీనిని ఇతర ఫైళ్లు దిగుమతి చేసుకోవచ్చు.

1  const accounts = [
2    "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
3    "0x70997970C51812dc3A010C7d01b50e0d17dc79C8",
4    "0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC",
5    "0x90F79bf6EB2c4f870365E785982E1f101E93b906",
6    "0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65",
7  ]

ఇవి ఖాతా చిరునామాలు, test ... test junk పాస్‌ఫ్రేజ్ ద్వారా సృష్టించబడిన చిరునామాలు. మీరు మీ స్వంత చిరునామాలను ఉపయోగించాలనుకుంటే, ఈ నిర్వచనాన్ని సవరించండి.

1  const account = useAccount()
2  const wallet = createWalletClient({
3    transport: custom(window.ethereum!)
4  })

ఈ Wagmi hooks (opens in a new tab) మాకు viem (opens in a new tab) లైబ్రరీ మరియు వాలెట్‌ను యాక్సెస్ చేయడానికి అనుమతిస్తాయి.

1  const message = `send ${toAccount} ${ethAmount*1000} finney (milliEth) ${nonce}`.padEnd(100, " ")

ఇది సందేశం, ఖాళీలతో ప్యాడ్ చేయబడింది. ప్రతిసారీ useState (opens in a new tab) వేరియబుల్స్ ఒకటి మారినప్పుడు, కాంపోనెంట్ తిరిగి గీయబడుతుంది మరియు message నవీకరించబడుతుంది.

1  const sign = async () => {

వినియోగదారు Sign బటన్‌ను క్లిక్ చేసినప్పుడు ఈ ఫంక్షన్ కాల్ చేయబడుతుంది. సందేశం స్వయంచాలకంగా నవీకరించబడుతుంది, కానీ సంతకానికి వాలెట్‌లో వినియోగదారు ఆమోదం అవసరం, మరియు అవసరం లేకపోతే మేము దానిని అడగాలనుకోవడం లేదు.

1    const signature = await wallet.signMessage({
2        account: fromAccount,
3        message,
4    })

వాలెట్‌ను సందేశానికి సంతకం చేయమని (opens in a new tab) అడగండి.

1    const hash = hashMessage(message)

సందేశం హాష్ పొందండి. వినియోగదారుకు డీబగ్గింగ్ (Noir కోడ్ యొక్క) కోసం దీనిని అందించడం సహాయకరంగా ఉంటుంది.

1    const pubKey = await recoverPublicKey({
2        hash,
3        signature
4    })

పబ్లిక్ కీ పొందండి (opens in a new tab). ఇది Noir ecrecover (opens in a new tab) ఫంక్షన్ కోసం అవసరం.

1    setSignature(signature)
2    setHash(hash)
3    setPubKey(pubKey)

స్థితి వేరియబుల్స్‌ను సెట్ చేయండి. ఇది చేయడం వల్ల కాంపోనెంట్ తిరిగి గీయబడుతుంది (sign ఫంక్షన్ నిష్క్రమించిన తర్వాత) మరియు వినియోగదారుకు నవీకరించబడిన విలువలను చూపుతుంది.

1    let proverToml = `

Prover.toml కోసం టెక్స్ట్.

1message="${message}"
2
3pubKeyX=${hexToArray(pubKey.slice(4,4+2*32))}
4pubKeyY=${hexToArray(pubKey.slice(4+2*32))}

Viem మాకు పబ్లిక్ కీని 65-బైట్ హెక్సాడెసిమల్ స్ట్రింగ్‌గా అందిస్తుంది. మొదటి బైట్ 0x04, ఒక వెర్షన్ మార్కర్. దీని తర్వాత పబ్లిక్ కీ యొక్క x కోసం 32 బైట్లు మరియు తర్వాత పబ్లిక్ కీ యొక్క y కోసం 32 బైట్లు ఉంటాయి.

అయితే, Noir ఈ సమాచారాన్ని రెండు బైట్ శ్రేణులుగా పొందాలని ఆశిస్తుంది, ఒకటి x కోసం మరియు మరొకటి y కోసం. జీరో-కనౌలెడ్జి రుజువులో భాగంగా కాకుండా ఇక్కడ క్లయింట్‌లో పార్స్ చేయడం సులభం.

గమనించండి ఇది సాధారణంగా జీరో-కనౌలెడ్జిలో మంచి పద్ధతి. జీరో-కనౌలెడ్జి రుజువులోని కోడ్ ఖరీదైనది, కాబట్టి జీరో-కనౌలెడ్జి రుజువు వెలుపల చేయగల ఏ ప్రాసెసింగ్ అయినా జీరో-కనౌలెడ్జి రుజువు వెలుపల చేయాలి.

1signature=${hexToArray(signature.slice(2,-2))}

సంతకం కూడా 65-బైట్ హెక్సాడెసిమల్ స్ట్రింగ్‌గా అందించబడుతుంది. అయితే, పబ్లిక్ కీని తిరిగి పొందడానికి చివరి బైట్ మాత్రమే అవసరం. పబ్లిక్ కీ ఇప్పటికే Noir కోడ్‌కు అందించబడుతుంది కాబట్టి, సంతకాన్ని ధృవీకరించడానికి మాకు ఇది అవసరం లేదు, మరియు Noir కోడ్‌కు ఇది అవసరం లేదు.

1${accounts.map(accountInProverToml).reduce((a,b) => a+b, "")}
2`

ఖాతాలను అందించండి.

1    setProverToml(proverToml)
2  }
3
4  return (
5    <>
6        <h2>Transfer</h2>

ఇది కాంపోనెంట్ యొక్క HTML (మరింత కచ్చితంగా, JSX (opens in a new tab)) ఫార్మాట్.

server/noir/src/main.nr

ఈ ఫైల్ (opens in a new tab) అసలు జీరో-కనౌలెడ్జి కోడ్.

1use std::hash::pedersen_hash;

Pedersen hash (opens in a new tab) Noir స్టాండర్డ్ లైబ్రరీ (opens in a new tab)తో అందించబడుతుంది. జీరో-కనౌలెడ్జి రుజువులు సాధారణంగా ఈ హాష్ ఫంక్షన్‌ను ఉపయోగిస్తాయి. స్టాండర్డ్ హాష్ ఫంక్షన్లతో పోలిస్తే అంకగణిత సర్క్యూట్‌లలో (opens in a new tab) గణించడం చాలా సులభం.

1use keccak256::keccak256;
2use dep::ecrecover;

ఈ రెండు ఫంక్షన్లు బాహ్య లైబ్రరీలు, ఇవి Nargo.toml (opens in a new tab)లో నిర్వచించబడ్డాయి. అవి ఖచ్చితంగా వాటి పేరుకు తగ్గట్టుగా ఉంటాయి, keccak256 హాష్ (opens in a new tab)ను గణించే ఒక ఫంక్షన్ మరియు ఇతీరియము సంతకాలను ధృవీకరించి, సంతకం చేసినవారి ఇతీరియము చిరునామాను తిరిగి పొందే ఒక ఫంక్షన్.

1global ACCOUNT_NUMBER : u32 = 5;

Noir Rust (opens in a new tab) నుండి ప్రేరణ పొందింది. వేరియబుల్స్, డిఫాల్ట్‌గా, స్థిరాంకాలు. గ్లోబల్ కాన్ఫిగరేషన్ స్థిరాంకాలను మనం ఇలా నిర్వచిస్తాము. ప్రత్యేకంగా, ACCOUNT_NUMBER అనేది మనం నిల్వ చేసే ఖాతాల సంఖ్య.

u<number> అని పేరు పెట్టబడిన డేటా రకాలు ఆ సంఖ్య బిట్స్, సంతకం చేయనివి. మద్దతు ఉన్న ఏకైక రకాలు u8, u16, u32, u64, మరియు u128.

1global FLAT_ACCOUNT_FIELDS : u32 = 2;

ఈ వేరియబుల్ ఖాతాల పెడెర్సెన్ హాష్ కోసం ఉపయోగించబడుతుంది, క్రింద వివరించిన విధంగా.

1global MESSAGE_LENGTH : u32 = 100;

పైన వివరించినట్లుగా, సందేశం పొడవు స్థిరంగా ఉంటుంది. ఇది ఇక్కడ పేర్కొనబడింది.

1global ASCII_MESSAGE_LENGTH : [u8; 3] = [0x31, 0x30, 0x30];
2global HASH_BUFFER_SIZE : u32 = 26+3+MESSAGE_LENGTH;

EIP-191 సంతకాలకు (opens in a new tab) 26-బైట్ ఉపసర్గతో ఒక బఫర్ అవసరం, దాని తర్వాత ASCIIలో సందేశం పొడవు, మరియు చివరగా సందేశం ఉంటుంది.

1struct Account {
2    balance: u128,
3    address: Field,
4    nonce: u32,
5}

ఖాతా గురించి మనం నిల్వ చేసే సమాచారం. Field (opens in a new tab) అనేది ఒక సంఖ్య, సాధారణంగా 253 బిట్ల వరకు ఉంటుంది, దీనిని జీరో-కనౌలెడ్జి రుజువును అమలు చేసే అంకగణిత సర్క్యూట్‌లో (opens in a new tab) నేరుగా ఉపయోగించవచ్చు. ఇక్కడ మనం Fieldను 160-బిట్ ఇతీరియము చిరునామాను నిల్వ చేయడానికి ఉపయోగిస్తాము.

1struct TransferTxn {
2    from: Field,
3    to: Field,
4    amount: u128,
5    nonce: u32
6}

బదిలీ లావాదేవీ కోసం మనం నిల్వ చేసే సమాచారం.

1fn flatten_account(account: Account) -> [Field; FLAT_ACCOUNT_FIELDS] {

ఒక ఫంక్షన్ నిర్వచనం. పారామితి Account సమాచారం. ఫలితం Field వేరియబుల్స్ యొక్క శ్రేణి, దీని పొడవు FLAT_ACCOUNT_FIELDS

1    let flat = [
2        account.address,
3        ((account.balance << 32) + account.nonce.into()).into(),
4    ];

శ్రేణిలోని మొదటి విలువ ఖాతా చిరునామా. రెండవది బ్యాలెన్స్ మరియు నాన్స్ రెండింటినీ కలిగి ఉంటుంది. .into() కాల్స్ ఒక సంఖ్యను దాని అవసరమైన డేటా రకానికి మారుస్తాయి. account.nonce ఒక u32 విలువ, కానీ దానిని account.balance « 32కు, ఒక u128 విలువకు, జోడించడానికి అది u128గా ఉండాలి. అది మొదటి .into(). రెండవది u128 ఫలితాన్ని Fieldగా మారుస్తుంది, తద్వారా అది శ్రేణిలో సరిపోతుంది.

1    flat
2}

Noirలో, ఫంక్షన్లు చివరలో మాత్రమే ఒక విలువను తిరిగి ఇవ్వగలవు (ప్రారంభ రిటర్న్ లేదు). రిటర్న్ విలువను పేర్కొనడానికి, మీరు దానిని ఫంక్షన్ యొక్క ముగింపు బ్రాకెట్‌కు ముందు అంచనా వేస్తారు.

1fn flatten_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] {

ఈ ఫంక్షన్ ఖాతాల శ్రేణిని Field శ్రేణిగా మారుస్తుంది, దీనిని పీటర్సన్ హాష్‌కు ఇన్‌పుట్‌గా ఉపయోగించవచ్చు.

1    let mut flat: [Field; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER] = [0; FLAT_ACCOUNT_FIELDS*ACCOUNT_NUMBER];

మార్చదగిన వేరియబుల్‌ను పేర్కొనడానికి ఇది మార్గం, అంటే కాదు ఒక స్థిరాంకం. Noirలోని వేరియబుల్స్ ఎల్లప్పుడూ ఒక విలువను కలిగి ఉండాలి, కాబట్టి మనం ఈ వేరియబుల్‌ను అన్ని సున్నాలకు ప్రారంభీకరిస్తాము.

1    for i in 0..ACCOUNT_NUMBER {

ఇది for లూప్. గమనించండి సరిహద్దులు స్థిరాంకాలు. Noir లూప్‌లు వాటి సరిహద్దులను కంపైల్ సమయంలో తెలిసి ఉండాలి. కారణం అంకగణిత సర్క్యూట్‌లు ప్రవాహ నియంత్రణకు మద్దతు ఇవ్వవు. for లూప్‌ను ప్రాసెస్ చేసేటప్పుడు, కంపైలర్ దానిలోని కోడ్‌ను అనేక సార్లు ఉంచుతుంది, ప్రతి పునరావృత్తికి ఒకటి.

1        let fields = flatten_account(accounts[i]);
2        for j in 0..FLAT_ACCOUNT_FIELDS {
3            flat[i*FLAT_ACCOUNT_FIELDS + j] = fields[j];
4        }
5    }
6
7    flat
8}
9
10fn hash_accounts(accounts: [Account; ACCOUNT_NUMBER]) -> Field {
11    pedersen_hash(flatten_accounts(accounts))
12}
అన్నీ చూపించు

చివరగా, మనం ఖాతాల శ్రేణిని హాష్ చేసే ఫంక్షన్‌కు వచ్చాము.

1fn find_account(accounts: [Account; ACCOUNT_NUMBER], address: Field) -> u32 {
2    let mut account : u32 = ACCOUNT_NUMBER;
3
4    for i in 0..ACCOUNT_NUMBER {
5        if accounts[i].address == address {
6            account = i;
7        }
8    }
9}
అన్నీ చూపించు

ఈ ఫంక్షన్ నిర్దిష్ట చిరునామాతో ఉన్న ఖాతాను కనుగొంటుంది. ఈ ఫంక్షన్ ప్రామాణిక కోడ్‌లో చాలా అసమర్థంగా ఉంటుంది ఎందుకంటే ఇది చిరునామాను కనుగొన్న తర్వాత కూడా అన్ని ఖాతాల మీద పునరావృతమవుతుంది.

అయితే, జీరో-కనౌలెడ్జి రుజువులలో, ప్రవాహ నియంత్రణ లేదు. మనం ఎప్పుడైనా ఒక షరతును తనిఖీ చేయవలసి వస్తే, మనం దానిని ప్రతిసారీ తనిఖీ చేయాలి.

if స్టేట్‌మెంట్లతో ఇలాంటిదే జరుగుతుంది. పైన ఉన్న లూప్‌లోని if స్టేట్‌మెంట్ ఈ గణిత స్టేట్‌మెంట్‌లకు అనువదించబడింది.

condition_result = accounts[i].address == address // అవి సమానంగా ఉంటే ఒకటి, లేకపోతే సున్నా

account_new = condition_result*i + (1-condition_result)*account_old

1    assert (account < ACCOUNT_NUMBER, f"{address} does not have an account");
2
3    account

assert (opens in a new tab) ఫంక్షన్, నిర్ధారణ తప్పు అయితే జీరో-కనౌలెడ్జి రుజువును క్రాష్ చేస్తుంది. ఈ సందర్భంలో, సంబంధిత చిరునామాతో ఖాతాను కనుగొనలేకపోతే. చిరునామాను నివేదించడానికి, మనం ఫార్మాట్ స్ట్రింగ్ (opens in a new tab)ను ఉపయోగిస్తాము.

1fn apply_transfer_txn(accounts: [Account; ACCOUNT_NUMBER], txn: TransferTxn) -> [Account; ACCOUNT_NUMBER] {

ఈ ఫంక్షన్ ఒక బదిలీ లావాదేవీని వర్తింపజేసి, కొత్త ఖాతాల శ్రేణిని తిరిగి ఇస్తుంది.

1    let from = find_account(accounts, txn.from);
2    let to = find_account(accounts, txn.to);
3
4    let (txnFrom, txnAmount, txnNonce, accountNonce) =
5        (txn.from, txn.amount, txn.nonce, accounts[from].nonce);

మనం Noirలోని ఫార్మాట్ స్ట్రింగ్‌లో నిర్మాణ మూలకాలను యాక్సెస్ చేయలేము, కాబట్టి మనం ఉపయోగపడే కాపీని సృష్టిస్తాము.

1    assert (accounts[from].balance >= txn.amount,
2        f"{txnFrom} does not have {txnAmount} finney");
3
4    assert (accounts[from].nonce == txn.nonce,
5        f"Transaction has nonce {txnNonce}, but the account is expected to use {accountNonce}");

ఇవి ఒక లావాదేవీని చెల్లనివిగా చేసే రెండు షరతులు.

1    let mut newAccounts = accounts;
2
3    newAccounts[from].balance -= txn.amount;
4    newAccounts[from].nonce += 1;
5    newAccounts[to].balance += txn.amount;
6
7    newAccounts

కొత్త ఖాతాల శ్రేణిని సృష్టించి, ఆపై దానిని తిరిగి ఇవ్వండి.

1fn readAddress(messageBytes: [u8; MESSAGE_LENGTH]) -> Field

ఈ ఫంక్షన్ సందేశం నుండి చిరునామాను చదువుతుంది.

1{
2    let mut result : Field = 0;
3
4    for i in 7..47 {

చిరునామా ఎల్లప్పుడూ 20 బైట్లు (అంటే, 40 హెక్సాడెసిమల్ అంకెలు) పొడవు ఉంటుంది, మరియు అక్షరం #7 వద్ద ప్రారంభమవుతుంది.

1        result *= 0x10;
2        if messageBytes[i] >= 48 & messageBytes[i] <= 57 {    // 0-9
3            result += (messageBytes[i]-48).into();
4        }
5        if messageBytes[i] >= 65 & messageBytes[i] <= 70 {    // A-F
6            result += (messageBytes[i]-65+10).into()
7        }
8        if messageBytes[i] >= 97 & messageBytes[i] <= 102 {   // a-f
9            result += (messageBytes[i]-97+10).into()
10        }        
11    }    
12
13    result
14}
15
16fn readAmountAndNonce(messageBytes: [u8; MESSAGE_LENGTH]) -> (u128, u32)
అన్నీ చూపించు

సందేశం నుండి మొత్తం మరియు నాన్స్‌ను చదవండి.

1{
2    let mut amount : u128 = 0;
3    let mut nonce: u32 = 0;
4    let mut stillReadingAmount: bool = true;
5    let mut lookingForNonce: bool = false;
6    let mut stillReadingNonce: bool = false;

సందేశంలో, చిరునామా తర్వాత మొదటి సంఖ్య బదిలీ చేయాల్సిన ఫిన్నీ మొత్తం (అంటే, ETHలో వెయ్యవ వంతు). రెండవ సంఖ్య నాన్స్. వాటి మధ్య ఉన్న ఏ టెక్స్ట్ అయినా విస్మరించబడుతుంది.

1    for i in 48..MESSAGE_LENGTH {
2        if messageBytes[i] >= 48 & messageBytes[i] <= 57 {    // 0-9
3            let digit = (messageBytes[i]-48);
4
5            if stillReadingAmount {
6                amount = amount*10 + digit.into();
7            }
8
9            if lookingForNonce {    // We just found it
10                stillReadingNonce = true;
11                lookingForNonce = false;
12            }
13
14            if stillReadingNonce {
15                nonce = nonce*10 + digit.into();
16            }
17        } else {
18            if stillReadingAmount {
19                stillReadingAmount = false;
20                lookingForNonce = true;
21            }
22            if stillReadingNonce {
23                stillReadingNonce = false;
24            }
25        }
26    }
27
28    (amount, nonce)
29}
అన్నీ చూపించు

ఒక ట్యూపుల్ (opens in a new tab)ను తిరిగి ఇవ్వడం అనేది ఒక ఫంక్షన్ నుండి బహుళ విలువలను తిరిగి ఇవ్వడానికి Noir మార్గం.

1fn readTransferTxn(message: str<MESSAGE_LENGTH>) -> TransferTxn 
2{
3    let mut txn: TransferTxn = TransferTxn { from: 0, to: 0, amount:0, nonce:0 };
4    let messageBytes = message.as_bytes();
5
6    txn.to = readAddress(messageBytes);
7    let (amount, nonce) = readAmountAndNonce(messageBytes);
8    txn.amount = amount;
9    txn.nonce = nonce;
10
11    txn
12}
అన్నీ చూపించు

ఈ ఫంక్షన్ సందేశాన్ని బైట్‌లుగా మారుస్తుంది, ఆపై మొత్తాలను TransferTxnగా మారుస్తుంది.

1// The equivalent to Viem's hashMessage
2// https://viem.sh/docs/utilities/hashMessage#hashmessage
3fn hashMessage(message: str<MESSAGE_LENGTH>) -> [u8;32] {

మనం ఖాతాల కోసం పెడెర్సెన్ హాష్‌ను ఉపయోగించగలిగాము ఎందుకంటే అవి జీరో-కనౌలెడ్జి రుజువులో మాత్రమే హాష్ చేయబడతాయి. అయితే, ఈ కోడ్‌లో మనం సందేశం యొక్క సంతకాన్ని తనిఖీ చేయాలి, ఇది బ్రౌజర్ ద్వారా ఉత్పత్తి చేయబడుతుంది. దాని కోసం, మనం EIP 191 (opens in a new tab)లో ఇతీరియము సంతకం ఫార్మాట్‌ను అనుసరించాలి. అంటే మనం ఒక ప్రామాణిక ఉపసర్గ, ASCIIలో సందేశం పొడవు, మరియు సందేశాన్ని కలిగి ఉన్న ఒక మిశ్రమ బఫర్‌ను సృష్టించి, దానిని హాష్ చేయడానికి ఇతీరియము ప్రామాణిక keccak256ను ఉపయోగించాలి.

1    // ASCII prefix
2    let prefix_bytes = [
3        0x19, // \x19
4        0x45, // 'E'
5        0x74, // 't'
6        0x68, // 'h'
7        0x65, // 'e'
8        0x72, // 'r'
9        0x65, // 'e'
10        0x75, // 'u'
11        0x6D, // 'm'
12        0x20, // ' '
13        0x53, // 'S'
14        0x69, // 'i'
15        0x67, // 'g'
16        0x6E, // 'n'
17        0x65, // 'e'
18        0x64, // 'd'
19        0x20, // ' '
20        0x4D, // 'M'
21        0x65, // 'e'
22        0x73, // 's'
23        0x73, // 's'
24        0x61, // 'a'
25        0x67, // 'g'
26        0x65, // 'e'
27        0x3A, // ':'
28        0x0A  // '\n'
29    ];
అన్నీ చూపించు

ఒక అప్లికేషన్ వినియోగదారుని ఒక లావాదేవీగా లేదా మరేదైనా ప్రయోజనం కోసం ఉపయోగించగల సందేశానికి సంతకం చేయమని అడిగే సందర్భాలను నివారించడానికి, EIP 191 అన్ని సంతకం చేసిన సందేశాలు అక్షరం 0x19 (చెల్లుబాటు అయ్యే ASCII అక్షరం కాదు) తర్వాత Ethereum Signed Message: మరియు ఒక కొత్త లైన్‌తో ప్రారంభం కావాలని నిర్దేశిస్తుంది.

1    let mut buffer: [u8; HASH_BUFFER_SIZE] = [0u8; HASH_BUFFER_SIZE];
2    for i in 0..26 {
3        buffer[i] = prefix_bytes[i];
4    }
5
6    let messageBytes : [u8; MESSAGE_LENGTH] = message.as_bytes();
7
8    if MESSAGE_LENGTH <= 9 {
9        for i in 0..1 {
10            buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
11        }
12
13        for i in 0..MESSAGE_LENGTH {
14            buffer[i+26+1] = messageBytes[i];
15        }
16    }
17
18    if MESSAGE_LENGTH >= 10 & MESSAGE_LENGTH <= 99 {
19        for i in 0..2 {
20            buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
21        }
22
23        for i in 0..MESSAGE_LENGTH {
24            buffer[i+26+2] = messageBytes[i];
25        }
26    }
27
28    if MESSAGE_LENGTH >= 100 {
29        for i in 0..3 {
30            buffer[i+26] = ASCII_MESSAGE_LENGTH[i];
31        }
32
33        for i in 0..MESSAGE_LENGTH {
34            buffer[i+26+3] = messageBytes[i];
35        }
36    }
37
38    assert(MESSAGE_LENGTH < 1000, "Messages whose length is over three digits are not supported");
అన్నీ చూపించు

999 వరకు సందేశం పొడవులను నిర్వహించి, అది ఎక్కువ ఉంటే విఫలమవండి. సందేశం పొడవు ఒక స్థిరాంకం అయినప్పటికీ, నేను ఈ కోడ్‌ను జోడించాను ఎందుకంటే ఇది దానిని మార్చడం సులభం చేస్తుంది. ఒక ఉత్పత్తి వ్యవస్థలో, మీరు బహుశా మెరుగైన పనితీరు కోసం MESSAGE_LENGTH మారదని ఊహించుకుంటారు.

1    keccak256::keccak256(buffer, HASH_BUFFER_SIZE)
2}

ఇతీరియము ప్రామాణిక keccak256 ఫంక్షన్‌ను ఉపయోగించండి.

1fn signatureToAddressAndHash(
2        message: str<MESSAGE_LENGTH>, 
3        pubKeyX: [u8; 32],
4        pubKeyY: [u8; 32],
5        signature: [u8; 64]
6    ) -> (Field, Field, Field)   // address, first 16 bytes of hash, last 16 bytes of hash        
7{

ఈ ఫంక్షన్ సంతకాన్ని ధృవీకరిస్తుంది, దీనికి సందేశం హాష్ అవసరం. ఆపై అది సంతకం చేసిన చిరునామా మరియు సందేశం హాష్‌ను మాకు అందిస్తుంది. సందేశం హాష్ రెండు Field విలువలుగా అందించబడుతుంది ఎందుకంటే అవి ప్రోగ్రామ్‌లోని మిగిలిన భాగంలో ఒక బైట్ శ్రేణి కంటే ఉపయోగించడం సులభం.

ఫీల్డ్ గణనలు ఒక పెద్ద సంఖ్యకు మాడ్యూలో (opens in a new tab) చేయబడతాయి కాబట్టి మనం రెండు Field విలువలను ఉపయోగించాలి, కానీ ఆ సంఖ్య సాధారణంగా 256 బిట్ల కంటే తక్కువగా ఉంటుంది (లేకపోతే EVMలో ఆ గణనలను చేయడం కష్టం).

1    let hash = hashMessage(message);
2
3    let mut (hash1, hash2) = (0,0);
4
5    for i in 0..16 {
6        hash1 = hash1*256 + hash[31-i].into();
7        hash2 = hash2*256 + hash[15-i].into();
8    }

hash1 మరియు hash2లను మార్చదగిన వేరియబుల్స్‌గా పేర్కొనండి, మరియు హాష్‌ను వాటిలో బైట్ బైట్‌గా వ్రాయండి.

1    (
2        ecrecover::ecrecover(pubKeyX, pubKeyY, signature, hash), 

ఇది Solidity యొక్క ecrecover (opens in a new tab)తో సమానంగా ఉంటుంది, రెండు ముఖ్యమైన తేడాలతో:

• సంతకం చెల్లనిది అయితే, కాల్ assertను విఫలం చేస్తుంది మరియు ప్రోగ్రామ్ రద్దు చేయబడుతుంది.
• పబ్లిక్ కీ సంతకం మరియు హాష్ నుండి తిరిగి పొందగలిగినప్పటికీ, ఇది బాహ్యంగా చేయగల ప్రాసెసింగ్ మరియు అందువల్ల జీరో-కనౌలెడ్జి రుజువులో చేయడం విలువైనది కాదు. ఎవరైనా ఇక్కడ మమ్మల్ని మోసం చేయడానికి ప్రయత్నిస్తే, సంతకం ధృవీకరణ విఫలమవుతుంది.

1        hash1,
2        hash2
3    )
4}
5
6fn main(
7        accounts: [Account; ACCOUNT_NUMBER],
8        message: str<MESSAGE_LENGTH>,
9        pubKeyX: [u8; 32],
10        pubKeyY: [u8; 32],
11        signature: [u8; 64],
12    ) -> pub (
13        Field,  // Hash of old accounts array
14        Field,  // Hash of new accounts array
15        Field,  // First 16 bytes of message hash
16        Field,  // Last 16 bytes of message hash
17    )
అన్నీ చూపించు

చివరగా, మనం main ఫంక్షన్‌కు చేరుకున్నాము. ఖాతాల హాష్‌ను పాత విలువ నుండి కొత్తదానికి చెల్లుబాటు అయ్యే విధంగా మార్చే ఒక లావాదేవీ మా వద్ద ఉందని మేము నిరూపించాలి. దీనికి ఈ నిర్దిష్ట లావాదేవీ హాష్ ఉందని కూడా మేము నిరూపించాలి, తద్వారా దానిని పంపిన వ్యక్తికి వారి లావాదేవీ ప్రాసెస్ చేయబడిందని తెలుస్తుంది.

1{
2    let mut txn = readTransferTxn(message);

txn మార్చదగినదిగా ఉండాలి ఎందుకంటే మనం సందేశం నుండి చిరునామాను చదవము, సంతకం నుండి చదువుతాము.

1    let (fromAddress, txnHash1, txnHash2) = signatureToAddressAndHash(
2        message,
3        pubKeyX,
4        pubKeyY,
5        signature);
6
7    txn.from = fromAddress;
8
9    let newAccounts = apply_transfer_txn(accounts, txn);
10
11    (
12        hash_accounts(accounts),
13        hash_accounts(newAccounts),
14        txnHash1,
15        txnHash2
16    )
17}
అన్నీ చూపించు

దశ 2 - ఒక సర్వర్‌ను జోడించడం

రెండవ దశలో, మేము బ్రౌజర్ నుండి బదిలీ లావాదేవీలను స్వీకరించి, అమలు చేసే ఒక సర్వర్‌ను జోడిస్తాము.

చర్యలో చూడటానికి:

1. Vite నడుస్తుంటే దాన్ని ఆపండి.

2. సర్వర్‌ను కలిగి ఉన్న శాఖను డౌన్‌లోడ్ చేయండి మరియు మీకు అవసరమైన అన్ని మాడ్యూల్స్ ఉన్నాయని నిర్ధారించుకోండి.

   1git checkout 02-add-server
   2cd client
   3npm install
   4cd ../server
   5npm install
   

   Noir కోడ్‌ను కంపైల్ చేయాల్సిన అవసరం లేదు, ఇది మీరు దశ 1 కోసం ఉపయోగించిన కోడ్‌తో సమానంగా ఉంటుంది.

3. సర్వర్‌ను ప్రారంభించండి.

   1npm run start
   

4. వేరే కమాండ్-లైన్ విండోలో, బ్రౌజర్ కోడ్‌ను అందించడానికి Viteని రన్ చేయండి.

   1cd client
   2npm run dev
   

5. క్లయింట్ కోడ్‌కు http://localhost:5173 (opens in a new tab) వద్ద బ్రౌజ్ చేయండి

6. మీరు ఒక లావాదేవీ జారీ చేసే ముందు, మీరు నాన్స్‌ను, అలాగే మీరు పంపగల మొత్తాన్ని తెలుసుకోవాలి. ఈ సమాచారం పొందడానికి, Update account data క్లిక్ చేసి, సందేశానికి సంతకం చేయండి.

   ఇక్కడ మనకు ఒక సందిగ్ధత ఉంది. ఒక వైపు, మేము తిరిగి ఉపయోగించగల సందేశానికి సంతకం చేయకూడదు (ఒక రీప్లే దాడి (opens in a new tab)), అందుకే మాకు ముందుగా నాన్స్ కావాలి. అయితే, మాకు ఇంకా నాన్స్ లేదు. పరిష్కారం ఒకసారి మాత్రమే ఉపయోగించగల మరియు రెండు వైపులా ఇప్పటికే ఉన్న ఒక నాన్స్‌ను ఎంచుకోవడం, ఉదాహరణకు ప్రస్తుత సమయం.

   ఈ పరిష్కారంతో సమస్య ఏమిటంటే, సమయం సంపూర్ణంగా సమకాలీకరించబడకపోవచ్చు. కాబట్టి బదులుగా, మేము ప్రతి నిమిషానికి మారే ఒక విలువకు సంతకం చేస్తాము. అంటే రీప్లే దాడులకు మా దుర్బలత్వం యొక్క విండో గరిష్టంగా ఒక నిమిషం ఉంటుంది. ఉత్పత్తిలో సంతకం చేసిన అభ్యర్థన TLS ద్వారా రక్షించబడుతుందని మరియు టన్నెల్ యొక్క మరొక వైపు---సర్వర్---బ్యాలెన్స్ మరియు నాన్స్‌ను ఇప్పటికే వెల్లడించగలదని (పని చేయడానికి అవి దానికి తెలిసి ఉండాలి) పరిగణలోకి తీసుకుంటే, ఇది ఒక ఆమోదయోగ్యమైన ప్రమాదం.

7. బ్రౌజర్ బ్యాలెన్స్ మరియు నాన్స్‌ను తిరిగి పొందిన తర్వాత, అది బదిలీ ఫారమ్‌ను చూపుతుంది. గమ్యస్థాన చిరునామా మరియు మొత్తాన్ని ఎంచుకుని, Transfer క్లిక్ చేయండి. ఈ అభ్యర్థనకు సంతకం చేయండి.

8. బదిలీని చూడటానికి, Update account data చేయండి లేదా మీరు సర్వర్‌ను రన్ చేసే విండోలో చూడండి. సర్వర్ ప్రతిసారి మారినప్పుడు స్థితిని లాగ్ చేస్తుంది.

   1ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
   2
   3> server@1.0.0 start
   4> node --experimental-json-modules index.mjs
   5
   6Listening on port 3000
   7Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 36000 finney (milliEth) 0 processed
   8New state:
   90xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 64000 (1)
   100x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 100000 (0)
   110x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
   120x90F79bf6EB2c4f870365E785982E1f101E93b906 has 136000 (0)
   130x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
   14Txn send 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 7200 finney (milliEth) 1 processed
   15New state:
   160xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 56800 (2)
   170x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 107200 (0)
   180x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
   190x90F79bf6EB2c4f870365E785982E1f101E93b906 has 136000 (0)
   200x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
   21Txn send 0x90F79bf6EB2c4f870365E785982E1f101E93b906 3000 finney (milliEth) 2 processed
   22New state:
   230xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 has 53800 (3)
   240x70997970C51812dc3A010C7d01b50e0d17dc79C8 has 107200 (0)
   250x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC has 100000 (0)
   260x90F79bf6EB2c4f870365E785982E1f101E93b906 has 139000 (0)
   270x15d34AAf54267DB7D7c367839AAf71A00a2C6A65 has 100000 (0)
   అన్నీ చూపించు

server/index.mjs

ఈ ఫైల్ (opens in a new tab) సర్వర్ ప్రాసెస్‌ను కలిగి ఉంది, మరియు main.nr (opens in a new tab) వద్ద Noir కోడ్‌తో సంకర్షణ చెందుతుంది. ఆసక్తికరమైన భాగాల వివరణ ఇక్కడ ఉంది.

1import { Noir } from '@noir-lang/noir_js'
కాపీ

noir.js (opens in a new tab) లైబ్రరీ జావాస్క్రిప్ట్ కోడ్ మరియు Noir కోడ్ మధ్య ఇంటర్ఫేస్ చేస్తుంది.

1const circuit = JSON.parse(await fs.readFile("./noir/target/zkBank.json"))
2const noir = new Noir(circuit)
కాపీ

అంకగణిత సర్క్యూట్‌ను లోడ్ చేయండి---మునుపటి దశలో మనం సృష్టించిన కంపైల్ చేయబడిన Noir ప్రోగ్రామ్---మరియు దానిని అమలు చేయడానికి సిద్ధం చేయండి.

1// We only provide account information in return to a signed request
2const accountInformation = async signature => {
3    const fromAddress = await recoverAddress({
4        hash: hashMessage("Get account data " + Math.floor((new Date().getTime())/60000)),
5        signature
6    })
కాపీ

ఖాతా సమాచారాన్ని అందించడానికి, మాకు సంతకం మాత్రమే అవసరం. కారణం, సందేశం ఏమి కాబోతోందో మాకు ఇప్పటికే తెలుసు, మరియు అందువల్ల సందేశం హాష్ కూడా.

1const processMessage = async (message, signature) => {
కాపీ

ఒక సందేశాన్ని ప్రాసెస్ చేసి, అది ఎన్కోడ్ చేసే లావాదేవీని అమలు చేయండి.

1    // Get the public key
2    const pubKey = await recoverPublicKey({
3        hash,
4        signature
5    })
కాపీ

ఇప్పుడు మేము సర్వర్‌లో జావాస్క్రిప్ట్‌ను రన్ చేస్తున్నాము కాబట్టి, మేము పబ్లిక్ కీని క్లయింట్‌లో కాకుండా అక్కడ తిరిగి పొందవచ్చు.

1    let noirResult
2    try {
3        noirResult = await noir.execute({
4            message,
5            signature: signature.slice(2,-2).match(/.{2}/g).map(x => `0x${x}`),
6            pubKeyX,
7            pubKeyY,
8            accounts: Accounts
9        })
అన్నీ చూపించు
కాపీ

noir.execute Noir ప్రోగ్రామ్‌ను రన్ చేస్తుంది. పారామితులు Prover.toml (opens in a new tab)లో అందించిన వాటికి సమానంగా ఉంటాయి. గమనించండి పొడవైన విలువలు హెక్సాడెసిమల్ స్ట్రింగ్‌ల శ్రేణిగా అందించబడతాయి (["0x60", "0xA7"]), ఒకే హెక్సాడెసిమల్ విలువగా కాదు (0x60A7), Viem చేసే విధంగా.

1    } catch (err) {
2        console.log(`Noir error: ${err}`)
3        throw Error("Invalid transaction, not processed")
4    }
కాపీ

ఒకవేళ లోపం ఉంటే, దాన్ని పట్టుకుని, ఆపై ఒక సరళీకృత వెర్షన్‌ను క్లయింట్‌కు పంపండి.

1    Accounts[fromAccountNumber].nonce++
2    Accounts[fromAccountNumber].balance -= amount
3    Accounts[toAccountNumber].balance += amount
కాపీ

లావాదేవీని వర్తించండి. మేము ఇప్పటికే దానిని Noir కోడ్‌లో చేసాము, కానీ ఫలితాన్ని అక్కడ నుండి సంగ్రహించడం కంటే ఇక్కడ మళ్ళీ చేయడం సులభం.

1let Accounts = [
2    {
3        address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
4        balance: 5000,
5        nonce: 0,
6    },
కాపీ

ప్రారంభ Accounts నిర్మాణం.

దశ 3 - ఇతీరియము స్మార్ట్ కాంట్రాక్టులు

1. సర్వర్ మరియు క్లయింట్ ప్రక్రియలను ఆపండి.

2. స్మార్ట్ కాంట్రాక్టులతో ఉన్న శాఖను డౌన్‌లోడ్ చేయండి మరియు మీకు అవసరమైన అన్ని మాడ్యూల్స్ ఉన్నాయని నిర్ధారించుకోండి.

   1git checkout 03-smart-contracts
   2cd client
   3npm install
   4cd ../server
   5npm install
   

3. anvilను వేరే కమాండ్-లైన్ విండోలో రన్ చేయండి.

4. ధృవీకరణ కీ మరియు సాలిడిటీ వెరిఫైయర్‌ను ఉత్పత్తి చేయండి, ఆపై వెరిఫైయర్ కోడ్‌ను Solidity ప్రాజెక్ట్‌కు కాపీ చేయండి.

   1cd noir
   2bb write_vk -b ./target/zkBank.json -o ./target --oracle_hash keccak
   3bb write_solidity_verifier -k ./target/vk -o ./target/Verifier.sol
   4cp target/Verifier.sol ../../smart-contracts/src
   

5. స్మార్ట్ కాంట్రాక్టులకు వెళ్లి, anvil బ్లాక్ చైనును ఉపయోగించడానికి పర్యావరణ వేరియబుల్స్‌ను సెట్ చేయండి.

   1cd ../../smart-contracts
   2export ETH_RPC_URL=http://localhost:8545
   3ETH_PRIVATE_KEY=ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
   

6. Verifier.solను అమలు చేయండి మరియు చిరునామాను పర్యావరణ వేరియబుల్‌లో నిల్వ చేయండి.

   1VERIFIER_ADDRESS=`forge create src/Verifier.sol:HonkVerifier --private-key $ETH_PRIVATE_KEY --optimize --broadcast | awk '/Deployed to:/ {print $3}'`
   2echo $VERIFIER_ADDRESS
   

7. ZkBank కాంట్రాక్టును అమలు చేయండి.

   1ZKBANK_ADDRESS=`forge create ZkBank --private-key $ETH_PRIVATE_KEY --broadcast --constructor-args $VERIFIER_ADDRESS 0x199aa62af8c1d562a6ec96e66347bf3240ab2afb5d022c895e6bf6a5e617167b | awk '/Deployed to:/ {print $3}'`
   2echo $ZKBANK_ADDRESS
   

   0x199..67b విలువ Accounts యొక్క ప్రారంభ స్థితి యొక్క పెడెర్సెన్ హాష్. మీరు server/index.mjsలో ఈ ప్రారంభ స్థితిని సవరించినట్లయితే, జీరో-కనౌలెడ్జి రుజువు ద్వారా నివేదించబడిన ప్రారంభ హాష్‌ను చూడటానికి ఒక లావాదేవీని రన్ చేయవచ్చు.

8. సర్వర్‌ను రన్ చేయండి.

   1cd ../server
   2npm run start
   

9. క్లయింట్‌ను వేరే కమాండ్-లైన్ విండోలో రన్ చేయండి.

   1cd client
   2npm run dev
   

10. కొన్ని లావాదేవీలను రన్ చేయండి.

11. స్థితి ఆన్‌చైన్‌లో మారిందని ధృవీకరించడానికి, సర్వర్ ప్రాసెస్‌ను పునఃప్రారంభించండి. లావాదేవీలలోని అసలు హాష్ విలువ ఆన్‌చైన్‌లో నిల్వ చేయబడిన హాష్ విలువకు భిన్నంగా ఉన్నందున, ZkBank ఇకపై లావాదేవీలను అంగీకరించదని చూడండి.

    ఇది ఊహించిన రకమైన లోపం.

    1ori@CryptoDocGuy:~/x/250911-zk-bank/server$ npm run start
    2
    3> server@1.0.0 start
    4> node --experimental-json-modules index.mjs
    5
    6Listening on port 3000
    7Verification error: ContractFunctionExecutionError: The contract function "processTransaction" reverted with the following reason:
    8Wrong old state hash
    9
    10Contract Call:
    11    address:   0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512
    12    function:  processTransaction(bytes _proof, bytes32[] _publicInputs)
    13    args:                        (0x0000000000000000000000000000000000000000000000042ab5d6d1986846cf00000000000000000000000000000000000000000000000b75c020998797da7800000000000000000000000000000000000000000000000
    అన్నీ చూపించు

server/index.mjs

ఈ ఫైల్‌లోని మార్పులు ఎక్కువగా అసలు రుజువును సృష్టించి, దానిని ఆన్‌చైన్‌లో సమర్పించడానికి సంబంధించినవి.

1import { exec } from 'child_process'
2import util from 'util'
3
4const execPromise = util.promisify(exec)
కాపీ

ఆన్‌చైన్‌కు పంపడానికి అసలు రుజువును సృష్టించడానికి మేము బారెటెన్‌బెర్గ్ ప్యాకేజీని (opens in a new tab) ఉపయోగించాలి. మేము ఈ ప్యాకేజీని కమాండ్-లైన్ ఇంటర్‌ఫేస్ (bb)ని రన్ చేయడం ద్వారా లేదా జావాస్క్రిప్ట్ లైబ్రరీ, bb.js (opens in a new tab)ని ఉపయోగించడం ద్వారా ఉపయోగించవచ్చు. జావాస్క్రిప్ట్ లైబ్రరీ కోడ్‌ను దేశీయంగా రన్ చేయడం కంటే చాలా నెమ్మదిగా ఉంటుంది, కాబట్టి మేము కమాండ్-లైన్‌ను ఉపయోగించడానికి ఇక్కడ exec (opens in a new tab)ని ఉపయోగిస్తాము.

గమనించండి మీరు bb.jsని ఉపయోగించాలని నిర్ణయించుకుంటే, మీరు ఉపయోగిస్తున్న Noir వెర్షన్‌తో అనుకూలమైన వెర్షన్‌ను ఉపయోగించాలి. వ్రాసే సమయంలో, ప్రస్తుత Noir వెర్షన్ (1.0.0-beta.11) bb.js వెర్షన్ 0.87ను ఉపయోగిస్తుంది.

1const zkBankAddress = process.env.ZKBANK_ADDRESS || "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512"
కాపీ

ఇక్కడి చిరునామా, మీరు శుభ్రమైన anvilతో ప్రారంభించి, పైన ఉన్న ఆదేశాలను అనుసరించినప్పుడు పొందేది.

1const walletClient = createWalletClient({ 
2    chain: anvil, 
3    transport: http(), 
4    account: privateKeyToAccount("0x2a871d0798f97d79848a013d4936a73bf4cc922c825d33c1cf7073dff6d409c6")
5})
కాపీ

ఈ ప్రైవేట్ కీ anvilలోని డిఫాల్ట్ ప్రీ-ఫండెడ్ ఖాతాలలో ఒకటి.

1const generateProof = async (witness, fileID) => {
కాపీ

bb ఎగ్జిక్యూటబుల్ ఉపయోగించి ఒక రుజువును రూపొందించండి.

1    const fname = `witness-${fileID}.gz`    
2    await fs.writeFile(fname, witness)
కాపీ

సాక్షిని ఒక ఫైల్‌కు వ్రాయండి.

1    await execPromise(`bb prove -b ./noir/target/zkBank.json -w ${fname} -o ${fileID} --oracle_hash keccak --output_format fields`)
కాపీ

నిజానికి రుజువును సృష్టించండి. ఈ దశ పబ్లిక్ వేరియబుల్స్‌తో ఒక ఫైల్‌ను కూడా సృష్టిస్తుంది, కానీ మాకు అది అవసరం లేదు. మేము ఆ వేరియబుల్స్‌ను noir.execute నుండి ఇప్పటికే పొందాము.

1    const proof = "0x" + JSON.parse(await fs.readFile(`./${fileID}/proof_fields.json`)).reduce((a,b) => a+b, "").replace(/0x/g, "")
కాపీ

రుజువు Field విలువల యొక్క JSON శ్రేణి, ప్రతిదీ ఒక హెక్సాడెసిమల్ విలువగా సూచించబడుతుంది. అయితే, మేము దానిని లావాదేవీలో ఒకే bytes విలువగా పంపాలి, దీనిని Viem ఒక పెద్ద హెక్సాడెసిమల్ స్ట్రింగ్‌తో సూచిస్తుంది. ఇక్కడ మేము అన్ని విలువలను కలిపి, అన్ని 0xలను తీసివేసి, ఆపై చివరలో ఒకటి జోడించడం ద్వారా ఫార్మాట్‌ను మారుస్తాము.

1    await execPromise(`rm -r ${fname} ${fileID}`)
2
3    return proof
4}
కాపీ

శుభ్రపరిచి, రుజువును తిరిగి ఇవ్వండి.

1const processMessage = async (message, signature) => {
2    .
3    .
4    .
5
6    const publicFields = noirResult.returnValue.map(x=>'0x' + x.slice(2).padStart(64, "0"))
కాపీ

పబ్లిక్ ఫీల్డ్‌లు 32-బైట్ విలువల శ్రేణిగా ఉండాలి. అయితే, లావాదేవీ హాష్‌ను రెండు Field విలువల మధ్య విభజించవలసి వచ్చినందున, ఇది 16-బైట్ విలువగా కనిపిస్తుంది. ఇక్కడ మేము సున్నాలను జోడిస్తాము, తద్వారా Viem అది నిజానికి 32 బైట్లు అని అర్థం చేసుకుంటుంది.

1    const proof = await generateProof(noirResult.witness, `${fromAddress}-${nonce}`)
కాపీ

ప్రతి చిరునామా ప్రతి నాన్స్‌ను ఒకసారి మాత్రమే ఉపయోగిస్తుంది, తద్వారా మేము fromAddress మరియు nonce కలయికను సాక్షి ఫైల్ మరియు అవుట్‌పుట్ డైరెక్టరీ కోసం ఒక ప్రత్యేక ఐడెంటిఫైయర్‌గా ఉపయోగించవచ్చు.

1    try {
2        await zkBank.write.processTransaction([
3            proof, publicFields])
4    } catch (err) {
5        console.log(`Verification error: ${err}`)
6        throw Error("Can't verify the transaction onchain")
7    }
8    .
9    .
10    .
11}
అన్నీ చూపించు
కాపీ

లావాదేవీని చైన్‌కు పంపండి.

smart-contracts/src/ZkBank.sol

ఇది లావాదేవీని స్వీకరించే ఆన్‌చైన్ కోడ్.

1// SPDX-License-Identifier: MIT
2
3pragma solidity >=0.8.21;
4
5import {HonkVerifier} from "./Verifier.sol";
6
7contract ZkBank {
8    HonkVerifier immutable myVerifier;
9    bytes32 currentStateHash;
10
11    constructor(address _verifierAddress, bytes32 _initialStateHash) {
12        currentStateHash = _initialStateHash;
13        myVerifier = HonkVerifier(_verifierAddress);
14    }
అన్నీ చూపించు
కాపీ

ఆన్‌చైన్ కోడ్ రెండు వేరియబుల్స్‌ను ట్రాక్ చేయాలి: వెరిఫైయర్ (nargo ద్వారా సృష్టించబడిన ఒక ప్రత్యేక కాంట్రాక్ట్) మరియు ప్రస్తుత స్థితి హాష్.

1    event TransactionProcessed(
2        bytes32 indexed transactionHash,
3        bytes32 oldStateHash,
4        bytes32 newStateHash
5    );
కాపీ

ప్రతిసారి స్థితి మారినప్పుడు, మేము TransactionProcessed ఈవెంట్‌ను విడుదల చేస్తాము.

1    function processTransaction(
2        bytes calldata _proof,
3        bytes32[] calldata _publicFields
4    ) public {
కాపీ

ఈ ఫంక్షన్ లావాదేవీలను ప్రాసెస్ చేస్తుంది. ఇది రుజువును (bytesగా) మరియు పబ్లిక్ ఇన్‌పుట్‌లను (bytes32 శ్రేణిగా), వెరిఫైయర్ అవసరమైన ఫార్మాట్‌లో (ఆన్‌చైన్ ప్రాసెసింగ్‌ను మరియు అందువల్ల గ్యాస్ ఖర్చులను తగ్గించడానికి) పొందుతుంది.

1        require(_publicInputs[0] == currentStateHash,
2            "Wrong old state hash");
కాపీ

జీరో-కనౌలెడ్జి రుజువు లావాదేవీ మన ప్రస్తుత హాష్ నుండి కొత్తదానికి మారుతుందని ఉండాలి.

1        myVerifier.verify(_proof, _publicFields);
కాపీ

జీరో-కనౌలెడ్జి రుజువును ధృవీకరించడానికి వెరిఫైయర్ కాంట్రాక్టును కాల్ చేయండి. జీరో-కనౌలెడ్జి రుజువు తప్పు అయితే ఈ దశ లావాదేవీని తిరిగి తీసుకుంటుంది.

1        currentStateHash = _publicFields[1];
2
3        emit TransactionProcessed(
4            _publicFields[2]<<128 | _publicFields[3],
5            _publicFields[0],
6            _publicFields[1]
7        );
8    }
9}
అన్నీ చూపించు
కాపీ

అన్నీ సరిగ్గా ఉంటే, స్థితి హాష్‌ను కొత్త విలువకు నవీకరించి, TransactionProcessed ఈవెంట్‌ను విడుదల చేయండి.

కేంద్రీకృత భాగం ద్వారా దుర్వినియోగాలు

సమాచార భద్రత మూడు గుణాలను కలిగి ఉంటుంది:

• గోప్యత, వినియోగదారులు వారు చదవడానికి అధికారం లేని సమాచారాన్ని చదవలేరు.
• సమగ్రత, అధీకృత వినియోగదారులు అధీకృత పద్ధతిలో తప్ప సమాచారాన్ని మార్చలేరు.
• లభ్యత, అధీకృత వినియోగదారులు వ్యవస్థను ఉపయోగించగలరు.

ఈ వ్యవస్థలో, సమగ్రత జీరో-కనౌలెడ్జి రుజువుల ద్వారా అందించబడుతుంది. లభ్యతను హామీ ఇవ్వడం చాలా కష్టం, మరియు గోప్యత అసాధ్యం, ఎందుకంటే బ్యాంకు ప్రతి ఖాతా యొక్క బ్యాలెన్స్ మరియు అన్ని లావాదేవీలను తెలుసుకోవాలి. సమాచారం ఉన్న ఒక సంస్థ ఆ సమాచారాన్ని పంచుకోకుండా నిరోధించడానికి మార్గం లేదు.

స్టీల్త్ చిరునామాలను (opens in a new tab) ఉపయోగించి నిజంగా గోప్యమైన బ్యాంకును సృష్టించడం సాధ్యం కావచ్చు, కానీ అది ఈ వ్యాసం పరిధికి మించినది.

తప్పుడు సమాచారం

డేటాను అభ్యర్థించినప్పుడు (opens in a new tab) తప్పుడు సమాచారాన్ని అందించడం ద్వారా సర్వర్ సమగ్రతను ఉల్లంఘించగల ఒక మార్గం.

దీన్ని పరిష్కరించడానికి, మేము ఖాతాలను ఒక ప్రైవేట్ ఇన్‌పుట్‌గా మరియు సమాచారం అభ్యర్థించబడిన చిరునామాను ఒక పబ్లిక్ ఇన్‌పుట్‌గా స్వీకరించే రెండవ Noir ప్రోగ్రామ్‌ను వ్రాయవచ్చు. అవుట్‌పుట్ ఆ చిరునామా యొక్క బ్యాలెన్స్ మరియు నాన్స్, మరియు ఖాతాల హాష్.

అయితే, ఈ రుజువును ఆన్‌చైన్‌లో ధృవీకరించలేము, ఎందుకంటే మేము నాన్స్‌లు మరియు బ్యాలెన్స్‌లను ఆన్‌చైన్‌లో పోస్ట్ చేయాలనుకోవడం లేదు. అయితే, దీనిని బ్రౌజర్‌లో నడుస్తున్న క్లయింట్ కోడ్ ద్వారా ధృవీకరించవచ్చు.

బలవంతపు లావాదేవీలు

L2లలో లభ్యతను నిర్ధారించడానికి మరియు సెన్సార్‌షిప్‌ను నివారించడానికి సాధారణ యంత్రాంగం బలవంతపు లావాదేవీలు (opens in a new tab). కానీ బలవంతపు లావాదేవీలు జీరో-కనౌలెడ్జి రుజువులతో కలపబడవు. సర్వర్ మాత్రమే లావాదేవీలను ధృవీకరించగల ఏకైక సంస్థ.

బలవంతపు లావాదేవీలను అంగీకరించడానికి మరియు అవి ప్రాసెస్ అయ్యే వరకు స్థితిని మార్చకుండా సర్వర్‌ను నిరోధించడానికి మేము smart-contracts/src/ZkBank.solను సవరించవచ్చు. అయితే, ఇది మాకు ఒక సాధారణ తిరస్కరణ-సేవ దాడికి గురి చేస్తుంది. ఒక బలవంతపు లావాదేవీ చెల్లనిది మరియు అందువల్ల ప్రాసెస్ చేయడం అసాధ్యం అయితే?

పరిష్కారం ఒక బలవంతపు లావాదేవీ చెల్లనిదని జీరో-కనౌలెడ్జి రుజువు కలిగి ఉండటం. ఇది సర్వర్‌కు మూడు ఎంపికలను ఇస్తుంది:

• బలవంతపు లావాదేవీని ప్రాసెస్ చేయడం, అది ప్రాసెస్ చేయబడిందని మరియు కొత్త స్థితి హాష్ ఉందని జీరో-కనౌలెడ్జి రుజువును అందించడం.
• బలవంతపు లావాదేవీని తిరస్కరించడం, మరియు లావాదేవీ చెల్లనిదని (తెలియని చిరునామా, చెడ్డ నాన్స్, లేదా తగినంత బ్యాలెన్స్ లేకపోవడం) కాంట్రాక్టుకు జీరో-కనౌలెడ్జి రుజువును అందించడం.
• బలవంతపు లావాదేవీని విస్మరించడం. సర్వర్‌ను లావాదేవీని నిజంగా ప్రాసెస్ చేయమని బలవంతం చేయడానికి మార్గం లేదు, కానీ దీని అర్థం మొత్తం వ్యవస్థ అందుబాటులో లేదు.

లభ్యత బాండ్లు

నిజ-జీవిత అమలులో, సర్వర్‌ను నడుపుతూ ఉండటానికి బహుశా ఏదో ఒక రకమైన లాభ ప్రేరణ ఉంటుంది. నిర్దిష్ట కాలంలో బలవంతపు లావాదేవీ ప్రాసెస్ చేయబడకపోతే ఎవరైనా కాల్చగల లభ్యత బాండ్‌ను సర్వర్ పోస్ట్ చేయడం ద్వారా మేము ఈ ప్రోత్సాహాన్ని బలోపేతం చేయవచ్చు.

చెడ్డ Noir కోడ్

సాధారణంగా, ప్రజలు ఒక స్మార్ట్ కాంట్రాక్టును విశ్వసించేలా చేయడానికి మేము సోర్స్ కోడ్‌ను ఒక బ్లాక్ ఎక్స్‌ప్లోరర్‌కు (opens in a new tab) అప్‌లోడ్ చేస్తాము. అయితే, జీరో-కనౌలెడ్జి రుజువుల విషయంలో, అది సరిపోదు.

Verifier.sol ధృవీకరణ కీని కలిగి ఉంటుంది, ఇది Noir ప్రోగ్రామ్ యొక్క ఫంక్షన్. అయితే, ఆ కీ మాకు Noir ప్రోగ్రామ్ ఏమిటో చెప్పదు. నిజంగా విశ్వసనీయ పరిష్కారం కలిగి ఉండటానికి, మీరు Noir ప్రోగ్రామ్ (మరియు దానిని సృష్టించిన వెర్షన్)ను అప్‌లోడ్ చేయాలి. లేకపోతే, జీరో-కనౌలెడ్జి రుజువులు వేరే ప్రోగ్రామ్‌ను ప్రతిబింబించవచ్చు, ఒక వెనుక ద్వారం ఉన్నది.

బ్లాక్ ఎక్స్‌ప్లోరర్లు మాకు Noir ప్రోగ్రామ్‌లను అప్‌లోడ్ చేయడానికి మరియు ధృవీకరించడానికి అనుమతించే వరకు, మీరు దానిని మీరే చేయాలి (ప్రాధాన్యంగా IPFSకి). అప్పుడు అధునాతన వినియోగదారులు సోర్స్ కోడ్‌ను డౌన్‌లోడ్ చేసుకోగలరు, దానిని స్వయంగా కంపైల్ చేయగలరు, Verifier.solని సృష్టించగలరు మరియు అది ఆన్‌చైన్‌లో ఉన్న దానికి సమానంగా ఉందని ధృవీకరించగలరు.

ముగింపు

ప్లాస్మా-రకం అప్లికేషన్లకు సమాచార నిల్వగా ఒక కేంద్రీకృత భాగం అవసరం. ఇది సంభావ్య దుర్బలత్వాలను తెరుస్తుంది కానీ, ప్రతిఫలంగా, బ్లాక్ చైనులో అందుబాటులో లేని మార్గాలలో గోప్యతను కాపాడటానికి మనకు అనుమతిస్తుంది. జీరో-కనౌలెడ్జి రుజువులతో మనం సమగ్రతను నిర్ధారించవచ్చు మరియు కేంద్రీకృత భాగాన్ని నడుపుతున్న ఎవరికైనా లభ్యతను నిర్వహించడానికి ఆర్థికంగా ప్రయోజనకరంగా చేయవచ్చు.

నా మరిన్ని పనుల కోసం ఇక్కడ చూడండి (opens in a new tab).

ధన్యవాదాలు

• జోష్ క్రైట్స్ ఈ వ్యాసం యొక్క డ్రాఫ్ట్‌ను చదివి, ఒక ముళ్లలాంటి Noir సమస్యతో నాకు సహాయం చేశారు.

మిగిలిన ఏవైనా లోపాలు నా బాధ్యత.

పేజీ చివరి అప్‌డేట్: 3 మార్చి, 2026

m (opens in a new tab)

q (opens in a new tab)

w (opens in a new tab)

సహకారులను చూడండి