రహస్య చిరునామాలను ఉపయోగించడం

మీరు బిల్ అనుకుందాం. మనం చర్చించని కొన్ని కారణాల వల్ల, మీరు "ప్రపంచ రాణిగా ఆలిస్" ప్రచారానికి విరాళం ఇవ్వాలనుకుంటున్నారు మరియు మీరు విరాళం ఇచ్చినట్లు ఆలిస్‌కు తెలియజేయాలనుకుంటున్నారు, తద్వారా ఆమె గెలిస్తే మీకు ప్రతిఫలం ఇస్తుంది. దురదృష్టవశాత్తు, ఆమె విజయం ఖాయం కాదు. "సౌర వ్యవస్థ సామ్రాజ్ఞిగా కరోల్" అనే పోటీ ప్రచారం కూడా ఉంది. కరోల్ గెలిచి, మీరు ఆలిస్‌కు విరాళం ఇచ్చారని ఆమెకు తెలిస్తే, మీరు ఇబ్బందుల్లో పడతారు. కాబట్టి మీరు మీ ఖాతా నుండి ఆలిస్ ఖాతాకు నేరుగా 200 ETH బదిలీ చేయలేరు.

ERC-5564 (opens in a new tab) వద్ద దీనికి పరిష్కారం ఉంది. అనామక బదిలీ కోసం రహస్య చిరునామాలను (opens in a new tab) ఎలా ఉపయోగించాలో ఈ ERC వివరిస్తుంది.

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

రహస్య చిరునామాలు ఎలా పనిచేస్తాయి

ఈ కథనం రహస్య చిరునామాలను రెండు విధాలుగా వివరించడానికి ప్రయత్నిస్తుంది. మొదటిది వాటిని ఎలా ఉపయోగించాలి అనేది. మిగిలిన కథనాన్ని అర్థం చేసుకోవడానికి ఈ భాగం సరిపోతుంది. ఆ తర్వాత, దీని వెనుక ఉన్న గణితం యొక్క వివరణ ఉంటుంది. మీకు గూఢలిపి శాస్త్రం పట్ల ఆసక్తి ఉంటే, ఈ భాగాన్ని కూడా చదవండి.

సరళమైన వెర్షన్ (రహస్య చిరునామాలను ఎలా ఉపయోగించాలి)

ఆలిస్ రెండు ప్రైవేట్ కీలను సృష్టిస్తుంది మరియు వాటికి సంబంధించిన పబ్లిక్ కీలను ప్రచురిస్తుంది (వీటిని ఒకే డబుల్-లెంగ్త్ మెటా-చిరునామాగా కలపవచ్చు). బిల్ కూడా ఒక ప్రైవేట్ కీని సృష్టిస్తాడు మరియు దానికి సంబంధించిన పబ్లిక్ కీని ప్రచురిస్తాడు.

ఒకరి పబ్లిక్ కీ మరియు మరొకరి ప్రైవేట్ కీని ఉపయోగించి, మీరు ఆలిస్ మరియు బిల్ ఇద్దరికీ మాత్రమే తెలిసిన భాగస్వామ్య రహస్యాన్ని (shared secret) పొందవచ్చు (దీన్ని కేవలం పబ్లిక్ కీల నుండి మాత్రమే పొందలేము). ఈ భాగస్వామ్య రహస్యాన్ని ఉపయోగించి, బిల్ రహస్య చిరునామాను పొందుతాడు మరియు దానికి ఆస్తులను పంపగలడు.

ఆలిస్ కూడా భాగస్వామ్య రహస్యం నుండి చిరునామాను పొందుతుంది, కానీ ఆమె ప్రచురించిన పబ్లిక్ కీలకు సంబంధించిన ప్రైవేట్ కీలు ఆమెకు తెలుసు కాబట్టి, ఆ చిరునామా నుండి ఆస్తులను ఉపసంహరించుకోవడానికి అనుమతించే ప్రైవేట్ కీని కూడా ఆమె పొందగలదు.

గణితం (రహస్య చిరునామాలు ఇలా ఎందుకు పనిచేస్తాయి)

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

అందరికీ తెలిసిన ఒక సంఖ్య ఉంది, అదే G. మీరు G తో గుణించవచ్చు. కానీ ECC స్వభావం కారణంగా, G తో భాగించడం ఆచరణాత్మకంగా అసాధ్యం. ఎథీరియంలో పబ్లిక్ కీ గూఢలిపి శాస్త్రం సాధారణంగా పనిచేసే విధానం ఏమిటంటే, మీరు లావాదేవీలపై సంతకం చేయడానికి ప్రైవేట్ కీ, P_priv ని ఉపయోగించవచ్చు, ఆపై అవి పబ్లిక్ కీ, P_pub = GP_priv ద్వారా ధృవీకరించబడతాయి.

