---
title: "రహస్య చిరునామాలను ఉపయోగించడం"
description: "రహస్య చిరునామాలు వినియోగదారులను అనామకంగా ఆస్తులను బదిలీ చేయడానికి అనుమతిస్తాయి. ఈ కథనాన్ని చదివిన తర్వాత, మీరు వీటిని చేయగలరు: రహస్య చిరునామాలు అంటే ఏమిటి మరియు అవి ఎలా పనిచేస్తాయో వివరించడం, అనామకత్వాన్ని కాపాడే విధంగా రహస్య చిరునామాలను ఎలా ఉపయోగించాలో అర్థం చేసుకోవడం మరియు రహస్య చిరునామాలను ఉపయోగించే వెబ్ ఆధారిత అప్లికేషన్‌ను రాయడం."
author: "ఓరి పోమెరాంజ్"
tags:
  - రహస్య చిరునామా
  - గోప్యత
  - గూఢలిపి శాస్త్రం
  - Rust
  - WASM
skill: intermediate
breadcrumb: "రహస్య చిరునామాలు"
published: 2025-11-30
lang: te
sidebarDepth: 3
---

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

[ERC-5564](https://eips.ethereum.org/EIPS/eip-5564) వద్ద దీనికి పరిష్కారం ఉంది. అనామక బదిలీ కోసం [రహస్య చిరునామాలను](https://nerolation.github.io/stealth-utils) ఎలా ఉపయోగించాలో ఈ ERC వివరిస్తుంది.

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

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

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

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

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

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

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

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

ప్రామాణిక రహస్య చిరునామాలు తక్కువ కీ బిట్‌లతో మెరుగైన పనితీరును పొందడానికి [ఎలిప్టిక్-కర్వ్ క్రిప్టోగ్రఫీ (ECC)](https://blog.cloudflare.com/a-relatively-easy-to-understand-primer-on-elliptic-curve-cryptography/#elliptic-curves-building-blocks-of-a-better-trapdoor)ని ఉపయోగిస్తాయి, అదే సమయంలో అదే స్థాయి భద్రతను నిర్వహిస్తాయి. కానీ చాలా వరకు మనం దానిని విస్మరించవచ్చు మరియు మనం సాధారణ అంకగణితాన్ని ఉపయోగిస్తున్నట్లుగా భావించవచ్చు.

అందరికీ తెలిసిన ఒక సంఖ్య ఉంది, అదే *G*. మీరు *G* తో గుణించవచ్చు. కానీ ECC స్వభావం కారణంగా, *G* తో భాగించడం ఆచరణాత్మకంగా అసాధ్యం. ఎథీరియంలో పబ్లిక్ కీ గూఢలిపి శాస్త్రం సాధారణంగా పనిచేసే విధానం ఏమిటంటే, మీరు లావాదేవీలపై సంతకం చేయడానికి ప్రైవేట్ కీ, *P<sub>priv</sub>* ని ఉపయోగించవచ్చు, ఆపై అవి పబ్లిక్ కీ, *P<sub>pub</sub> = GP<sub>priv</sub>* ద్వారా ధృవీకరించబడతాయి. 

ఆలిస్ *K<sub>priv</sub>* మరియు *V<sub>priv</sub>* అనే రెండు ప్రైవేట్ కీలను సృష్టిస్తుంది. *K<sub>priv</sub>* అనేది రహస్య చిరునామా నుండి డబ్బు ఖర్చు చేయడానికి ఉపయోగించబడుతుంది మరియు *V<sub>priv</sub>* అనేది ఆలిస్‌కు చెందిన చిరునామాలను వీక్షించడానికి ఉపయోగించబడుతుంది. ఆలిస్ ఆపై పబ్లిక్ కీలను ప్రచురిస్తుంది: *K<sub>pub</sub> = GK<sub>priv</sub>* మరియు *V<sub>pub</sub> = GV<sub>priv</sub>*

బిల్ మూడవ ప్రైవేట్ కీ, *R<sub>priv</sub>* ని సృష్టిస్తాడు మరియు *R<sub>pub</sub> = GR<sub>priv</sub>* ని ఒక కేంద్ర రిజిస్ట్రీలో ప్రచురిస్తాడు (బిల్ దానిని ఆలిస్‌కు కూడా పంపి ఉండవచ్చు, కానీ కరోల్ వింటున్నదని మనం అనుకుందాం).

బిల్ *R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>* ని లెక్కిస్తాడు, ఇది ఆలిస్‌కు కూడా తెలుసని అతను ఆశిస్తాడు (దీని గురించి దిగువ వివరించబడింది). ఈ విలువను *S*, అంటే భాగస్వామ్య రహస్యం అని పిలుస్తారు. ఇది బిల్‌కు ఒక పబ్లిక్ కీ, *P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)* ని ఇస్తుంది. ఈ పబ్లిక్ కీ నుండి, అతను ఒక చిరునామాను లెక్కించవచ్చు మరియు దానికి అతను కోరుకున్న వనరులను పంపవచ్చు. భవిష్యత్తులో, ఆలిస్ గెలిస్తే, వనరులు తన నుండే వచ్చాయని నిరూపించడానికి బిల్ ఆమెకు *R<sub>priv</sub>* ని చెప్పగలడు.

ఆలిస్ *R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>* ని లెక్కిస్తుంది. ఇది ఆమెకు అదే భాగస్వామ్య రహస్యం, *S* ని ఇస్తుంది. ఆమెకు ప్రైవేట్ కీ, *K<sub>priv</sub>* తెలుసు కాబట్టి, ఆమె *P<sub>priv</sub> = K<sub>priv</sub>+hash(S)* ని లెక్కించగలదు. ఈ కీ ఆమెను *P<sub>pub</sub> = GP<sub>priv</sub> = GK<sub>priv</sub>+G\*hash(S) = K<sub>pub</sub>+G\*hash(S)* ఫలితంగా వచ్చే చిరునామాలోని ఆస్తులను యాక్సెస్ చేయడానికి అనుమతిస్తుంది.

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

వీక్షించడానికి మరియు ఖర్చు చేయడానికి వేర్వేరు కీలను ఉపయోగిస్తున్నందున, ఆలిస్ డేవ్‌కు *V<sub>priv</sub>* ని ఇవ్వగలదు. అప్పుడు డేవ్ *S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>* ని లెక్కించగలడు మరియు ఆ విధంగా పబ్లిక్ కీలను (*P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)*) పొందగలడు. కానీ *K<sub>priv</sub>* లేకుండా డేవ్ ప్రైవేట్ కీని పొందలేడు.

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

