Blockchain ass eng innovativ Technologie déi versprécht vill Beräicher vum mënschleche Liewen ze verbesseren. Et transferéiert real Prozesser a Produkter an den digitale Raum, garantéiert d'Geschwindegkeet an d'Zouverlässegkeet vun de Finanztransaktiounen, reduzéiert hir Käschte, an erlaabt Iech och modern DAPP Uwendungen mat Smart Kontrakter an dezentraliséierten Netzwierker ze kreéieren.
Wéinst de ville Virdeeler an ënnerschiddlech Uwendunge vu Blockchain, kann et iwwerraschend schéngen datt dës villverspriechend Technologie nach net an all Branche säi Wee gemaach huet. De Problem ass datt modern dezentraliséiert Blockchaine Skalierbarkeet feelen. Ethereum veraarbecht ongeféier 20 Transaktiounen pro Sekonn, wat net genuch ass fir d'Bedierfnesser vun den dynamesche Geschäfter vun haut ze treffen. Zur selwechter Zäit sinn Firmen, déi Blockchain Technologie benotzen, zéckt fir Ethereum opzeginn wéinst sengem héije Schutzgrad vu Hacking an Netzwierkfehler.
Fir Dezentraliséierung, Sécherheet a Skalierbarkeet am Blockchain ze garantéieren, sou d'Scalability Trilemma ze léisen, d'Entwécklungsteam Plasma Cash erstallt, eng Duechtergesellschaftskette besteet aus engem Smart Kontrakt an engem privaten Netzwierk baséiert op Node.js, déi periodesch säi Staat an d'Root Kette (Ethereum) transferéiert.
Schlëssel Prozesser am Plasma Cash
1. De Benotzer nennt d'Smart Kontraktfunktioun "Depot", andeems hien de Betrag vun der ETH an de Plasma Cash Token deposéiere wëllt. D'Smart Kontrakt Funktioun erstellt en Token a generéiert en Event doriwwer.
2. Plasma Cash Noden, déi op Smart Kontrakt Eventer abonnéiert sinn, kréien en Event iwwer d'Schafe vun engem Depot a fügen eng Transaktioun iwwer d'Schafe vun engem Token an de Pool.
3. Periodesch huelen speziell Plasma Cash Noden all Transaktiounen aus dem Pool (bis zu 1 Millioun) a bilden e Block vun hinnen, berechent de Merkle Bam an deementspriechend den Hash. Dëse Block gëtt fir d'Verifizéierung an aner Node geschéckt. D'Node kontrolléieren ob de Merkle Hash gëlteg ass an ob d'Transaktioune gëlteg sinn (zum Beispill ob de Sender vum Token säi Besëtzer ass). No der Verifizéierung vum Block, nennt den Node d''submitBlock' Funktioun vum Smart Kontrakt, deen d'Blocknummer an d'Merkle Hash an d'Randkette späichert. De Smart Kontrakt generéiert en Event deen den erfollegräichen Zousatz vun engem Block bezeechent. Transaktioune ginn aus dem Pool geläscht.
4. Noden, déi de Block Soumissioun Event kréien, fänken un d'Transaktiounen z'applizéieren déi an de Block bäigefüügt goufen.
5. Iergendwann wëll de Besëtzer (oder Net-Besëtzer) vum Token et aus Plasma Cash zréckzéien. Fir dëst ze maachen, nennt hien d'Funktioun "startExit", andeems hien d'Informatioun iwwer déi lescht 2 Transaktiounen um Token weiderginn, déi bestätegen datt hien de Besëtzer vum Token ass. De Smart Kontrakt, mat der Merkle Hash, kontrolléiert d'Präsenz vun Transaktiounen an de Blocken a schéckt den Token fir d'Entzéiung, wat an zwou Wochen geschitt.
6. Wann d'Token Réckzuch Operatioun mat Violatioune geschitt ass (den Token gouf no der Entzugsprozedur ugefaang oder den Token war scho vun engem aneren virum Réckzuch), kann de Besëtzer vum Token de Réckzuch innerhalb vun zwou Wochen refuséieren.
Privatsphär gëtt op zwou Weeër erreecht
1. D'Root Kette weess näischt iwwer d'Transaktiounen déi an der Kannerkette generéiert a weidergeleet ginn. Informatioun iwwer wien ETH vu Plasma Cash deposéiert an zréckgezunn huet bleift ëffentlech.
2. D'Kand Kette erlaabt anonym Transaktiounen mat zk-SNARKs.
Technologie Stack
- NodeJS
- Redis
- Ethereum
- Buedem
Testen
Wärend der Entwécklung vu Plasma Cash, hu mir d'Geschwindegkeet vum System getest an déi folgend Resultater kritt:
- bis zu 35 Transaktiounen pro Sekonn ginn an de Pool dobäigesat;
- bis zu 1 Transaktiounen kënnen an engem Block gespäichert ginn.
Tester goufen op de folgenden 3 Serveren duerchgefouert:
1. Intel Haaptentwéckler i7-6700 Quad-Core Skylake inkl. NVMe SSD - 512 GB, 64 GB DDR4 RAM
3 validéierend Plasma Cash Noden goufen opgehuewen.
2. AMD Ryzen 7 1700X Octa-Core "Summit Ridge" (Zen), SATA SSD - 500 GB, 64 GB DDR4 RAM
De Ropsten Testnet ETH Node gouf erhéicht.
3 validéierend Plasma Cash Noden goufen opgehuewen.
3. Intel Haaptentwéckler i9-9900K Octa-Core inkl. NVMe SSD - 1 TB, 64 GB DDR4 RAM
1 Plasma Cash Soumissioun Node gouf erhéicht.
3 validéierend Plasma Cash Noden goufen opgehuewen.
En Test gouf gestart fir Transaktiounen an de Plasma Cash Netz ze addéieren.
Total: 10 Plasma Cash Wirbelen an engem privaten Netzwierk.
Test 1
Et gëtt eng Limite vun 1 Millioun Transaktiounen pro Block. Dofir falen 1 Millioun Transaktiounen an 2 Blocken (well de System et fäerdeg bréngt en Deel vun den Transaktiounen ze huelen an ofzeginn wärend se geschéckt ginn).
Ufank Staat: leschte Spär # 7; 1 Millioun Transaktiounen an Tokens ginn an der Datebank gespäichert.
00:00 - Start vun Transaktioun Generatioun Skript
01:37 - 1 Millioun Transaktioune goufen erstallt an d'Sendung an den Node huet ugefaang
01:46 - Soumissioun Node huet 240k Transaktiounen aus dem Pool a Formen Block #8. Mir gesinn och datt 320k Transaktiounen an de Pool an 10 Sekonnen bäigefüügt ginn
01:58 - Block #8 ass ënnerschriwwen a fir Validatioun geschéckt
02:03 - Block #8 ass validéiert an d''submitBlock' Funktioun vum Smart Kontrakt gëtt mam Merkle Hash a Blocknummer genannt
02:10 - Demo Skript huet fäerdeg geschafft, deen 1 Millioun Transaktiounen an 32 Sekonnen geschéckt huet
02:33 - Noden hunn ugefaang Informatioun ze kréien datt de Block #8 an d'Rootkette bäigefüügt gouf, an hunn ugefaang 240k Transaktiounen auszeféieren
02:40 - 240k Transaktioune goufen aus dem Pool geläscht, déi schonn am Block #8 sinn
02:56 - Submit Node huet déi verbleiwen 760k Transaktiounen aus dem Pool geholl an ugefaang de Merkle Hash ze berechnen an de Block #9 z'ënnerschreiwen
03:20 - all Noden enthalen 1 Millioun 240k Transaktiounen an Tokens
03:35 - Block #9 gëtt ënnerschriwwen a fir Validatioun an aner Noden geschéckt
03:41 - Netzfehler ass geschitt
04:40 - waart op d'Validatioun vum Block #9 ass ofgeschloss
04:54 - Submit Node huet déi verbleiwen 760k Transaktiounen aus dem Pool geholl an ugefaang de Merkle Hash ze berechnen an de Block #9 z'ënnerschreiwen
05:32 - Block #9 gëtt ënnerschriwwen a fir Validatioun an aner Noden geschéckt
05:53 - Block #9 gëtt validéiert an an d'Rootkette geschéckt
06:17 - Noden hunn ugefaang Informatioun ze kréien datt de Block #9 an d'Rootkette bäigefüügt gouf an ugefaang 760k Transaktiounen auszeféieren
06:47 - de Pool huet vun Transaktiounen geläscht déi am Block #9 sinn
09:06 - all Noden enthalen 2 Milliounen Transaktiounen an Tokens
Test 2
Et gëtt eng Limite vun 350k pro Block. Als Resultat hu mir 3 Blocks.
Ufank Staat: leschte Spär # 9; 2 Milliounen Transaktiounen an Tokens ginn an der Datebank gespäichert
00:00 - Transaktiounsgeneratiounsskript ass scho gestart
00:44 - 1 Millioun Transaktioune goufen erstallt an d'Sendung an den Node huet ugefaang
00:56 - Soumissioun Node huet 320k Transaktiounen aus dem Pool a Formen Block #10. Mir gesinn och datt 320k Transaktiounen an de Pool an 10 Sekonnen bäigefüügt ginn
01:12 - Block #10 gëtt ënnerschriwwen an an aner Noden geschéckt fir ze validéieren
01:18 - Demo Skript huet fäerdeg geschafft, deen 1 Millioun Transaktiounen an 34 Sekonnen geschéckt huet
01:20 - Block #10 gëtt validéiert an an d'Root Kette geschéckt
01:51 - all Node kruten Informatioun vun der Rootkette datt de Block #10 bäigefüügt gouf a fänken un 320k Transaktiounen anzesetzen
02:01 - de Pool huet fir 320k Transaktioune geläscht, déi an de Block #10 bäigefüügt goufen
02:15 - Soumissioun Node huet 350k Transaktiounen aus dem Pool a Formen Block #11
02:34 - Block #11 gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
02:51 - Block #11 gëtt validéiert an an d'Root Kette geschéckt
02:55 - de leschten Node fäerdeg Transaktioune vum Block #10
10:59 - d'Transaktioun mat der Soumissioun vum Block #9 huet eng ganz laang Zäit an der Rootkette gedauert, awer et war ofgeschloss an all Node kruten Informatioun doriwwer an hunn ugefaang 350k Transaktiounen auszeféieren.
11:05 - de Pool huet fir 320k Transaktioune geläscht, déi an de Block #11 bäigefüügt goufen
12:10 - all Node enthalen 1 Millioun 670k Transaktiounen an Tokens
12:17 - Soumissioun Node huet 330k Transaktiounen aus dem Pool a Formen Block #12
12:32 - Block #12 gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
12:39 - Block #12 gëtt validéiert an an d'Root Kette geschéckt
13:44 - all Node kruten Informatioun vun der Rootkette datt de Block #12 bäigefüügt gouf a fänken un 330k Transaktiounen anzesetzen
14:50 - all Noden enthalen 2 Milliounen Transaktiounen an Tokens
Test 3
Am éischten an zweete Server gouf ee validéierende Node duerch e Submitting Node ersat.
Ufank Staat: leschte Spär # 84; 0 Transaktiounen an Tokens an der Datebank gespäichert
00:00 - 3 Skripte goufen lancéiert déi all 1 Millioun Transaktiounen generéieren a schécken
01:38 - 1 Millioun Transaktioune goufen erstallt a geschéckt fir Node #3 ofzeginn huet ugefaang
01:50 - ofginn Node #3 huet 330k Transaktiounen aus dem Pool a Forme Block #85 (f21). Mir gesinn och datt 350k Transaktiounen an de Pool an 10 Sekonnen bäigefüügt ginn
01:53 - 1 Millioun Transaktioune goufen erstallt a geschéckt fir Node #1 ofzeginn huet ugefaang
01:50 - ofginn Node #3 huet 330k Transaktiounen aus dem Pool a Forme Block #85 (f21). Mir gesinn och datt 350k Transaktiounen an de Pool an 10 Sekonnen bäigefüügt ginn
02:01 - Ofginn Node #1 huet 250k Transaktioune vum Pool a Forme Block #85 (65e)
02:06 - Block #85 (f21) gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
02:08 - Demo Skript vum Server #3, deen 1 Millioun Transaktiounen an 30 Sekonnen geschéckt huet, fäerdeg geschafft
02:14 - Block #85 (f21) gëtt validéiert an an d'Root Kette geschéckt
02:19 - Block #85 (65e) gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
02:22 - 1 Millioun Transaktioune goufen erstallt a geschéckt fir Node #2 ofzeginn huet ugefaang
02:27 - Block #85 (65e) validéiert an an d'Root Kette geschéckt
02:29 - ofginn Node #2 huet 111855 Transaktiounen aus dem Pool a Forme Block #85 (256) gemaach.
02:36 - Block #85 (256) gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
02:36 - Demo Skript vum Server #1, deen 1 Millioun Transaktiounen an 42.5 Sekonnen geschéckt huet, fäerdeg geschafft
02:38 - Block #85 (256) gëtt validéiert an an d'Rootkette geschéckt
03:08 - Server #2 Skript huet fäerdeg geschafft, deen 1 Millioun Transaktiounen a 47 Sekonnen geschéckt huet
03:38 - all Node kruten Informatioun vun der Rootkette déi blockéiert #85 (f21), #86(65e), #87(256) goufen bäigefüügt an hunn ugefaang 330k, 250k, 111855 Transaktiounen ze gëllen
03:49 - de Pool gouf bei 330k, 250k, 111855 Transaktiounen geläscht, déi an de Block #85 (f21), #86(65e), #87(256) bäigefüügt goufen
03:59 - Ofschécken Node #1 huet 888145 Transaktioune vum Pool a Forme Block #88 (214), ofginn Node #2 huet 750k Transaktioune vum Pool geholl a Forme Block #88 (50a), ofginn Node #3 huet 670k Transaktioune vun de Pool a Formen Block #88 (d3b)
04:44 - Block #88 (d3b) gëtt ënnerschriwwen an an aner Node geschéckt fir ze validéieren
04:58 - Block #88 (214) gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
05:11 - Block #88 (50a) gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
05:11 - Block #85 (d3b) gëtt validéiert an an d'Root Kette geschéckt
05:36 - Block #85 (214) gëtt validéiert an an d'Rootkette geschéckt
05:43 - all Node kruten Informatioun vun der Rootkette déi blockéiert #88 (d3b), #89(214) goufen bäigefüügt a fänken un 670k, 750k Transaktiounen anzesetzen
06:50 - wéinst engem Kommunikatiounsfehler gouf de Block #85 (50a) net validéiert
06:55 - ofginn Node #2 huet 888145 Transaktioune vum Pool a Forme Block #90 (50a)
08:14 - Block #90 (50a) gëtt ënnerschriwwen an op aner Node geschéckt fir ze validéieren
09:04 - Block #90 (50a) gëtt validéiert an an d'Root Kette geschéckt
11:23 - all Wirbelen kritt Informatiounen aus der Wuerzel Kette datt Block #90 (50a) dobäi war, a fänken 888145 Transaktiounen ze gëllen. Zur selwechter Zäit huet de Server #3 schonn Transaktioune vu Block #88 (d3b), #89(214) applizéiert.
12:11 - all Pool sinn eidel
13:41 - all Node vum Server #3 enthalen 3 Milliounen Transaktiounen an Tokens
14:35 - all Node vum Server #1 enthalen 3 Milliounen Transaktiounen an Tokens
19:24 - all Node vum Server #2 enthalen 3 Milliounen Transaktiounen an Tokens
Hindernisser
Wärend der Entwécklung vu Plasma Cash hu mir déi folgend Probleemer begéint, déi mir lues a lues geléist hunn a léisen:
1. Konflikt an der Interaktioun vu verschiddene Systemfunktiounen. Zum Beispill huet d'Funktioun fir Transaktiounen an de Pool ze addéieren blockéiert d'Aarbecht vun der Soumissioun an der Validatioun vu Blocken, a vice-versa, wat zu enger Ofsenkung vun der Geschwindegkeet gefouert huet.
2. Et war net direkt kloer wéi eng grouss Unzuel vun Transaktiounen ze schécken wärend d'Datentransferkäschte minimiséieren.
3. Et war net kloer wéi a wou Daten gespäichert ginn fir héich Resultater z'erreechen.
4. Et war net kloer wéi een Netzwierk tëscht Noden organiséiert, well d'Gréisst vun engem Block mat 1 Millioun Transaktiounen ongeféier 100 MB hëlt.
5. Schafft am Single-threaded Modus brécht d'Verbindung tëscht Noden wann laang Berechnunge geschéien (zum Beispill, e Merkle Bam bauen a seng Hash berechnen).
Wéi hu mir dat alles ëmgeet?
Déi éischt Versioun vum Plasma Cash Node war eng Zort Kombinatioun déi alles zur selwechter Zäit konnt maachen: Transaktiounen akzeptéieren, Blocks ofginn an validéieren, an eng API fir Zougang zu Daten ubidden. Zënter NodeJS nativ Single-threaded ass, blockéiert déi schwéier Merkle Bam Berechnungsfunktioun d'Add Transaction Funktioun. Mir hunn zwou Méiglechkeeten gesinn fir dëse Problem ze léisen:
1. Lancéiere verschidde NodeJS Prozesser, jidderee vun deenen spezifesch Funktiounen ausféiert.
2. Benotzt worker_threads a réckelt d'Ausféierung vun engem Deel vum Code an Threads.
Als Resultat hu mir béid Optiounen zur selwechter Zäit benotzt: mir hunn logesch een Node an 3 Deeler opgedeelt, déi separat funktionnéiere kënnen, awer gläichzäiteg synchron
1. Soumissioun Node, deen Transaktiounen an de Pool akzeptéiert a blockéiert erstellt.
2. E validéierende Node deen d'Validitéit vun den Noden iwwerpréift.
3. API Node - bitt en API fir Zougang zu Daten.
An dësem Fall kënnt Dir op all Node iwwer eng Unix Socket mat Cli verbannen.
Mir hunn schwéier Operatiounen, wéi d'Berechnung vum Merkle Bam, an e separate Fuedem geréckelt.
Sou hu mir normal Operatioun vun all Plasma Cash Funktiounen gläichzäiteg an ouni Feeler erreecht.
Wann de System funktionell war, hu mir ugefaang d'Geschwindegkeet ze testen an hunn leider onzefridden Resultater kritt: 5 Transaktiounen pro Sekonn a bis zu 000 Transaktiounen pro Block. Ech hu missen erausfannen, wat falsch ëmgesat gouf.
Fir unzefänken, hu mir ugefaang de Mechanismus vun der Kommunikatioun mat Plasma Cash ze testen fir d'Peakkapazitéit vum System erauszefannen. Mir hunn virdru geschriwwen datt de Plasma Cash Node eng Unix Socket Interface ubitt. Am Ufank war et Text-baséiert. json Objete goufen mat `JSON.parse()` an `JSON.stringify()` geschéckt.
```json
{
"action": "sendTransaction",
"payload":{
"prevHash": "0x8a88cc4217745fd0b4eb161f6923235da10593be66b841d47da86b9cd95d93e0",
"prevBlock": 41,
"tokenId": "57570139642005649136210751546585740989890521125187435281313126554130572876445",
"newOwner": "0x200eabe5b26e547446ae5821622892291632d4f4",
"type": "pay",
"data": "",
"signature": "0xd1107d0c6df15e01e168e631a386363c72206cb75b233f8f3cf883134854967e1cd9b3306cc5c0ce58f0a7397ae9b2487501b56695fe3a3c90ec0f61c7ea4a721c"
}
}
```
Mir hunn d'Transfergeschwindegkeet vun esou Objeten gemooss an hunn ~ 130k pro Sekonn fonnt. Mir hu probéiert d'Standardfunktiounen ze ersetzen fir mat json ze schaffen, awer d'Performance huet net verbessert. De V8 Motor muss gutt fir dës Operatiounen optimiséiert ginn.
Mir hunn mat Transaktiounen, Tokens a Blocken duerch Klassen geschafft. Wann Dir esou Klassen erstellt, ass d'Leeschtung ëm 2 Mol erofgaang, wat beweist datt OOP net fir eis gëeegent ass. Ech hu missen alles op eng reng funktionell Approche ëmschreiwen.
Opzeechnung an der Datebank
Am Ufank gouf Redis fir Datelagerung als eng vun de produktivste Léisungen gewielt, déi eis Ufuerderungen entsprécht: Schlësselwäertspäicherung, Schafft mat Hashtabellen, Sets. Mir hunn Redis-Benchmark gestart a kruten ~ 80k Operatiounen pro Sekonn am 1 Pipelining Modus.
Fir héich Leeschtung hu mir Redis méi fein ofgestëmmt:
- Eng Unix Socket Verbindung gouf etabléiert.
- Mir behënnert de Staat op Disk ze späicheren (fir Zouverlässegkeet kënnt Dir eng Replika opsetzen an op Disk späicheren an enger separater Redis).
A Redis ass e Pool en Hash-Tabelle well mir musse fäeg sinn all Transaktiounen an enger Ufro ze recuperéieren an Transaktiounen een nom aneren ze läschen. Mir hu probéiert eng regulär Lëscht ze benotzen, awer et ass méi lues wann Dir déi ganz Lëscht ausluet.
Wann Dir Standard NodeJS benotzt, hunn d'Redis Bibliothéiken eng Leeschtung vun 18k Transaktiounen pro Sekonn erreecht. D'Vitesse ass 9 Mol erofgaang.
Well de Benchmark eis gewisen huet datt d'Méiglechkeeten kloer 5 Mol méi grouss waren, hu mir ugefaang ze optimiséieren. Mir hunn d'Bibliothéik op ioredis geännert a krut Leeschtung vun 25k pro Sekonn. Mir hunn Transaktiounen een nom aneren bäigefüügt mam Kommando "hset". Also hu mir vill Ufroen am Redis generéiert. D'Iddi ass entstanen Transaktiounen a Chargen ze kombinéieren an se mat engem Kommando `hmset` ze schécken. D'Resultat ass 32k pro Sekonn.
Aus verschiddene Grënn, déi mir hei ënnen beschreiwen, schaffe mir mat Daten mat `Buffer` a wéi et sech erausstellt, wann Dir se an Text konvertéiert (`buffer.toString('hex')`), ier Dir schreift, kënnt Dir zousätzlech kréien Leeschtung. Sou gouf d'Vitesse op 35k pro Sekonn erhéicht. Am Moment hu mir décidéiert fir weider Optimisatioun ze stoppen.
Mir hu missen op e binäre Protokoll wiesselen well:
1. De System berechent dacks Hashes, Ënnerschrëften, etc., a fir dëst brauch et Daten am `Buffer.
2. Wann tëscht Servicer geschéckt, binär Daten Gewiicht manner wéi Text. Zum Beispill, wann Dir e Block mat 1 Millioun Transaktiounen schéckt, kënnen d'Donnéeën am Text méi wéi 300 Megabytes ophuelen.
3. Konstant Datentransformatioun beaflosst d'Performance.
Dofir hu mir als Basis eisen eegene binäre Protokoll geholl fir Daten ze späicheren an ze vermëttelen, entwéckelt op Basis vun der wonnerbarer "binärer Donnéeën" Bibliothéik.
Als Resultat hu mir déi folgend Datestrukturen:
- Transaktioun
```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,
}
```
- Token
```json
{
id: BD.types.string(null),
owner: BD.types.buffer(20),
block: BD.types.uint24le,
amount: BD.types.string(null),
}
```
— Block
```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,
}
```
Mat den üblechen Kommandoen `BD.encode(block, Protocol).slice();` an `BD.decode(buffer, Protocol)` konvertéiere mir d'Donnéeën an `Buffer` fir an Redis ze späicheren oder op en aneren Node weiderzebréngen an d'Recuperatioun vum daten zréck.
Mir hunn och 2 binär Protokoller fir Daten tëscht Servicer ze transferéieren:
- Protokoll fir Interaktioun mat Plasma Node iwwer Unix Socket
```json
{
type: BD.types.uint8,
messageId: BD.types.uint24le,
error: BD.types.uint8,
length: BD.types.uint24le,
payload: BD.types.buffer(({node}) => node.length)
}
```
wou:
- 'Typ' - d'Aktioun ze maachen, zum Beispill, 1 - sendTransaction, 2 - getTransaction;
- `Notzlaascht` - Daten déi un déi entspriechend Funktioun weiderginn musse ginn;
- 'messageId' - Message ID sou datt d'Äntwert identifizéiert ka ginn.
- Protokoll fir Interaktioun tëscht Noden
```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)
}
```
wou:
- 'Code' - Message Code, zum Beispill 6 - PREPARE_NEW_BLOCK, 7 - BLOCK_VALID, 8 - BLOCK_COMMIT;
- 'versionProtocol' - Protokollversioun, well Wirbelen mat verschiddene Versioune kënnen am Netz eropgebaut ginn a si kënnen anescht funktionnéieren;
- `sech` - Message Identifizéierer;
- `countChunk` и `ChunkNumber` néideg fir grouss Messagen opzedeelen;
- 'Längt' и `Notzlaascht` Längt an d'Donnéeën selwer.
Zënter datt mir d'Donnéeën virgeschriwwe hunn, ass de finalen System vill méi séier wéi d'Ethereum 'rlp' Bibliothéik. Leider konnte mir et nach net refuséieren, well et néideg ass de Smart Kontrakt ofzeschléissen, wat mir plangen an Zukunft ze maachen.
Wa mir et fäerdeg bruecht hunn d'Vitesse z'erreechen 35 000 Transaktiounen pro Sekonn, musse mir se och an der optimaler Zäit veraarbecht. Zënter datt déi geschätzte Blockbildungszäit 30 Sekonnen dauert, musse mir an de Block enthalen 1 000 000 Transaktiounen, dat heescht méi schécken 100 MB Daten.
Am Ufank hu mir d''ethereumjs-devp2p' Bibliothéik benotzt fir tëscht Noden ze kommunizéieren, awer et konnt net sou vill Daten handhaben. Als Resultat hu mir d''ws' Bibliothéik benotzt a konfiguréiert d'Schécken vun binäre Daten iwwer Websocket. Natierlech hu mir och Problemer begéint wann Dir grouss Datepäck schécken, awer mir hunn se a Stécker opgedeelt an elo sinn dës Probleemer fort.
Och e Merkle Bam bilden an den Hash berechnen 1 000 000 Transaktiounen verlaangt iwwer 10 Sekonnen vun kontinuéierlech Berechnung. Wärend dëser Zäit geléngt d'Verbindung mat all Noden ze briechen. Et gouf decidéiert dës Berechnung op eng separat Fuedem ze plënneren.
Konklusiounen:
Tatsächlech sinn eis Erkenntnisser net nei, awer aus irgendege Grënn vergiessen vill Experten iwwer si wann se entwéckelen.
- Funktionell Programméierung ze benotzen anstatt Objektorientéiert Programméierung verbessert Produktivitéit.
- De Monolith ass méi schlëmm wéi eng Servicearchitektur fir e produktive NodeJS System.
- Benotzt 'worker_threads' fir schwéier Berechnung verbessert d'Systemreaktiounsfäegkeet, besonnesch wann Dir mat i/o Operatiounen handelt.
- Unix Socket ass méi stabil a méi séier wéi http Ufroen.
- Wann Dir séier grouss Daten iwwer d'Netzwierk transferéiere musst, ass et besser Websockets ze benotzen a binär Daten ze schécken, opgedeelt a Stécker, déi weidergeleet kënne ginn wann se net kommen, an dann an ee Message kombinéiert ginn.
Mir invitéieren Iech op Besuch GitHub Projet:
Den Artikel gouf zesumme geschriwwen vum Alexander Nashivan, Senior Entwéckler .
Source: will.com