ఆలిస్ K_priv మరియు V_priv అనే రెండు ప్రైవేట్ కీలను సృష్టిస్తుంది. K_priv అనేది రహస్య చిరునామా నుండి డబ్బు ఖర్చు చేయడానికి ఉపయోగించబడుతుంది మరియు V_priv అనేది ఆలిస్‌కు చెందిన చిరునామాలను వీక్షించడానికి ఉపయోగించబడుతుంది. ఆలిస్ ఆపై పబ్లిక్ కీలను ప్రచురిస్తుంది: K_pub = GK_priv మరియు V_pub = GV_priv

బిల్ మూడవ ప్రైవేట్ కీ, R_priv ని సృష్టిస్తాడు మరియు R_pub = GR_priv ని ఒక కేంద్ర రిజిస్ట్రీలో ప్రచురిస్తాడు (బిల్ దానిని ఆలిస్‌కు కూడా పంపి ఉండవచ్చు, కానీ కరోల్ వింటున్నదని మనం అనుకుందాం).

బిల్ R_privV_pub = GR_privV_priv ని లెక్కిస్తాడు, ఇది ఆలిస్‌కు కూడా తెలుసని అతను ఆశిస్తాడు (దీని గురించి దిగువ వివరించబడింది). ఈ విలువను S, అంటే భాగస్వామ్య రహస్యం అని పిలుస్తారు. ఇది బిల్‌కు ఒక పబ్లిక్ కీ, P_pub = K_pub+G*hash(S) ని ఇస్తుంది. ఈ పబ్లిక్ కీ నుండి, అతను ఒక చిరునామాను లెక్కించవచ్చు మరియు దానికి అతను కోరుకున్న వనరులను పంపవచ్చు. భవిష్యత్తులో, ఆలిస్ గెలిస్తే, వనరులు తన నుండే వచ్చాయని నిరూపించడానికి బిల్ ఆమెకు R_priv ని చెప్పగలడు.

ఆలిస్ R_pubV_priv = GR_privV_priv ని లెక్కిస్తుంది. ఇది ఆమెకు అదే భాగస్వామ్య రహస్యం, S ని ఇస్తుంది. ఆమెకు ప్రైవేట్ కీ, K_priv తెలుసు కాబట్టి, ఆమె P_priv = K_priv+hash(S) ని లెక్కించగలదు. ఈ కీ ఆమెను P_pub = GP_priv = GK_priv+G*hash(S) = K_pub+G*hash(S) ఫలితంగా వచ్చే చిరునామాలోని ఆస్తులను యాక్సెస్ చేయడానికి అనుమతిస్తుంది.

ఆలిస్ డేవ్స్ వరల్డ్ డామినేషన్ క్యాంపెయిన్ సర్వీసెస్‌కు సబ్‌కాంట్రాక్ట్ ఇవ్వడానికి వీలుగా మనకు ప్రత్యేక వీక్షణ కీ (viewing key) ఉంది. పబ్లిక్ చిరునామాలను డేవ్ తెలుసుకోవడానికి మరియు మరింత డబ్బు అందుబాటులో ఉన్నప్పుడు తనకు తెలియజేయడానికి ఆలిస్ సిద్ధంగా ఉంది, కానీ అతను తన ప్రచార డబ్బును ఖర్చు చేయడం ఆమెకు ఇష్టం లేదు.

వీక్షించడానికి మరియు ఖర్చు చేయడానికి వేర్వేరు కీలను ఉపయోగిస్తున్నందున, ఆలిస్ డేవ్‌కు V_priv ని ఇవ్వగలదు. అప్పుడు డేవ్ S = R_pubV_priv = GR_privV_priv ని లెక్కించగలడు మరియు ఆ విధంగా పబ్లిక్ కీలను (P_pub = K_pub+G*hash(S)) పొందగలడు. కానీ K_priv లేకుండా డేవ్ ప్రైవేట్ కీని పొందలేడు.

సారాంశంలో, వివిధ పాల్గొనేవారికి తెలిసిన విలువలు ఇవి.

రహస్య చిరునామాలు తప్పుగా పనిచేసినప్పుడు