| ఆలిస్ | ప్రచురించబడినవి | బిల్ | డేవ్ |
| - | - | - | - |
| G | G | G | G |
| *K<sub>priv</sub>* | - | - | - | 
| *V<sub>priv</sub>* | - | - | *V<sub>priv</sub>* |
| *K<sub>pub</sub> = GK<sub>priv</sub>* | *K<sub>pub</sub>* | *K<sub>pub</sub>* | *K<sub>pub</sub>* |
| *V<sub>pub</sub> = GV<sub>priv</sub>* | *V<sub>pub</sub>* | *V<sub>pub</sub>* | *V<sub>pub</sub>* |
| - | - | *R<sub>priv</sub>* | - |
| *R<sub>pub</sub>* | *R<sub>pub</sub>* | *R<sub>pub</sub> = GR<sub>priv</sub>* | *R<sub>pub</sub>* |
| *S = R<sub>pub</sub>V<sub>priv</sub> = GR<sub>priv</sub>V<sub>priv</sub>* | - | *S = R<sub>priv</sub>V<sub>pub</sub> = GR<sub>priv</sub>V<sub>priv</sub>* | *S = *R<sub>pub</sub>V<sub>priv</sub>* = GR<sub>priv</sub>V<sub>priv</sub>* |
| *P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)* | - | *P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)* | *P<sub>pub</sub> = K<sub>pub</sub>+G\*hash(S)* |
| *Address=f(P<sub>pub</sub>)* | - | *Address=f(P<sub>pub</sub>)* | *Address=f(P<sub>pub</sub>)* | *Address=f(P<sub>pub</sub>)*
| *P<sub>priv</sub> = K<sub>priv</sub>+hash(S)* | - | - | - |

