బ్లాక్‌చెయిన్ మానవ జీవితంలోని అనేక రంగాలను మెరుగుపరుస్తుందని వాగ్దానం చేసే వినూత్న సాంకేతికత. ఇది నిజమైన ప్రక్రియలు మరియు ఉత్పత్తులను డిజిటల్ స్పేస్‌లోకి బదిలీ చేస్తుంది, ఆర్థిక లావాదేవీల వేగం మరియు విశ్వసనీయతను నిర్ధారిస్తుంది, వాటి ధరను తగ్గిస్తుంది మరియు వికేంద్రీకృత నెట్‌వర్క్‌లలో స్మార్ట్ కాంట్రాక్టులను ఉపయోగించి ఆధునిక DAPP అప్లికేషన్‌లను రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది.
బ్లాక్‌చెయిన్ యొక్క అనేక ప్రయోజనాలు మరియు విభిన్న అప్లికేషన్‌లను బట్టి, ఈ ఆశాజనక సాంకేతికత ఇంకా ప్రతి పరిశ్రమలోకి ప్రవేశించకపోవడం ఆశ్చర్యంగా అనిపించవచ్చు. సమస్య ఏమిటంటే ఆధునిక వికేంద్రీకృత బ్లాక్‌చెయిన్‌లు స్కేలబిలిటీని కలిగి ఉండవు. Ethereum సెకనుకు దాదాపు 20 లావాదేవీలను ప్రాసెస్ చేస్తుంది, ఇది నేటి డైనమిక్ వ్యాపారాల అవసరాలను తీర్చడానికి సరిపోదు. అదే సమయంలో, బ్లాక్‌చెయిన్ టెక్నాలజీని ఉపయోగించే కంపెనీలు హ్యాకింగ్ మరియు నెట్‌వర్క్ వైఫల్యాల నుండి అధిక స్థాయి రక్షణ కారణంగా Ethereumని వదిలివేయడానికి వెనుకాడుతున్నాయి.
బ్లాక్‌చెయిన్‌లో వికేంద్రీకరణ, భద్రత మరియు స్కేలబిలిటీని నిర్ధారించడానికి, తద్వారా స్కేలబిలిటీ ట్రిలెమాను పరిష్కరించడం, అభివృద్ధి బృందం స్మార్ట్ కాంట్రాక్ట్ మరియు Node.js ఆధారంగా ప్రైవేట్ నెట్‌వర్క్‌తో కూడిన అనుబంధ గొలుసు ప్లాస్మా క్యాష్‌ను సృష్టించింది, ఇది క్రమానుగతంగా దాని స్థితిని రూట్ చైన్ (Ethereum)కి బదిలీ చేస్తుంది.
ప్లాస్మా నగదులో కీలక ప్రక్రియలు
1. వినియోగదారుడు స్మార్ట్ కాంట్రాక్ట్ ఫంక్షన్‌ను `డిపాజిట్` అని పిలుస్తాడు, అతను ప్లాస్మా క్యాష్ టోకెన్‌లో డిపాజిట్ చేయాలనుకుంటున్న ETH మొత్తాన్ని దానిలోకి పంపాడు. స్మార్ట్ కాంట్రాక్ట్ ఫంక్షన్ ఒక టోకెన్‌ను సృష్టిస్తుంది మరియు దాని గురించి ఈవెంట్‌ను రూపొందిస్తుంది.
2. స్మార్ట్ కాంట్రాక్ట్ ఈవెంట్‌లకు సబ్‌స్క్రయిబ్ చేయబడిన ప్లాస్మా క్యాష్ నోడ్‌లు డిపాజిట్‌ని క్రియేట్ చేయడం గురించి ఈవెంట్‌ను స్వీకరిస్తాయి మరియు పూల్‌కి టోకెన్‌ను క్రియేట్ చేయడం గురించి లావాదేవీని జోడిస్తాయి.
3. క్రమానుగతంగా, ప్రత్యేక ప్లాస్మా క్యాష్ నోడ్‌లు పూల్ (1 మిలియన్ వరకు) నుండి అన్ని లావాదేవీలను తీసుకుంటాయి మరియు వాటి నుండి ఒక బ్లాక్‌ను ఏర్పరుస్తాయి, మెర్కిల్ ట్రీని లెక్కించండి మరియు తదనుగుణంగా, హాష్. ధృవీకరణ కోసం ఈ బ్లాక్ ఇతర నోడ్‌లకు పంపబడుతుంది. నోడ్‌లు Merkle హాష్ చెల్లుబాటులో ఉందో లేదో మరియు లావాదేవీలు చెల్లుబాటులో ఉన్నాయో లేదో తనిఖీ చేస్తాయి (ఉదాహరణకు, టోకెన్ పంపినవారు దాని యజమాని కాదా). బ్లాక్‌ని ధృవీకరించిన తర్వాత, నోడ్ స్మార్ట్ కాంట్రాక్ట్ యొక్క `సబ్‌మిట్‌బ్లాక్` ఫంక్షన్‌ని పిలుస్తుంది, ఇది బ్లాక్ నంబర్‌ను మరియు మెర్కిల్ హాష్‌ను అంచు గొలుసులో సేవ్ చేస్తుంది. స్మార్ట్ కాంట్రాక్ట్ బ్లాక్ యొక్క విజయవంతమైన జోడింపును సూచించే ఈవెంట్‌ను రూపొందిస్తుంది. పూల్ నుండి లావాదేవీలు తీసివేయబడతాయి.
4. బ్లాక్ సమర్పణ ఈవెంట్‌ను స్వీకరించే నోడ్‌లు బ్లాక్‌కు జోడించబడిన లావాదేవీలను వర్తింపజేయడం ప్రారంభిస్తాయి.
5. ఏదో ఒక సమయంలో, టోకెన్ యజమాని (లేదా నాన్-ఓనర్) దానిని ప్లాస్మా క్యాష్ నుండి ఉపసంహరించుకోవాలనుకుంటున్నారు. దీన్ని చేయడానికి, అతను టోకెన్‌లోని చివరి 2 లావాదేవీల గురించి సమాచారాన్ని పంపి, `స్టార్ట్‌ఎగ్జిట్` ఫంక్షన్‌కి కాల్ చేస్తాడు, ఇది టోకెన్ యజమాని అని నిర్ధారిస్తుంది. స్మార్ట్ కాంట్రాక్ట్, Merkle హాష్‌ని ఉపయోగించి, బ్లాక్‌లలో లావాదేవీల ఉనికిని తనిఖీ చేస్తుంది మరియు ఉపసంహరణ కోసం టోకెన్‌ను పంపుతుంది, ఇది రెండు వారాల్లో జరుగుతుంది.
6. టోకెన్ ఉపసంహరణ ఆపరేషన్ ఉల్లంఘనలతో సంభవించినట్లయితే (ఉపసంహరణ ప్రక్రియ ప్రారంభమైన తర్వాత టోకెన్ ఖర్చు చేయబడింది లేదా ఉపసంహరణకు ముందు టోకెన్ మరొకరిది), టోకెన్ యజమాని రెండు వారాల్లో ఉపసంహరణను తిరస్కరించవచ్చు.
గోప్యత రెండు విధాలుగా సాధించబడుతుంది
1. చైల్డ్ చైన్‌లో ఉత్పత్తి చేయబడిన మరియు ఫార్వార్డ్ చేయబడిన లావాదేవీల గురించి రూట్ చెయిన్‌కు ఏమీ తెలియదు. ప్లాస్మా క్యాష్ నుండి ETHను ఎవరు డిపాజిట్ చేసారు మరియు ఉపసంహరించుకున్నారు అనే సమాచారం పబ్లిక్‌గా ఉంటుంది.
2. చైల్డ్ చైన్ zk-SNARKలను ఉపయోగించి అనామక లావాదేవీలను అనుమతిస్తుంది.
టెక్నాలజీ స్టాక్
- nodeJS
- Redis
- ఎథెరియం
- నేల
పరీక్ష
ప్లాస్మా క్యాష్‌ని అభివృద్ధి చేస్తున్నప్పుడు, మేము సిస్టమ్ వేగాన్ని పరీక్షించాము మరియు ఈ క్రింది ఫలితాలను పొందాము:
- సెకనుకు 35 లావాదేవీలు పూల్‌కి జోడించబడతాయి;
- ఒక బ్లాక్‌లో 1 లావాదేవీలను నిల్వ చేయవచ్చు.
కింది 3 సర్వర్‌లలో పరీక్షలు జరిగాయి:
1. ఇంటెల్ కోర్ i7-6700 క్వాడ్-కోర్ స్కైలేక్ సహా. NVMe SSD - 512 GB, 64 GB DDR4 ర్యామ్
3 చెల్లుబాటు అయ్యే ప్లాస్మా క్యాష్ నోడ్‌లు పెంచబడ్డాయి.
2. AMD రైజెన్ 7 1700X ఆక్టా-కోర్ “సమ్మిట్ రిడ్జ్” (జెన్), SATA SSD – 500 GB, 64 GB DDR4 RAM
Ropsten testnet ETH నోడ్ పెంచబడింది.
3 చెల్లుబాటు అయ్యే ప్లాస్మా క్యాష్ నోడ్‌లు పెంచబడ్డాయి.
3. ఇంటెల్ కోర్ i9-9900K ఆక్టా-కోర్ సహా. NVMe SSD - 1 TB, 64 GB DDR4 ర్యామ్
1 ప్లాస్మా నగదు సమర్పణ నోడ్ పెంచబడింది.
3 చెల్లుబాటు అయ్యే ప్లాస్మా క్యాష్ నోడ్‌లు పెంచబడ్డాయి.
ప్లాస్మా క్యాష్ నెట్‌వర్క్‌కు లావాదేవీలను జోడించడానికి ఒక పరీక్ష ప్రారంభించబడింది.
మొత్తం: ప్రైవేట్ నెట్‌వర్క్‌లో 10 ప్లాస్మా క్యాష్ నోడ్‌లు.
పరీక్ష 1
ఒక్కో బ్లాక్‌కు 1 మిలియన్ లావాదేవీల పరిమితి ఉంది. అందువల్ల, 1 మిలియన్ లావాదేవీలు 2 బ్లాక్‌లుగా ఉంటాయి (సిస్టమ్ లావాదేవీలలో భాగం వహించి, వాటిని పంపుతున్నప్పుడు సమర్పించడాన్ని నిర్వహిస్తుంది కాబట్టి).
ప్రారంభ స్థితి: చివరి బ్లాక్ #7; 1 మిలియన్ లావాదేవీలు మరియు టోకెన్లు డేటాబేస్లో నిల్వ చేయబడతాయి.
00:00 — లావాదేవీ ఉత్పత్తి స్క్రిప్ట్ ప్రారంభం
01:37 - 1 మిలియన్ లావాదేవీలు సృష్టించబడ్డాయి మరియు నోడ్‌కి పంపడం ప్రారంభమైంది
01:46 — సబ్మిట్ నోడ్ పూల్ నుండి 240k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌ల బ్లాక్ #8. 320 సెకన్లలో 10k లావాదేవీలు పూల్‌కి జోడించబడటం కూడా మనం చూస్తాము
01:58 — బ్లాక్ #8 సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం పంపబడింది
02:03 — బ్లాక్ #8 ధృవీకరించబడింది మరియు స్మార్ట్ కాంట్రాక్ట్ యొక్క `సబ్‌మిట్‌బ్లాక్` ఫంక్షన్ మెర్కిల్ హాష్ మరియు బ్లాక్ నంబర్‌తో పిలువబడుతుంది.
02:10 — డెమో స్క్రిప్ట్ పని పూర్తి చేసింది, ఇది 1 సెకన్లలో 32 మిలియన్ లావాదేవీలను పంపింది
02:33 - రూట్ చైన్‌కు బ్లాక్ #8 జోడించబడిందని నోడ్‌లు సమాచారాన్ని అందుకోవడం ప్రారంభించాయి మరియు 240k లావాదేవీలు చేయడం ప్రారంభించాయి.
02:40 - ఇప్పటికే బ్లాక్ #240లో ఉన్న పూల్ నుండి 8k లావాదేవీలు తీసివేయబడ్డాయి
02:56 — సబ్మిట్ నోడ్ పూల్ నుండి మిగిలిన 760k లావాదేవీలను తీసుకుంది మరియు మెర్కిల్ హాష్ మరియు సంతకం బ్లాక్ #9ని లెక్కించడం ప్రారంభించింది.
03:20 - అన్ని నోడ్‌లు 1 మిలియన్ 240k లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
03:35 — బ్లాక్ #9 సంతకం చేయబడింది మరియు ఇతర నోడ్‌లకు ధ్రువీకరణ కోసం పంపబడింది
03:41 - నెట్‌వర్క్ లోపం సంభవించింది
04:40 — బ్లాక్ #9 ధ్రువీకరణ సమయం ముగిసింది
04:54 — సబ్మిట్ నోడ్ పూల్ నుండి మిగిలిన 760k లావాదేవీలను తీసుకుంది మరియు మెర్కిల్ హాష్ మరియు సంతకం బ్లాక్ #9ని లెక్కించడం ప్రారంభించింది.
05:32 — బ్లాక్ #9 సంతకం చేయబడింది మరియు ఇతర నోడ్‌లకు ధ్రువీకరణ కోసం పంపబడింది
05:53 — బ్లాక్ #9 ధృవీకరించబడింది మరియు రూట్ చైన్‌కి పంపబడుతుంది
06:17 - రూట్ చైన్‌కు బ్లాక్ #9 జోడించబడి, 760k లావాదేవీలను నిర్వహించడం ప్రారంభించిన సమాచారాన్ని నోడ్‌లు స్వీకరించడం ప్రారంభించాయి.
06:47 — బ్లాక్ #9లో ఉన్న లావాదేవీలను పూల్ క్లియర్ చేసింది
09:06 - అన్ని నోడ్‌లు 2 మిలియన్ లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
పరీక్ష 2
ఒక్కో బ్లాక్‌కు 350k పరిమితి ఉంది. ఫలితంగా, మనకు 3 బ్లాక్‌లు ఉన్నాయి.
ప్రారంభ స్థితి: చివరి బ్లాక్ #9; 2 మిలియన్ లావాదేవీలు మరియు టోకెన్లు డేటాబేస్లో నిల్వ చేయబడతాయి
00:00 — లావాదేవీ జనరేషన్ స్క్రిప్ట్ ఇప్పటికే ప్రారంభించబడింది
00:44 - 1 మిలియన్ లావాదేవీలు సృష్టించబడ్డాయి మరియు నోడ్‌కి పంపడం ప్రారంభమైంది
00:56 — సబ్మిట్ నోడ్ పూల్ నుండి 320k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌ల బ్లాక్ #10. 320 సెకన్లలో 10k లావాదేవీలు పూల్‌కి జోడించబడటం కూడా మనం చూస్తాము
01:12 — బ్లాక్ #10 సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
01:18 — డెమో స్క్రిప్ట్ పని పూర్తి చేసింది, ఇది 1 సెకన్లలో 34 మిలియన్ లావాదేవీలను పంపింది
01:20 — బ్లాక్ #10 ధృవీకరించబడింది మరియు రూట్ చైన్‌కి పంపబడుతుంది
01:51 - బ్లాక్ #10 జోడించబడింది మరియు 320k లావాదేవీలను వర్తింపజేయడం ప్రారంభించిన రూట్ చైన్ నుండి అన్ని నోడ్‌లకు సమాచారం అందింది.
02:01 - బ్లాక్ #320కి జోడించబడిన 10k లావాదేవీల కోసం పూల్ క్లియర్ చేయబడింది
02:15 — సబ్మిట్ నోడ్ పూల్ నుండి 350k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #11
02:34 — బ్లాక్ #11 సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
02:51 — బ్లాక్ #11 ధృవీకరించబడింది మరియు రూట్ చైన్‌కి పంపబడుతుంది
02:55 — చివరి నోడ్ బ్లాక్ #10 నుండి లావాదేవీలను పూర్తి చేసింది
10:59 — బ్లాక్ #9 సమర్పణతో లావాదేవీ రూట్ చైన్‌లో చాలా సమయం పట్టింది, కానీ అది పూర్తయింది మరియు అన్ని నోడ్‌లు దాని గురించి సమాచారాన్ని పొందాయి మరియు 350k లావాదేవీలు చేయడం ప్రారంభించాయి.
11:05 - బ్లాక్ #320కి జోడించబడిన 11k లావాదేవీల కోసం పూల్ క్లియర్ చేయబడింది
12:10 - అన్ని నోడ్‌లు 1 మిలియన్ 670k లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
12:17 — సబ్మిట్ నోడ్ పూల్ నుండి 330k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #12
12:32 — బ్లాక్ #12 సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
12:39 — బ్లాక్ #12 ధృవీకరించబడింది మరియు రూట్ చైన్‌కి పంపబడుతుంది
13:44 - బ్లాక్ #12 జోడించబడింది మరియు 330k లావాదేవీలను వర్తింపజేయడం ప్రారంభించిన రూట్ చైన్ నుండి అన్ని నోడ్‌లకు సమాచారం అందింది.
14:50 - అన్ని నోడ్‌లు 2 మిలియన్ లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
పరీక్ష 3
మొదటి మరియు రెండవ సర్వర్‌లలో, ఒక ధ్రువీకరణ నోడ్‌ను సమర్పించే నోడ్‌తో భర్తీ చేసింది.
ప్రారంభ స్థితి: చివరి బ్లాక్ #84; 0 లావాదేవీలు మరియు టోకెన్లు డేటాబేస్లో సేవ్ చేయబడ్డాయి
00:00 — 3 స్క్రిప్ట్‌లు ప్రారంభించబడ్డాయి, ఇవి ఒక్కొక్కటి 1 మిలియన్ లావాదేవీలను ఉత్పత్తి చేస్తాయి మరియు పంపుతాయి
01:38 — 1 మిలియన్ లావాదేవీలు సృష్టించబడ్డాయి మరియు సబ్మిట్ నోడ్ #3కి పంపడం ప్రారంభమైంది
01:50 — సబ్మిట్ నోడ్ #3 పూల్ నుండి 330k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #85 (f21). 350 సెకన్లలో 10k లావాదేవీలు పూల్‌కి జోడించబడటం కూడా మనం చూస్తాము
01:53 — 1 మిలియన్ లావాదేవీలు సృష్టించబడ్డాయి మరియు సబ్మిట్ నోడ్ #1కి పంపడం ప్రారంభమైంది
01:50 — సబ్మిట్ నోడ్ #3 పూల్ నుండి 330k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #85 (f21). 350 సెకన్లలో 10k లావాదేవీలు పూల్‌కి జోడించబడటం కూడా మనం చూస్తాము
02:01 — సబ్మిట్ నోడ్ #1 పూల్ నుండి 250k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌ల బ్లాక్ #85 (65e)
02:06 — బ్లాక్ #85 (f21) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
02:08 — 3 సెకన్లలో 1 మిలియన్ లావాదేవీలను పంపిన సర్వర్ #30 యొక్క డెమో స్క్రిప్ట్, పనిని పూర్తి చేసింది
02:14 — బ్లాక్ #85 (f21) ధృవీకరించబడింది మరియు రూట్ చైన్‌కు పంపబడుతుంది
02:19 — బ్లాక్ #85 (65e) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
02:22 — 1 మిలియన్ లావాదేవీలు సృష్టించబడ్డాయి మరియు సబ్మిట్ నోడ్ #2కి పంపడం ప్రారంభమైంది
02:27 — బ్లాక్ #85 (65e) ధృవీకరించబడింది మరియు రూట్ చైన్‌కి పంపబడింది
02:29 — సబ్మిట్ నోడ్ #2 పూల్ నుండి 111855 లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #85 (256).
02:36 — బ్లాక్ #85 (256) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
02:36 — 1 సెకన్లలో 1 మిలియన్ లావాదేవీలను పంపిన సర్వర్ #42.5 యొక్క డెమో స్క్రిప్ట్, పనిని పూర్తి చేసింది
02:38 — బ్లాక్ #85 (256) ధృవీకరించబడింది మరియు రూట్ చైన్‌కు పంపబడుతుంది
03:08 — సర్వర్ #2 స్క్రిప్ట్ పని చేయడం పూర్తయింది, ఇది 1 సెకన్లలో 47 మిలియన్ లావాదేవీలను పంపింది
03:38 - #85 (f21), #86(65e), #87(256) బ్లాక్‌లు జోడించబడ్డాయి మరియు 330k, 250k, 111855 లావాదేవీలను వర్తింపజేయడం ప్రారంభించిన రూట్ చైన్ నుండి అన్ని నోడ్‌లు సమాచారాన్ని పొందాయి.
03:49 - #330 (f250), #111855(85e), #21(86) బ్లాక్‌లకు జోడించబడిన 65k, 87k, 256 లావాదేవీల వద్ద పూల్ క్లియర్ చేయబడింది
03:59 — సబ్మిట్ నోడ్ #1 పూల్ నుండి 888145 లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు #88 (214), సబ్మిట్ నోడ్ #2 పూల్ నుండి 750k లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #88 (50a), సబ్మిట్ నోడ్ #3 నుండి 670k లావాదేవీలు జరిగాయి పూల్ మరియు ఫారమ్‌లు బ్లాక్ #88 (d3b)
04:44 — బ్లాక్ #88 (d3b) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
04:58 — బ్లాక్ #88 (214) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
05:11 — బ్లాక్ #88 (50a) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
05:11 — బ్లాక్ #85 (d3b) ధృవీకరించబడింది మరియు రూట్ చైన్‌కు పంపబడుతుంది
05:36 — బ్లాక్ #85 (214) ధృవీకరించబడింది మరియు రూట్ చైన్‌కు పంపబడుతుంది
05:43 - #88 (d3b), #89(214) బ్లాక్‌లు జోడించబడ్డాయి మరియు 670k, 750k లావాదేవీలను వర్తింపజేయడం ప్రారంభించిన రూట్ చెయిన్ నుండి అన్ని నోడ్‌లకు సమాచారం అందింది
06:50 — కమ్యూనికేషన్ వైఫల్యం కారణంగా, బ్లాక్ #85 (50a) ధృవీకరించబడలేదు
06:55 — సబ్మిట్ నోడ్ #2 పూల్ నుండి 888145 లావాదేవీలను తీసుకుంది మరియు ఫారమ్‌లు బ్లాక్ #90 (50a)
08:14 — బ్లాక్ #90 (50a) సంతకం చేయబడింది మరియు ధ్రువీకరణ కోసం ఇతర నోడ్‌లకు పంపబడింది
09:04 — బ్లాక్ #90 (50a) ధృవీకరించబడింది మరియు రూట్ చైన్‌కి పంపబడుతుంది
11:23 - బ్లాక్ #90 (50a) జోడించబడిన రూట్ చైన్ నుండి అన్ని నోడ్‌లకు సమాచారం అందింది మరియు 888145 లావాదేవీలను వర్తింపజేయడం ప్రారంభించింది. అదే సమయంలో, సర్వర్ #3 ఇప్పటికే బ్లాక్‌లు #88 (d3b), #89(214) నుండి లావాదేవీలను వర్తింపజేసింది.
12:11 - అన్ని కొలనులు ఖాళీగా ఉన్నాయి
13:41 — సర్వర్ #3 యొక్క అన్ని నోడ్‌లు 3 మిలియన్ లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
14:35 — సర్వర్ #1 యొక్క అన్ని నోడ్‌లు 3 మిలియన్ లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
19:24 — సర్వర్ #2 యొక్క అన్ని నోడ్‌లు 3 మిలియన్ లావాదేవీలు మరియు టోకెన్‌లను కలిగి ఉంటాయి
అడ్డంకులు
ప్లాస్మా క్యాష్ అభివృద్ధి సమయంలో, మేము ఈ క్రింది సమస్యలను ఎదుర్కొన్నాము, వాటిని మేము క్రమంగా పరిష్కరించాము మరియు పరిష్కరిస్తున్నాము:
1. వివిధ సిస్టమ్ ఫంక్షన్ల పరస్పర చర్యలో వైరుధ్యం. ఉదాహరణకు, పూల్‌కు లావాదేవీలను జోడించే ఫంక్షన్ బ్లాక్‌లను సమర్పించే మరియు ధృవీకరించే పనిని నిరోధించింది మరియు దీనికి విరుద్ధంగా, ఇది వేగం తగ్గడానికి దారితీసింది.
2. డేటా బదిలీ ఖర్చులను తగ్గించేటప్పుడు భారీ సంఖ్యలో లావాదేవీలను ఎలా పంపాలో వెంటనే స్పష్టంగా తెలియలేదు.
3. అధిక ఫలితాలను సాధించడానికి డేటాను ఎలా మరియు ఎక్కడ నిల్వ చేయాలో స్పష్టంగా తెలియలేదు.
4. నోడ్‌ల మధ్య నెట్‌వర్క్‌ను ఎలా నిర్వహించాలో స్పష్టంగా తెలియలేదు, ఎందుకంటే 1 మిలియన్ లావాదేవీలతో బ్లాక్ పరిమాణం 100 MB వరకు ఉంటుంది.
5. సింగిల్-థ్రెడ్ మోడ్‌లో పని చేయడం వలన దీర్ఘ గణనలు జరిగినప్పుడు నోడ్‌ల మధ్య కనెక్షన్ విచ్ఛిన్నమవుతుంది (ఉదాహరణకు, మెర్కిల్ ట్రీని నిర్మించడం మరియు దాని హాష్‌ను లెక్కించడం).
వీటన్నింటిని మేము ఎలా ఎదుర్కొన్నాము?
ప్లాస్మా క్యాష్ నోడ్ యొక్క మొదటి సంస్కరణ ఒక రకమైన కలయిక, ఇది ఒకే సమయంలో ప్రతిదీ చేయగలదు: లావాదేవీలను అంగీకరించడం, బ్లాక్‌లను సమర్పించడం మరియు ధృవీకరించడం మరియు డేటాను యాక్సెస్ చేయడానికి APIని అందించడం. NodeJS స్థానికంగా సింగిల్-థ్రెడ్ అయినందున, భారీ మెర్కిల్ ట్రీ లెక్కింపు ఫంక్షన్ యాడ్ లావాదేవీ ఫంక్షన్‌ను బ్లాక్ చేసింది. ఈ సమస్యను పరిష్కరించడానికి మేము రెండు ఎంపికలను చూశాము:
1. అనేక NodeJS ప్రక్రియలను ప్రారంభించండి, వీటిలో ప్రతి ఒక్కటి నిర్దిష్ట విధులను నిర్వహిస్తుంది.
2. వర్కర్_థ్రెడ్‌లను ఉపయోగించండి మరియు కోడ్‌లోని కొంత భాగాన్ని థ్రెడ్‌లలోకి తరలించండి.
ఫలితంగా, మేము ఒకే సమయంలో రెండు ఎంపికలను ఉపయోగించాము: మేము తార్కికంగా ఒక నోడ్‌ను 3 భాగాలుగా విభజించాము, అవి విడిగా పని చేయగలవు, కానీ అదే సమయంలో సమకాలీకరించబడతాయి
1. సమర్పణ నోడ్, ఇది పూల్‌లోకి లావాదేవీలను అంగీకరిస్తుంది మరియు బ్లాక్‌లను సృష్టిస్తుంది.
2. నోడ్‌ల చెల్లుబాటును తనిఖీ చేసే ధ్రువీకరణ నోడ్.
3. API నోడ్ - డేటాను యాక్సెస్ చేయడానికి APIని అందిస్తుంది.
ఈ సందర్భంలో, మీరు cliని ఉపయోగించి unix సాకెట్ ద్వారా ప్రతి నోడ్‌కి కనెక్ట్ చేయవచ్చు.
మేము మెర్కిల్ ట్రీని లెక్కించడం వంటి భారీ కార్యకలాపాలను ప్రత్యేక థ్రెడ్‌లోకి మార్చాము.
ఈ విధంగా, మేము అన్ని ప్లాస్మా క్యాష్ ఫంక్షన్ల యొక్క సాధారణ ఆపరేషన్‌ను ఏకకాలంలో మరియు వైఫల్యాలు లేకుండా సాధించాము.
సిస్టమ్ క్రియాత్మకమైన తర్వాత, మేము వేగాన్ని పరీక్షించడం ప్రారంభించాము మరియు దురదృష్టవశాత్తూ, సంతృప్తికరమైన ఫలితాలను పొందలేదు: సెకనుకు 5 లావాదేవీలు మరియు ప్రతి బ్లాక్‌కు 000 లావాదేవీలు. ఏది తప్పుగా అమలు చేయబడిందో నేను గుర్తించవలసి వచ్చింది.
ప్రారంభించడానికి, మేము సిస్టమ్ యొక్క గరిష్ట సామర్థ్యాన్ని తెలుసుకోవడానికి ప్లాస్మా క్యాష్‌తో కమ్యూనికేషన్ యొక్క మెకానిజమ్‌ను పరీక్షించడం ప్రారంభించాము. ప్లాస్మా క్యాష్ నోడ్ unix సాకెట్ ఇంటర్‌ఫేస్‌ను అందిస్తుందని మేము ఇంతకు ముందు వ్రాసాము. మొదట్లో ఇది టెక్స్ట్ ఆధారితంగా ఉండేది. json వస్తువులు `JSON.parse()` మరియు `JSON.stringify()` ఉపయోగించి పంపబడ్డాయి.
```json
{
"action": "sendTransaction",
"payload":{
"prevHash": "0x8a88cc4217745fd0b4eb161f6923235da10593be66b841d47da86b9cd95d93e0",
"prevBlock": 41,
"tokenId": "57570139642005649136210751546585740989890521125187435281313126554130572876445",
"newOwner": "0x200eabe5b26e547446ae5821622892291632d4f4",
"type": "pay",
"data": "",
"signature": "0xd1107d0c6df15e01e168e631a386363c72206cb75b233f8f3cf883134854967e1cd9b3306cc5c0ce58f0a7397ae9b2487501b56695fe3a3c90ec0f61c7ea4a721c"
}
}
```
మేము అటువంటి వస్తువుల బదిలీ వేగాన్ని కొలిచాము మరియు సెకనుకు ~ 130k కనుగొన్నాము. మేము jsonతో పని చేయడానికి ప్రామాణిక ఫంక్షన్‌లను భర్తీ చేయడానికి ప్రయత్నించాము, కానీ పనితీరు మెరుగుపడలేదు. ఈ ఆపరేషన్ల కోసం V8 ఇంజిన్ బాగా ఆప్టిమైజ్ చేయబడాలి.
మేము తరగతుల ద్వారా లావాదేవీలు, టోకెన్లు మరియు బ్లాక్‌లతో పని చేసాము. అటువంటి తరగతులను సృష్టించేటప్పుడు, పనితీరు 2 సార్లు పడిపోయింది, ఇది OOP మాకు సరిపోదని సూచిస్తుంది. నేను ప్రతిదీ పూర్తిగా ఫంక్షనల్ విధానానికి తిరిగి వ్రాయవలసి వచ్చింది.
డేటాబేస్లో రికార్డింగ్
ప్రారంభంలో, Redis డేటా నిల్వ కోసం మా అవసరాలను సంతృప్తిపరిచే అత్యంత ఉత్పాదక పరిష్కారాలలో ఒకటిగా ఎంపిక చేయబడింది: కీ-విలువ నిల్వ, హాష్ పట్టికలు, సెట్‌లతో పని చేయడం. మేము redis-benchmarkని ప్రారంభించాము మరియు 80 పైప్‌లైనింగ్ మోడ్‌లో సెకనుకు ~1k కార్యకలాపాలను పొందాము.
అధిక పనితీరు కోసం, మేము Redisని మరింత చక్కగా ట్యూన్ చేసాము:
- యునిక్స్ సాకెట్ కనెక్షన్ ఏర్పాటు చేయబడింది.
- మేము స్టేట్‌ను డిస్క్‌లో సేవ్ చేయడాన్ని నిలిపివేసాము (విశ్వసనీయత కోసం, మీరు ఒక ప్రతిరూపాన్ని సెటప్ చేయవచ్చు మరియు ప్రత్యేక Redisలో డిస్క్‌లో సేవ్ చేయవచ్చు).
Redisలో, పూల్ అనేది హాష్ టేబుల్, ఎందుకంటే మనం ఒక ప్రశ్నలో అన్ని లావాదేవీలను తిరిగి పొందగలగాలి మరియు లావాదేవీలను ఒక్కొక్కటిగా తొలగించగలగాలి. మేము సాధారణ జాబితాను ఉపయోగించడానికి ప్రయత్నించాము, కానీ మొత్తం జాబితాను అన్‌లోడ్ చేస్తున్నప్పుడు అది నెమ్మదిగా ఉంటుంది.
ప్రామాణిక NodeJSని ఉపయోగిస్తున్నప్పుడు, Redis లైబ్రరీలు సెకనుకు 18k లావాదేవీల పనితీరును సాధించాయి. వేగం 9 సార్లు పడిపోయింది.
బెంచ్‌మార్క్ మాకు అవకాశాలను స్పష్టంగా 5 రెట్లు ఎక్కువగా చూపించినందున, మేము ఆప్టిమైజ్ చేయడం ప్రారంభించాము. మేము లైబ్రరీని ioredisకి మార్చాము మరియు సెకనుకు 25k పనితీరును పొందాము. మేము `hset` ఆదేశాన్ని ఉపయోగించి లావాదేవీలను ఒక్కొక్కటిగా జోడించాము. కాబట్టి మేము Redisలో చాలా ప్రశ్నలను రూపొందిస్తున్నాము. లావాదేవీలను బ్యాచ్‌లుగా చేర్చి, వాటిని ఒక కమాండ్ `hmset`తో పంపాలనే ఆలోచన వచ్చింది. ఫలితం సెకనుకు 32వే.
మేము క్రింద వివరించే అనేక కారణాల వల్ల, మేము `బఫర్`ని ఉపయోగించి డేటాతో పని చేస్తాము మరియు మీరు వ్రాసే ముందు దానిని టెక్స్ట్ (`buffer.toString('hex')`)కి మార్చినట్లయితే, మీరు అదనపు పొందవచ్చు. పనితీరు. ఆ విధంగా, వేగం సెకనుకు 35k కి పెరిగింది. ప్రస్తుతానికి, మేము తదుపరి ఆప్టిమైజేషన్‌ని నిలిపివేయాలని నిర్ణయించుకున్నాము.
మేము బైనరీ ప్రోటోకాల్‌కి మారవలసి వచ్చింది ఎందుకంటే:
1. సిస్టమ్ తరచుగా హ్యాష్‌లు, సంతకాలు మొదలైనవాటిని గణిస్తుంది మరియు దీని కోసం `బఫర్‌లో డేటా అవసరం.
2. సేవల మధ్య పంపినప్పుడు, బైనరీ డేటా టెక్స్ట్ కంటే తక్కువ బరువు ఉంటుంది. ఉదాహరణకు, 1 మిలియన్ లావాదేవీలతో బ్లాక్‌ను పంపేటప్పుడు, టెక్స్ట్‌లోని డేటా 300 మెగాబైట్‌ల కంటే ఎక్కువ పడుతుంది.
3. డేటాను నిరంతరం మార్చడం పనితీరును ప్రభావితం చేస్తుంది.
అందువల్ల, అద్భుతమైన `బైనరీ-డేటా` లైబ్రరీ ఆధారంగా అభివృద్ధి చేసిన డేటాను నిల్వ చేయడానికి మరియు ప్రసారం చేయడానికి మేము మా స్వంత బైనరీ ప్రోటోకాల్‌ను ప్రాతిపదికగా తీసుకున్నాము.
ఫలితంగా, మేము ఈ క్రింది డేటా నిర్మాణాలను పొందాము:
- లావాదేవీ
```json
{
prevHash: BD.types.buffer(20),
prevBlock: BD.types.uint24le,
tokenId: BD.types.string(null),
type: BD.types.uint8,
newOwner: BD.types.buffer(20),
dataLength: BD.types.uint24le,
data: BD.types.buffer(({current}) => current.dataLength),
signature: BD.types.buffer(65),
hash: BD.types.buffer(32),
blockNumber: BD.types.uint24le,
timestamp: BD.types.uint48le,
}
```
- టోకెన్
```json
{
id: BD.types.string(null),
owner: BD.types.buffer(20),
block: BD.types.uint24le,
amount: BD.types.string(null),
}
```
- నిరోధించు
```json
{
number: BD.types.uint24le,
merkleRootHash: BD.types.buffer(32),
signature: BD.types.buffer(65),
countTx: BD.types.uint24le,
transactions: BD.types.array(Transaction.Protocol, ({current}) => current.countTx),
timestamp: BD.types.uint48le,
}
```
సాధారణ ఆదేశాలతో `BD.encode(block, Protocol).slice();` మరియు `BD.decode(బఫర్, ప్రోటోకాల్)` మేము Redisలో సేవ్ చేయడానికి లేదా మరొక నోడ్‌కి ఫార్వార్డ్ చేయడానికి మరియు తిరిగి పొందడానికి డేటాను `బఫర్`గా మారుస్తాము డేటా తిరిగి.
సేవల మధ్య డేటాను బదిలీ చేయడానికి మా వద్ద 2 బైనరీ ప్రోటోకాల్‌లు కూడా ఉన్నాయి:
— unix సాకెట్ ద్వారా ప్లాస్మా నోడ్‌తో పరస్పర చర్య కోసం ప్రోటోకాల్
```json
{
type: BD.types.uint8,
messageId: BD.types.uint24le,
error: BD.types.uint8,
length: BD.types.uint24le,
payload: BD.types.buffer(({node}) => node.length)
}
```
పేరు:
- `రకం` — నిర్వహించాల్సిన చర్య, ఉదాహరణకు, 1 — sendTransaction, 2 — getTransaction;
- `పేలోడ్` - తగిన ఫంక్షన్‌కు పాస్ చేయాల్సిన డేటా;
- `messageId` - సందేశం ఐడి తద్వారా ప్రతిస్పందనను గుర్తించవచ్చు.
- నోడ్స్ మధ్య పరస్పర చర్య కోసం ప్రోటోకాల్
```json
{
code: BD.types.uint8,
versionProtocol: BD.types.uint24le,
seq: BD.types.uint8,
countChunk: BD.types.uint24le,
chunkNumber: BD.types.uint24le,
length: BD.types.uint24le,
payload: BD.types.buffer(({node}) => node.length)
}
```
పేరు:
- `కోడ్` — సందేశ కోడ్, ఉదాహరణకు 6 — PREPARE_NEW_BLOCK, 7 — BLOCK_VALID, 8 — BLOCK_COMMIT;
- `వెర్షన్ ప్రోటోకాల్` — ప్రోటోకాల్ వెర్షన్, వివిధ వెర్షన్లతో నోడ్‌లను నెట్‌వర్క్‌లో పెంచవచ్చు మరియు అవి విభిన్నంగా పని చేయగలవు;
- `సీక్` - సందేశ ఐడెంటిఫైయర్;
- `కౌంట్‌చంక్` и `చంక్ నంబర్` పెద్ద సందేశాలను విభజించడానికి అవసరం;
- `పొడవు` и `పేలోడ్` పొడవు మరియు డేటా కూడా.
మేము డేటాను ముందే టైప్ చేసినందున, తుది సిస్టమ్ Ethereum యొక్క `rlp` లైబ్రరీ కంటే చాలా వేగంగా ఉంటుంది. దురదృష్టవశాత్తు, మేము ఇంకా దానిని తిరస్కరించలేకపోయాము, ఎందుకంటే భవిష్యత్తులో మేము చేయాలనుకుంటున్న స్మార్ట్ ఒప్పందాన్ని ఖరారు చేయడం అవసరం.
మేము వేగం చేరుకోవడానికి నిర్వహించేది ఉంటే 35 000 సెకనుకు లావాదేవీలు, మేము వాటిని సరైన సమయంలో కూడా ప్రాసెస్ చేయాలి. సుమారుగా బ్లాక్ ఏర్పడే సమయం 30 సెకన్లు పడుతుంది కాబట్టి, మేము బ్లాక్‌లో చేర్చాలి 1 000 000 లావాదేవీలు, అంటే మరిన్ని పంపడం 100 MB డేటా.
ప్రారంభంలో, నోడ్‌ల మధ్య కమ్యూనికేట్ చేయడానికి మేము `ethereumjs-devp2p` లైబ్రరీని ఉపయోగించాము, కానీ అది అంత డేటాను నిర్వహించలేకపోయింది. ఫలితంగా, మేము `ws` లైబ్రరీని ఉపయోగించాము మరియు వెబ్‌సాకెట్ ద్వారా బైనరీ డేటాను పంపడాన్ని కాన్ఫిగర్ చేసాము. వాస్తవానికి, పెద్ద డేటా ప్యాకెట్‌లను పంపేటప్పుడు కూడా మేము సమస్యలను ఎదుర్కొన్నాము, కానీ మేము వాటిని భాగాలుగా విభజించాము మరియు ఇప్పుడు ఈ సమస్యలు తొలగిపోయాయి.
అలాగే మెర్కిల్ ట్రీని ఏర్పరుస్తుంది మరియు హాష్‌ను లెక్కిస్తోంది 1 000 000 లావాదేవీల గురించి అవసరం 10 సెకన్లు నిరంతర గణన. ఈ సమయంలో, అన్ని నోడ్‌లతో కనెక్షన్ విచ్ఛిన్నం అవుతుంది. ఈ గణనను ప్రత్యేక థ్రెడ్‌కు తరలించాలని నిర్ణయించారు.
ముగింపులు:
వాస్తవానికి, మా పరిశోధనలు కొత్తవి కావు, కానీ కొన్ని కారణాల వల్ల చాలా మంది నిపుణులు అభివృద్ధి చెందుతున్నప్పుడు వాటి గురించి మరచిపోతారు.
- ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌కు బదులుగా ఫంక్షనల్ ప్రోగ్రామింగ్‌ని ఉపయోగించడం ఉత్పాదకతను మెరుగుపరుస్తుంది.
- ఉత్పాదక NodeJS సిస్టమ్ కోసం సర్వీస్ ఆర్కిటెక్చర్ కంటే ఏకశిలా అధ్వాన్నంగా ఉంది.
- భారీ గణన కోసం `worker_threads`ని ఉపయోగించడం సిస్టమ్ ప్రతిస్పందనను మెరుగుపరుస్తుంది, ముఖ్యంగా i/o ఆపరేషన్‌లతో వ్యవహరించేటప్పుడు.
- unix సాకెట్ http అభ్యర్థనల కంటే మరింత స్థిరంగా మరియు వేగంగా ఉంటుంది.
- మీరు నెట్‌వర్క్ ద్వారా పెద్ద డేటాను త్వరగా బదిలీ చేయవలసి వస్తే, వెబ్‌సాకెట్‌లను ఉపయోగించడం మరియు బైనరీ డేటాను పంపడం మంచిది, వాటిని భాగాలుగా విభజించి, అవి రాకపోతే ఫార్వార్డ్ చేయబడి, ఆపై ఒక సందేశంలో కలపవచ్చు.
మేము మిమ్మల్ని సందర్శించమని ఆహ్వానిస్తున్నాము గ్యాలరీలు ప్రాజెక్ట్:
వ్యాసం సహ-రచయిత అలెగ్జాండర్ నశివాన్, సీనియర్ డెవలపర్ .
మూలం: www.habr.com