బ్లాక్‌చైన్‌లో ఎలాంటి రహస్యాలు ఉండవు. రహస్య చిరునామాలు మీకు గోప్యతను అందించినప్పటికీ, ఆ గోప్యత ట్రాఫిక్ విశ్లేషణకు గురయ్యే అవకాశం ఉంది. ఒక చిన్న ఉదాహరణను తీసుకుంటే, బిల్ ఒక చిరునామాకు నిధులు సమకూర్చి, వెంటనే R_pub విలువను ప్రచురించడానికి ఒక లావాదేవీని పంపుతాడని ఊహించుకోండి. ఆలిస్ యొక్క V_priv లేకుండా, ఇది రహస్య చిరునామా అని మనం ఖచ్చితంగా చెప్పలేము, కానీ అలా అనుకోవడానికి ఆస్కారం ఉంది. ఆ తర్వాత, ఆ చిరునామా నుండి మొత్తం ETH ని ఆలిస్ ప్రచార నిధి చిరునామాకు బదిలీ చేసే మరొక లావాదేవీని మనం చూస్తాము. మనం దానిని నిరూపించలేకపోవచ్చు, కానీ బిల్ ఆలిస్ ప్రచారానికి విరాళం ఇచ్చి ఉండే అవకాశం ఉంది. కరోల్ ఖచ్చితంగా అలాగే అనుకుంటుంది.

రహస్య చిరునామాకు నిధులు సమకూర్చడం నుండి R_pub ప్రచురణను వేరు చేయడం బిల్‌కు సులభం (వాటిని వేర్వేరు సమయాల్లో, వేర్వేరు చిరునామాల నుండి చేయవచ్చు). అయితే, అది సరిపోదు. కరోల్ వెతికే నమూనా ఏమిటంటే, బిల్ ఒక చిరునామాకు నిధులు సమకూర్చడం, ఆపై ఆలిస్ ప్రచార నిధి దాని నుండి ఉపసంహరించుకోవడం.

దీనికి ఒక పరిష్కారం ఏమిటంటే, ఆలిస్ ప్రచారం నేరుగా డబ్బును ఉపసంహరించుకోకుండా, మూడవ పక్షానికి చెల్లించడానికి దానిని ఉపయోగించడం. ఆలిస్ ప్రచారం డేవ్స్ వరల్డ్ డామినేషన్ క్యాంపెయిన్ సర్వీసెస్‌కు 10 ETH పంపితే, బిల్ డేవ్ కస్టమర్లలో ఒకరికి విరాళం ఇచ్చాడని మాత్రమే కరోల్‌కు తెలుస్తుంది. డేవ్‌కు తగినంత మంది కస్టమర్‌లు ఉంటే, బిల్ తనతో పోటీపడే ఆలిస్‌కు విరాళం ఇచ్చాడా, లేదా కరోల్ పట్టించుకోని ఆడమ్, ఆల్బర్ట్ లేదా అబిగైల్‌కు విరాళం ఇచ్చాడా అనేది కరోల్ తెలుసుకోలేకపోతుంది. ఆలిస్ చెల్లింపుతో పాటు హాష్ చేయబడిన విలువను చేర్చవచ్చు, ఆపై అది తన విరాళం అని నిరూపించడానికి డేవ్‌కు ప్రీఇమేజ్‌ను అందించవచ్చు. ప్రత్యామ్నాయంగా, పైన పేర్కొన్నట్లుగా, ఆలిస్ డేవ్‌కు తన V_priv ని ఇస్తే, చెల్లింపు ఎవరి నుండి వచ్చిందో అతనికి ముందే తెలుస్తుంది.

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

బహుళ రహస్య పొరలను ఉపయోగించడం

బిల్ గోప్యతను కాపాడటానికి ఆలిస్‌పై ఆధారపడే బదులు, బిల్ దానిని స్వయంగా చేయగలడు. అతను కల్పిత వ్యక్తులైన బాబ్ మరియు బెల్లా కోసం బహుళ మెటా-చిరునామాలను రూపొందించగలడు. బిల్ ఆపై బాబ్‌కు ETH పంపుతాడు, మరియు "బాబ్" (అతను వాస్తవానికి బిల్) దానిని బెల్లాకు పంపుతాడు. "బెల్లా" (కూడా బిల్) దానిని ఆలిస్‌కు పంపుతుంది.

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

రహస్య-చిరునామా అప్లికేషన్‌ను రాయడం

ఈ కథనం GitHub లో అందుబాటులో ఉన్న (opens in a new tab) రహస్య-చిరునామా అప్లికేషన్‌ను వివరిస్తుంది.

సాధనాలు

మనం ఉపయోగించగల ఒక TypeScript రహస్య చిరునామా లైబ్రరీ (opens in a new tab) ఉంది. అయితే, గూఢలిపి శాస్త్ర కార్యకలాపాలు CPU-ఇంటెన్సివ్‌గా ఉండవచ్చు. నేను వాటిని Rust (opens in a new tab) వంటి కంపైల్ చేయబడిన భాషలో అమలు చేయడానికి మరియు బ్రౌజర్‌లో కోడ్‌ను రన్ చేయడానికి WASM (opens in a new tab) ని ఉపయోగించడానికి ఇష్టపడతాను.

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