## రహస్య చిరునామాలు తప్పుగా పనిచేసినప్పుడు {#go-wrong}

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

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

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

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

### బహుళ రహస్య పొరలను ఉపయోగించడం {#multi-layer}

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

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

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

ఈ కథనం [GitHub లో అందుబాటులో ఉన్న](https://github.com/qbzzt/251022-stealth-addresses.git) రహస్య-చిరునామా అప్లికేషన్‌ను వివరిస్తుంది. 

### సాధనాలు {#tools}

మనం ఉపయోగించగల [ఒక TypeScript రహస్య చిరునామా లైబ్రరీ](https://github.com/ScopeLift/stealth-address-sdk) ఉంది. అయితే, గూఢలిపి శాస్త్ర కార్యకలాపాలు CPU-ఇంటెన్సివ్‌గా ఉండవచ్చు. నేను వాటిని [Rust](https://rust-lang.org/) వంటి కంపైల్ చేయబడిన భాషలో అమలు చేయడానికి మరియు బ్రౌజర్‌లో కోడ్‌ను రన్ చేయడానికి [WASM](https://webassembly.org/) ని ఉపయోగించడానికి ఇష్టపడతాను.

మనం [Vite](https://vite.dev/) మరియు [React](https://react.dev/) లను ఉపయోగించబోతున్నాము. ఇవి పరిశ్రమ-ప్రామాణిక సాధనాలు; మీకు వాటి గురించి తెలియకపోతే, మీరు [ఈ ట్యుటోరియల్‌ని](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) ఉపయోగించవచ్చు. Vite ని ఉపయోగించడానికి, మనకు Node అవసరం.

### రహస్య చిరునామాలు ఎలా పనిచేస్తాయో చూడండి {#in-action}

1. అవసరమైన సాధనాలను ఇన్‌స్టాల్ చేయండి: [Rust](https://rust-lang.org/tools/install/) మరియు [Node](https://nodejs.org/en/download).

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

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

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

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

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

   ```sh
   cd ../..
   npm install
   npm run dev
   ```

5. [అప్లికేషన్‌కు](http://localhost:5173/) బ్రౌజ్ చేయండి. ఈ అప్లికేషన్ పేజీలో రెండు ఫ్రేమ్‌లు ఉన్నాయి: ఒకటి ఆలిస్ యూజర్ ఇంటర్‌ఫేస్ కోసం మరియు మరొకటి బిల్ కోసం. ఈ రెండు ఫ్రేమ్‌లు కమ్యూనికేట్ చేసుకోవు; అవి సౌలభ్యం కోసం మాత్రమే ఒకే పేజీలో ఉంటాయి.

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

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

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

9. ప్రైవేట్ కీ చిరునామాకు అనుగుణంగా ఉందో లేదో నిర్ధారించుకోవడానికి మీరు [ఆన్‌లైన్ కాలిక్యులేటర్‌ను](https://iancoleman.net/ethereum-private-key-to-address/) ఉపయోగించవచ్చు.

### ప్రోగ్రామ్ ఎలా పనిచేస్తుంది {#how-the-program-works}

#### WASM కాంపోనెంట్ {#wasm}

WASM లోకి కంపైల్ అయ్యే సోర్స్ కోడ్ [Rust](https://rust-lang.org/) లో వ్రాయబడింది. మీరు దానిని [`src/rust_wasm/src/lib.rs`](https://github.com/qbzzt/251022-stealth-addresses/blob/main/src/rust-wasm/src/lib.rs) లో చూడవచ్చు. ఈ కోడ్ ప్రధానంగా JavaScript కోడ్ మరియు [`eth-stealth-addresses` లైబ్రరీ](https://github.com/kassandraoftroy/eth-stealth-addresses) మధ్య ఇంటర్‌ఫేస్‌గా పనిచేస్తుంది.

**`Cargo.toml`**

Rust లోని [`Cargo.toml`](https://doc.rust-lang.org/cargo/reference/manifest.html) అనేది JavaScript లోని [`package.json`](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) కి సమానం. ఇది ప్యాకేజీ సమాచారం, డిపెండెన్సీ డిక్లరేషన్‌లు మొదలైనవాటిని కలిగి ఉంటుంది.

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

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

[`getrandom`](https://docs.rs/getrandom/latest/getrandom/) ప్యాకేజీ యాదృచ్ఛిక విలువలను రూపొందించాలి. అది కేవలం అల్గారిథమిక్ మార్గాల ద్వారా చేయబడదు; దానికి ఎంట్రోపీ మూలంగా భౌతిక ప్రక్రియకు యాక్సెస్ అవసరం. మనం రన్ చేస్తున్న బ్రౌజర్‌ను అడగడం ద్వారా ఆ ఎంట్రోపీని పొందుతామని ఈ నిర్వచనం నిర్దేశిస్తుంది.

```toml
console_error_panic_hook = "0.1.7"
```

WASM కోడ్ పానిక్ అయినప్పుడు మరియు కొనసాగలేనప్పుడు [ఈ లైబ్రరీ](https://docs.rs/console_error_panic_hook/latest/console_error_panic_hook/) మనకు మరింత అర్థవంతమైన ఎర్రర్ సందేశాలను ఇస్తుంది.

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

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

**`lib.rs`**

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

```rust
use wasm_bindgen::prelude::*;
```

Rust నుండి WASM ప్యాకేజీని సృష్టించడానికి నిర్వచనాలు. అవి [ఇక్కడ](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/index.html) డాక్యుమెంట్ చేయబడ్డాయి.

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

[`eth-stealth-addresses` లైబ్రరీ](https://github.com/kassandraoftroy/eth-stealth-addresses) నుండి మనకు అవసరమైన ఫంక్షన్‌లు.

```rust
use hex::{decode,encode};
```

Rust సాధారణంగా విలువల కోసం బైట్ [అరేలను](https://doc.rust-lang.org/std/primitive.array.html) (`[u8; <size>]`) ఉపయోగిస్తుంది. కానీ JavaScript లో, మనం సాధారణంగా హెక్సాడెసిమల్ స్ట్రింగ్‌లను ఉపయోగిస్తాము. [`hex` లైబ్రరీ](https://docs.rs/hex/latest/hex/) మన కోసం ఒక ప్రాతినిధ్యం నుండి మరొక దానికి అనువదిస్తుంది.

```rust
#[wasm_bindgen]
```

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

```rust
pub fn wasm_generate_stealth_meta_address() -> String {
```

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

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

[`generate_stealth_meta_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_meta_address.html) మూడు ఫీల్డ్‌లను తిరిగి ఇస్తుంది:

- మెటా-చిరునామా (*K<sub>pub</sub>* మరియు *V<sub>pub</sub>*)
- వీక్షణ ప్రైవేట్ కీ (*V<sub>priv</sub>*)
- ఖర్చు చేసే ప్రైవేట్ కీ (*K<sub>priv</sub>*)

[టపుల్ (tuple)](https://doc.rust-lang.org/std/primitive.tuple.html) సింటాక్స్ ఆ విలువలను మళ్లీ వేరు చేయడానికి మనల్ని అనుమతిస్తుంది.

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

JSON-ఎన్‌కోడ్ చేయబడిన స్ట్రింగ్‌ను రూపొందించడానికి [`format!`](https://doc.rust-lang.org/std/fmt/index.html) మ్యాక్రోను ఉపయోగించండి. అరేలను హెక్స్ స్ట్రింగ్‌లుగా మార్చడానికి [`hex::encode`](https://docs.rs/hex/latest/hex/fn.encode.html) ని ఉపయోగించండి.

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

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

`<const N: usize>` ఎక్స్‌ప్రెషన్‌ను [జెనరిక్ (generic)](https://doc.rust-lang.org/book/ch10-01-syntax.html) అని పిలుస్తారు. `N` అనేది తిరిగి ఇవ్వబడిన అరే పొడవును నియంత్రించే పారామితి. ఫంక్షన్ వాస్తవానికి `str_to_array::<n>` అని పిలువబడుతుంది, ఇక్కడ `n` అనేది అరే పొడవు.

రిటర్న్ విలువ `Option<[u8; N]>`, అంటే తిరిగి ఇవ్వబడిన అరే [ఆప్షనల్ (optional)](https://doc.rust-lang.org/std/option/) అని అర్థం. విఫలమయ్యే అవకాశం ఉన్న ఫంక్షన్‌ల కోసం Rust లో ఇది ఒక సాధారణ నమూనా.

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

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

[`hex::decode`](https://docs.rs/hex/latest/hex/fn.decode.html) ఫంక్షన్ `Result<Vec<u8>, FromHexError>` ని తిరిగి ఇస్తుంది. [`Result`](https://doc.rust-lang.org/std/result/) రకం విజయవంతమైన ఫలితాన్ని (`Ok(value)`) లేదా ఎర్రర్‌ను (`Err(error)`) కలిగి ఉంటుంది.

`.ok()` పద్ధతి `Result` ని `Option` గా మారుస్తుంది, దీని విలువ విజయవంతమైతే `Ok()` విలువ లేదా కాకపోతే `None` అవుతుంది. చివరగా, `Option` ఖాళీగా ఉంటే [ప్రశ్నార్థక ఆపరేటర్](https://doc.rust-lang.org/std/option/#the-question-mark-operator-) ప్రస్తుత ఫంక్షన్‌లను నిలిపివేసి `None` ని తిరిగి ఇస్తుంది. లేకపోతే, అది విలువను అన్‌రాప్ చేసి దానిని తిరిగి ఇస్తుంది (ఈ సందర్భంలో, `vec` కి విలువను కేటాయించడానికి).

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

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

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

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

Rust లో రెండు అరే రకాలు ఉన్నాయి. [అరేలు](https://doc.rust-lang.org/std/primitive.array.html) స్థిరమైన పరిమాణాన్ని కలిగి ఉంటాయి. [వెక్టర్లు](https://doc.rust-lang.org/std/vec/index.html) పెరగగలవు మరియు తగ్గగలవు. `hex::decode` ఒక వెక్టర్‌ను తిరిగి ఇస్తుంది, కానీ `eth_stealth_addresses` లైబ్రరీ అరేలను స్వీకరించాలనుకుంటుంది. [`.try_into()`](https://doc.rust-lang.org/std/convert/trait.TryInto.html#required-methods) ఒక విలువను మరొక రకంగా మారుస్తుంది, ఉదాహరణకు, వెక్టర్‌ను అరేగా.

```rust
    Some(array)
}
```

ఫంక్షన్ చివరలో విలువను తిరిగి ఇచ్చేటప్పుడు మీరు [`return`](https://doc.rust-lang.org/std/keyword.return.html) కీవర్డ్‌ను ఉపయోగించాల్సిన అవసరం Rust కు లేదు.

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

ఈ ఫంక్షన్ పబ్లిక్ మెటా-చిరునామాను స్వీకరిస్తుంది, ఇందులో *V<sub>pub</sub>* మరియు *K<sub>pub</sub>* రెండూ ఉంటాయి. ఇది రహస్య చిరునామాను, ప్రచురించాల్సిన పబ్లిక్ కీని (*R<sub>pub</sub>*), మరియు ప్రచురించబడిన చిరునామాలలో ఏవి ఆలిస్‌కు చెందినవి కావచ్చో గుర్తించడాన్ని వేగవంతం చేసే ఒక-బైట్ స్కాన్ విలువను తిరిగి ఇస్తుంది.

స్కాన్ విలువ అనేది భాగస్వామ్య రహస్యంలో (*S = GR<sub>priv</sub>V<sub>priv</sub>*) ఒక భాగం. ఈ విలువ ఆలిస్‌కు అందుబాటులో ఉంటుంది, మరియు *f(K<sub>pub</sub>+G\*hash(S))* ప్రచురించబడిన చిరునామాకు సమానంగా ఉందో లేదో తనిఖీ చేయడం కంటే దీనిని తనిఖీ చేయడం చాలా వేగంగా ఉంటుంది.

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

మనం లైబ్రరీ యొక్క [`generate_stealth_address`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.generate_stealth_address.html) ని ఉపయోగిస్తాము.

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

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

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

చిరునామా నుండి ఉపసంహరించుకోవడానికి ప్రైవేట్ కీని (*R<sub>priv</sub>*) లెక్కించడానికి ఈ ఫంక్షన్ లైబ్రరీ యొక్క [`compute_stealth_key`](https://docs.rs/eth-stealth-addresses/latest/eth_stealth_addresses/fn.compute_stealth_key.html) ని ఉపయోగిస్తుంది. ఈ గణనకు ఈ విలువలు అవసరం:

- చిరునామా (*Address=f(P<sub>pub</sub>)*)
- బిల్ రూపొందించిన పబ్లిక్ కీ (*R<sub>pub</sub>*)
- వీక్షణ ప్రైవేట్ కీ (*V<sub>priv</sub>*)
- ఖర్చు చేసే ప్రైవేట్ కీ (*K<sub>priv</sub>*)

```rust
#[wasm_bindgen(start)]
```

WASM కోడ్ ప్రారంభించబడినప్పుడు ఫంక్షన్ అమలు చేయబడుతుందని [`#[wasm_bindgen(start)]`](https://wasm-bindgen.github.io/wasm-bindgen/reference/attributes/on-rust-exports/start.html) నిర్దేశిస్తుంది.

```rust
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
```

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

#### యూజర్ ఇంటర్‌ఫేస్ {#ui}

యూజర్ ఇంటర్‌ఫేస్ [React](https://react.dev/) ని ఉపయోగించి వ్రాయబడింది మరియు [Vite](https://vite.dev/) ద్వారా అందించబడుతుంది. మీరు [ఈ ట్యుటోరియల్‌ని](/developers/tutorials/creating-a-wagmi-ui-for-your-contract/) ఉపయోగించి వాటి గురించి తెలుసుకోవచ్చు. మనం నేరుగా బ్లాక్‌చైన్ లేదా వాలెట్‌తో ఇంటరాక్ట్ అవ్వము కాబట్టి ఇక్కడ [Wagmi](https://wagmi.sh/) అవసరం లేదు.

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

**`vite.config.js`**

ఈ ఫైల్ [Vite కాన్ఫిగరేషన్‌ను](https://vite.dev/config/) కలిగి ఉంటుంది.

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

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

మనకు రెండు Vite ప్లగిన్‌లు అవసరం: [react](https://www.npmjs.com/package/@vitejs/plugin-react) మరియు [wasm](https://github.com/Menci/vite-plugin-wasm#readme).

**`App.jsx`**

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

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

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

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

    loadWasm()
    }, []
  )
```

[`useEffect` హుక్](https://react.dev/reference/react/useEffect) స్థితి (state) వేరియబుల్స్ మారినప్పుడు అమలు చేయబడే ఫంక్షన్‌ను పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇక్కడ, స్థితి వేరియబుల్స్ జాబితా ఖాళీగా ఉంది (`[]`), కాబట్టి పేజీ లోడ్ అయినప్పుడు ఈ ఫంక్షన్ ఒక్కసారి మాత్రమే అమలు చేయబడుతుంది.

ఎఫెక్ట్ ఫంక్షన్ వెంటనే తిరిగి రావాలి. WASM `init` వంటి అసమకాలిక (asynchronous) కోడ్‌ను ఉపయోగించడానికి (ఇది `.wasm` ఫైల్‌ను లోడ్ చేయాలి కాబట్టి సమయం పడుతుంది) మనం అంతర్గత [`async`](https://en.wikipedia.org/wiki/Async/await) ఫంక్షన్‌ను నిర్వచిస్తాము మరియు దానిని `await` లేకుండా రన్ చేస్తాము.

**`Bill.jsx`**

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

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

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

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

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

**`Alice.jsx`**

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

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

## ముగింపు {#conclusion}

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

[నా మరిన్ని పనుల కోసం ఇక్కడ చూడండి](https://cryptodocguy.pro/).