రహస్య చిరునామాలు ఎలా పనిచేస్తాయో చూడండి

1. అవసరమైన సాధనాలను ఇన్‌స్టాల్ చేయండి: Rust (opens in a new tab) మరియు Node (opens in a new tab).

2. GitHub రిపోజిటరీని క్లోన్ చేయండి.

   git clone https://github.com/qbzzt/251022-stealth-addresses.git
   cd 251022-stealth-addresses
   

   కాపీ చేయండిShell

3. ముందస్తు అవసరాలను ఇన్‌స్టాల్ చేయండి మరియు Rust కోడ్‌ను కంపైల్ చేయండి.

   cd src/rust-wasm
   rustup target add wasm32-unknown-unknown   
   cargo install wasm-pack   
   wasm-pack build --target web
   

   కాపీ చేయండిShell

4. వెబ్ సర్వర్‌ను ప్రారంభించండి.

   cd ../..
   npm install
   npm run dev
   

   కాపీ చేయండిShell

5. అప్లికేషన్‌కు (opens in a new tab) బ్రౌజ్ చేయండి. ఈ అప్లికేషన్ పేజీలో రెండు ఫ్రేమ్‌లు ఉన్నాయి: ఒకటి ఆలిస్ యూజర్ ఇంటర్‌ఫేస్ కోసం మరియు మరొకటి బిల్ కోసం. ఈ రెండు ఫ్రేమ్‌లు కమ్యూనికేట్ చేసుకోవు; అవి సౌలభ్యం కోసం మాత్రమే ఒకే పేజీలో ఉంటాయి.

6. ఆలిస్‌గా, Generate a Stealth Meta-Address పై క్లిక్ చేయండి. ఇది కొత్త రహస్య చిరునామాను మరియు దానికి సంబంధించిన ప్రైవేట్ కీలను ప్రదర్శిస్తుంది. రహస్య మెటా-చిరునామాను క్లిప్‌బోర్డ్‌కు కాపీ చేయండి.

7. బిల్‌గా, కొత్త రహస్య మెటా-చిరునామాను పేస్ట్ చేసి, Generate an address పై క్లిక్ చేయండి. ఇది ఆలిస్ కోసం నిధులు సమకూర్చాల్సిన చిరునామాను మీకు ఇస్తుంది.

8. చిరునామాను మరియు బిల్ పబ్లిక్ కీని కాపీ చేసి, వాటిని ఆలిస్ యూజర్ ఇంటర్‌ఫేస్‌లోని "Private key for address generated by Bill" ప్రాంతంలో పేస్ట్ చేయండి. ఆ ఫీల్డ్‌లు నింపబడిన తర్వాత, ఆ చిరునామాలోని ఆస్తులను యాక్సెస్ చేయడానికి ప్రైవేట్ కీని మీరు చూస్తారు.

9. ప్రైవేట్ కీ చిరునామాకు అనుగుణంగా ఉందో లేదో నిర్ధారించుకోవడానికి మీరు ఆన్‌లైన్ కాలిక్యులేటర్‌ను (opens in a new tab) ఉపయోగించవచ్చు.

ప్రోగ్రామ్ ఎలా పనిచేస్తుంది

WASM కాంపోనెంట్

WASM లోకి కంపైల్ అయ్యే సోర్స్ కోడ్ Rust (opens in a new tab) లో వ్రాయబడింది. మీరు దానిని src/rust_wasm/src/lib.rs (opens in a new tab) లో చూడవచ్చు. ఈ కోడ్ ప్రధానంగా JavaScript కోడ్ మరియు eth-stealth-addresses లైబ్రరీ (opens in a new tab) మధ్య ఇంటర్‌ఫేస్‌గా పనిచేస్తుంది.

Cargo.toml

Rust లోని Cargo.toml (opens in a new tab) అనేది JavaScript లోని package.json (opens in a new tab) కి సమానం. ఇది ప్యాకేజీ సమాచారం, డిపెండెన్సీ డిక్లరేషన్‌లు మొదలైనవాటిని కలిగి ఉంటుంది.

[package]
name = "rust-wasm"
version = "0.1.0"
edition = "2024"

[dependencies]
eth-stealth-addresses = "0.1.0"
hex = "0.4.3"
wasm-bindgen = "0.2.104"
getrandom = { version = "0.2", features = ["js"] }

getrandom (opens in a new tab) ప్యాకేజీ యాదృచ్ఛిక విలువలను రూపొందించాలి. అది కేవలం అల్గారిథమిక్ మార్గాల ద్వారా చేయబడదు; దానికి ఎంట్రోపీ మూలంగా భౌతిక ప్రక్రియకు యాక్సెస్ అవసరం. మనం రన్ చేస్తున్న బ్రౌజర్‌ను అడగడం ద్వారా ఆ ఎంట్రోపీని పొందుతామని ఈ నిర్వచనం నిర్దేశిస్తుంది.

console_error_panic_hook = "0.1.7"

WASM కోడ్ పానిక్ అయినప్పుడు మరియు కొనసాగలేనప్పుడు ఈ లైబ్రరీ (opens in a new tab) మనకు మరింత అర్థవంతమైన ఎర్రర్ సందేశాలను ఇస్తుంది.

[lib]
crate-type = ["cdylib", "rlib"]

WASM కోడ్‌ను ఉత్పత్తి చేయడానికి అవసరమైన అవుట్‌పుట్ రకం.

lib.rs

ఇది అసలు Rust కోడ్.

use wasm_bindgen::prelude::*;

Rust నుండి WASM ప్యాకేజీని సృష్టించడానికి నిర్వచనాలు. అవి ఇక్కడ (opens in a new tab) డాక్యుమెంట్ చేయబడ్డాయి.

use eth_stealth_addresses::{
    generate_stealth_meta_address,
    generate_stealth_address,
    compute_stealth_key
};

eth-stealth-addresses లైబ్రరీ (opens in a new tab) నుండి మనకు అవసరమైన ఫంక్షన్‌లు.

use hex::{decode,encode};

Rust సాధారణంగా విలువల కోసం బైట్ అరేలను (opens in a new tab) ([u8; <size>]) ఉపయోగిస్తుంది. కానీ JavaScript లో, మనం సాధారణంగా హెక్సాడెసిమల్ స్ట్రింగ్‌లను ఉపయోగిస్తాము. hex లైబ్రరీ (opens in a new tab) మన కోసం ఒక ప్రాతినిధ్యం నుండి మరొక దానికి అనువదిస్తుంది.

#[wasm_bindgen]

JavaScript నుండి ఈ ఫంక్షన్‌ను కాల్ చేయడానికి వీలుగా WASM బైండింగ్‌లను రూపొందించండి.

pub fn wasm_generate_stealth_meta_address() -> String {

బహుళ ఫీల్డ్‌లతో కూడిన ఆబ్జెక్ట్‌ను తిరిగి ఇవ్వడానికి సులభమైన మార్గం JSON స్ట్రింగ్‌ను తిరిగి ఇవ్వడం.

    let (address, spend_private_key, view_private_key) = 
        generate_stealth_meta_address();

generate_stealth_meta_address (opens in a new tab) మూడు ఫీల్డ్‌లను తిరిగి ఇస్తుంది:

• మెటా-చిరునామా (K_pub మరియు V_pub)
• వీక్షణ ప్రైవేట్ కీ (V_priv)
• ఖర్చు చేసే ప్రైవేట్ కీ (K_priv)

టపుల్ (tuple) (opens in a new tab) సింటాక్స్ ఆ విలువలను మళ్లీ వేరు చేయడానికి మనల్ని అనుమతిస్తుంది.

    format!("{{\"address\":\"{}\",\"view_private_key\":\"{}\",\"spend_private_key\":\"{}\"}}",
        encode(address),
        encode(view_private_key),
        encode(spend_private_key)
    )
}

JSON-ఎన్‌కోడ్ చేయబడిన స్ట్రింగ్‌ను రూపొందించడానికి format! (opens in a new tab) మ్యాక్రోను ఉపయోగించండి. అరేలను హెక్స్ స్ట్రింగ్‌లుగా మార్చడానికి hex::encode (opens in a new tab) ని ఉపయోగించండి.

fn str_to_array<const N: usize>(s: &str) -> Option<[u8; N]> {

ఈ ఫంక్షన్ (JavaScript ద్వారా అందించబడిన) హెక్స్ స్ట్రింగ్‌ను బైట్ అరేగా మారుస్తుంది. JavaScript కోడ్ ద్వారా అందించబడిన విలువలను పార్స్ చేయడానికి మనం దీనిని ఉపయోగిస్తాము. Rust అరేలు మరియు వెక్టర్‌లను ఎలా నిర్వహిస్తుందనే దాని కారణంగా ఈ ఫంక్షన్ సంక్లిష్టంగా ఉంటుంది.

<const N: usize> ఎక్స్‌ప్రెషన్‌ను జెనరిక్ (generic) (opens in a new tab) అని పిలుస్తారు. N అనేది తిరిగి ఇవ్వబడిన అరే పొడవును నియంత్రించే పారామితి. ఫంక్షన్ వాస్తవానికి str_to_array::<n> అని పిలువబడుతుంది, ఇక్కడ n అనేది అరే పొడవు.

రిటర్న్ విలువ Option<[u8; N]>, అంటే తిరిగి ఇవ్వబడిన అరే ఆప్షనల్ (optional) (opens in a new tab) అని అర్థం. విఫలమయ్యే అవకాశం ఉన్న ఫంక్షన్‌ల కోసం Rust లో ఇది ఒక సాధారణ నమూనా.

ఉదాహరణకు, మనం str_to_array::10("bad060a7") ని కాల్ చేస్తే, ఫంక్షన్ పది-విలువల అరేను తిరిగి ఇవ్వాలి, కానీ ఇన్‌పుట్ కేవలం నాలుగు బైట్‌లు మాత్రమే. ఫంక్షన్ విఫలం కావాలి, మరియు అది None ని తిరిగి ఇవ్వడం ద్వారా అలా చేస్తుంది. str_to_array::4("bad060a7") కోసం రిటర్న్ విలువ Some<[0xba, 0xd0, 0x60, 0xa7]> అవుతుంది.

    // decode Result<Vec<u8>, _> ను తిరిగి ఇస్తుంది
    let vec = decode(s).ok()?;

hex::decode (opens in a new tab) ఫంక్షన్ Result<Vec<u8>, FromHexError> ని తిరిగి ఇస్తుంది. Result (opens in a new tab) రకం విజయవంతమైన ఫలితాన్ని (Ok(value)) లేదా ఎర్రర్‌ను (Err(error)) కలిగి ఉంటుంది.

.ok() పద్ధతి Result ని Option గా మారుస్తుంది, దీని విలువ విజయవంతమైతే Ok() విలువ లేదా కాకపోతే None అవుతుంది. చివరగా, Option ఖాళీగా ఉంటే ప్రశ్నార్థక ఆపరేటర్ (opens in a new tab) ప్రస్తుత ఫంక్షన్‌లను నిలిపివేసి None ని తిరిగి ఇస్తుంది. లేకపోతే, అది విలువను అన్‌రాప్ చేసి దానిని తిరిగి ఇస్తుంది (ఈ సందర్భంలో, vec కి విలువను కేటాయించడానికి).

ఎర్రర్‌లను నిర్వహించడానికి ఇది వింతగా సంక్లిష్టమైన పద్ధతిగా కనిపిస్తుంది, కానీ Result మరియు Option అన్ని ఎర్రర్‌లు ఏదో ఒక విధంగా నిర్వహించబడేలా చూస్తాయి.

    if vec.len() != N { return None; }

బైట్‌ల సంఖ్య తప్పుగా ఉంటే, అది వైఫల్యం, మరియు మనం None ని తిరిగి ఇస్తాము.

    // try_into vec ను వినియోగిస్తుంది మరియు [u8; N] చేయడానికి ప్రయత్నిస్తుంది
    let array: [u8; N] = vec.try_into().ok()?;

Rust లో రెండు అరే రకాలు ఉన్నాయి. అరేలు (opens in a new tab) స్థిరమైన పరిమాణాన్ని కలిగి ఉంటాయి. వెక్టర్లు (opens in a new tab) పెరగగలవు మరియు తగ్గగలవు. hex::decode ఒక వెక్టర్‌ను తిరిగి ఇస్తుంది, కానీ eth_stealth_addresses లైబ్రరీ అరేలను స్వీకరించాలనుకుంటుంది. .try_into() (opens in a new tab) ఒక విలువను మరొక రకంగా మారుస్తుంది, ఉదాహరణకు, వెక్టర్‌ను అరేగా.

    Some(array)
}

ఫంక్షన్ చివరలో విలువను తిరిగి ఇచ్చేటప్పుడు మీరు return (opens in a new tab) కీవర్డ్‌ను ఉపయోగించాల్సిన అవసరం Rust కు లేదు.

#[wasm_bindgen]
pub fn wasm_generate_stealth_address(stealth_address: &str) -> Option<String> {

ఈ ఫంక్షన్ పబ్లిక్ మెటా-చిరునామాను స్వీకరిస్తుంది, ఇందులో V_pub మరియు K_pub రెండూ ఉంటాయి. ఇది రహస్య చిరునామాను, ప్రచురించాల్సిన పబ్లిక్ కీని (R_pub), మరియు ప్రచురించబడిన చిరునామాలలో ఏవి ఆలిస్‌కు చెందినవి కావచ్చో గుర్తించడాన్ని వేగవంతం చేసే ఒక-బైట్ స్కాన్ విలువను తిరిగి ఇస్తుంది.

స్కాన్ విలువ అనేది భాగస్వామ్య రహస్యంలో (S = GR_privV_priv) ఒక భాగం. ఈ విలువ ఆలిస్‌కు అందుబాటులో ఉంటుంది, మరియు f(K_pub+G*hash(S)) ప్రచురించబడిన చిరునామాకు సమానంగా ఉందో లేదో తనిఖీ చేయడం కంటే దీనిని తనిఖీ చేయడం చాలా వేగంగా ఉంటుంది.

    let (address, r_pub, scan) = 
        generate_stealth_address(&str_to_array::<66>(stealth_address)?);

మనం లైబ్రరీ యొక్క generate_stealth_address (opens in a new tab) ని ఉపయోగిస్తాము.

    format!("{{\"address\":\"{}\",\"rPub\":\"{}\",\"scan\":\"{}\"}}",
        encode(address),
        encode(r_pub),
        encode(&[scan])
    ).into()
}

JSON-ఎన్‌కోడ్ చేయబడిన అవుట్‌పుట్ స్ట్రింగ్‌ను సిద్ధం చేయండి.

#[wasm_bindgen]
pub fn wasm_compute_stealth_key(
    address: &str, 
    bill_pub_key: &str, 
    view_private_key: &str,
    spend_private_key: &str    
) -> Option<String> {
    .
    .
    .
}

చిరునామా నుండి ఉపసంహరించుకోవడానికి ప్రైవేట్ కీని (R_priv) లెక్కించడానికి ఈ ఫంక్షన్ లైబ్రరీ యొక్క compute_stealth_key (opens in a new tab) ని ఉపయోగిస్తుంది. ఈ గణనకు ఈ విలువలు అవసరం:

• చిరునామా (Address=f(P_pub))
• బిల్ రూపొందించిన పబ్లిక్ కీ (R_pub)
• వీక్షణ ప్రైవేట్ కీ (V_priv)
• ఖర్చు చేసే ప్రైవేట్ కీ (K_priv)

#[wasm_bindgen(start)]

WASM కోడ్ ప్రారంభించబడినప్పుడు ఫంక్షన్ అమలు చేయబడుతుందని #[wasm_bindgen(start)] (opens in a new tab) నిర్దేశిస్తుంది.

pub fn main() {
    console_error_panic_hook::set_once();
}

పానిక్ అవుట్‌పుట్ JavaScript కన్సోల్‌కు పంపబడాలని ఈ కోడ్ నిర్దేశిస్తుంది. ఇది ఎలా పనిచేస్తుందో చూడటానికి, అప్లికేషన్‌ను ఉపయోగించండి మరియు బిల్‌కు చెల్లని మెటా-చిరునామాను ఇవ్వండి (కేవలం ఒక హెక్సాడెసిమల్ అంకెను మార్చండి). మీరు JavaScript కన్సోల్‌లో ఈ ఎర్రర్‌ను చూస్తారు:

rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs:701:9:
assertion `left == right` failed
  left: 0
 right: 1

దీని తర్వాత స్టాక్ ట్రేస్ వస్తుంది. ఆపై బిల్‌కు చెల్లుబాటు అయ్యే మెటా-చిరునామాను ఇవ్వండి, మరియు ఆలిస్‌కు చెల్లని చిరునామాను లేదా చెల్లని పబ్లిక్ కీని ఇవ్వండి. మీరు ఈ ఎర్రర్‌ను చూస్తారు:

rust_wasm.js:236 panicked at /home/ori/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/eth-stealth-addresses-0.1.0/src/lib.rs:78:9:
keys do not generate stealth address

మళ్లీ, దీని తర్వాత స్టాక్ ట్రేస్ వస్తుంది.

యూజర్ ఇంటర్‌ఫేస్

యూజర్ ఇంటర్‌ఫేస్ React (opens in a new tab) ని ఉపయోగించి వ్రాయబడింది మరియు Vite (opens in a new tab) ద్వారా అందించబడుతుంది. మీరు ఈ ట్యుటోరియల్‌ని ఉపయోగించి వాటి గురించి తెలుసుకోవచ్చు. మనం నేరుగా బ్లాక్‌చైన్ లేదా వాలెట్‌తో ఇంటరాక్ట్ అవ్వము కాబట్టి ఇక్కడ Wagmi (opens in a new tab) అవసరం లేదు.

యూజర్ ఇంటర్‌ఫేస్‌లో స్పష్టంగా తెలియని ఏకైక భాగం WASM కనెక్టివిటీ. ఇది ఎలా పనిచేస్తుందో ఇక్కడ ఉంది.

vite.config.js

ఈ ఫైల్ Vite కాన్ఫిగరేషన్‌ను (opens in a new tab) కలిగి ఉంటుంది.

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import wasm from "vite-plugin-wasm";

// https://vite.dev/config/
export default defineConfig({
  plugins: [react(), wasm()],
})

మనకు రెండు Vite ప్లగిన్‌లు అవసరం: react (opens in a new tab) మరియు wasm (opens in a new tab).

App.jsx

ఈ ఫైల్ అప్లికేషన్ యొక్క ప్రధాన కాంపోనెంట్. ఇది రెండు కాంపోనెంట్‌లను కలిగి ఉన్న కంటైనర్: Alice మరియు Bill, ఆ వినియోగదారుల కోసం యూజర్ ఇంటర్‌ఫేస్‌లు. WASM కి సంబంధించిన భాగం ఇనిషియలైజేషన్ కోడ్.

import init from './rust-wasm/pkg/rust_wasm.js'

మనం wasm-pack (opens in a new tab) ని ఉపయోగించినప్పుడు, అది మనం ఇక్కడ ఉపయోగించే రెండు ఫైల్‌లను సృష్టిస్తుంది: అసలు కోడ్‌తో కూడిన wasm ఫైల్ (ఇక్కడ, src/rust-wasm/pkg/rust_wasm_bg.wasm) మరియు దానిని ఉపయోగించడానికి నిర్వచనాలతో కూడిన JavaScript ఫైల్ (ఇక్కడ, src/rust_wasm/pkg/rust_wasm.js). ఆ JavaScript ఫైల్ యొక్క డిఫాల్ట్ ఎక్స్‌పోర్ట్ అనేది WASM ని ప్రారంభించడానికి రన్ చేయాల్సిన కోడ్.

function App() {
    .
    .
    .
  useEffect(() => {
    const loadWasm = async () => {
      try {
        await init();
        setWasmReady(true)
      } catch (err) {
        console.error('Error loading wasm:', err)
        alert("Wasm error: " + err)
      }
    }

    loadWasm()
    }, []
  )

useEffect హుక్ (opens in a new tab) స్థితి (state) వేరియబుల్స్ మారినప్పుడు అమలు చేయబడే ఫంక్షన్‌ను పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇక్కడ, స్థితి వేరియబుల్స్ జాబితా ఖాళీగా ఉంది ([]), కాబట్టి పేజీ లోడ్ అయినప్పుడు ఈ ఫంక్షన్ ఒక్కసారి మాత్రమే అమలు చేయబడుతుంది.

ఎఫెక్ట్ ఫంక్షన్ వెంటనే తిరిగి రావాలి. WASM init వంటి అసమకాలిక (asynchronous) కోడ్‌ను ఉపయోగించడానికి (ఇది .wasm ఫైల్‌ను లోడ్ చేయాలి కాబట్టి సమయం పడుతుంది) మనం అంతర్గత async (opens in a new tab) ఫంక్షన్‌ను నిర్వచిస్తాము మరియు దానిని await లేకుండా రన్ చేస్తాము.

Bill.jsx

ఇది బిల్ కోసం యూజర్ ఇంటర్‌ఫేస్. ఇది ఒకే చర్యను కలిగి ఉంటుంది, ఆలిస్ అందించిన రహస్య మెటా-చిరునామా ఆధారంగా చిరునామాను సృష్టించడం.

import { wasm_generate_stealth_address } from './rust-wasm/pkg/rust_wasm.js'

డిఫాల్ట్ ఎక్స్‌పోర్ట్‌తో పాటు, wasm-pack ద్వారా రూపొందించబడిన JavaScript కోడ్ WASM కోడ్‌లోని ప్రతి ఫంక్షన్ కోసం ఒక ఫంక్షన్‌ను ఎక్స్‌పోర్ట్ చేస్తుంది.

            <button onClick={() => {
              setPublicAddress(JSON.parse(wasm_generate_stealth_address(stealthMetaAddress)))
            }}>

WASM ఫంక్షన్‌లను కాల్ చేయడానికి, మనం wasm-pack ద్వారా సృష్టించబడిన JavaScript ఫైల్ ఎక్స్‌పోర్ట్ చేసిన ఫంక్షన్‌ను కాల్ చేస్తాము.

Alice.jsx

Alice.jsx లోని కోడ్ కూడా ఇలాగే ఉంటుంది, కాకపోతే ఆలిస్‌కు రెండు చర్యలు ఉంటాయి:

• మెటా-చిరునామాను రూపొందించడం
• బిల్ ప్రచురించిన చిరునామా కోసం ప్రైవేట్ కీని పొందడం

ముగింపు

రహస్య చిరునామాలు సర్వరోగ నివారిణి కాదు; వాటిని సరిగ్గా ఉపయోగించాలి. కానీ సరిగ్గా ఉపయోగించినప్పుడు, అవి పబ్లిక్ బ్లాక్‌చైన్‌లో గోప్యతను ప్రారంభించగలవు.

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