Als nächst wäerte mir am Detail d'Haaptcharakteristike vun der Move Sprooch betruechten a wat sinn hir Schlësseldifferenzen mat enger anerer, scho populärer Sprooch fir Smart Kontrakter - Solidity (op der Ethereum Plattform). D'Material baséiert op enger Studie vum verfügbaren Online 26-Säit Wäissbuch.
Aféierung
Move ass eng ausführbar Bytecode Sprooch déi benotzt gëtt fir Benotzertransaktiounen a Smart Kontrakter auszeféieren. Notéiert w.e.g. zwee Punkten:
- Wärend Move eng Bytecodesprooch ass, déi direkt op der Move virtueller Maschinn ausgefouert ka ginn, Solidity (Ethereum's Smart Contract Language) ass eng méi héich Sprooch, déi als éischt op Bytecode kompiléiert gëtt ier se op engem EVM ausgefouert gëtt (Ethereum Virtual Machine).
- Move ka benotzt ginn net nëmme fir intelligent Kontrakter ëmzesetzen, awer och fir personaliséiert Transaktiounen (méi iwwer dëst méi spéit), wärend Solidity eng intelligent kontraktuell Sprooch ass.
D'Iwwersetzung gouf vum INDEX Protocol Project Team duerchgefouert. Mir hu schonn iwwersat , elo ass et Zäit d'Move Sprooch e bësse méi am Detail ze kucken. D'Iwwersetzung gouf zesumme mam Habrauser duerchgefouert
Eng Schlëssel Feature vu Move ass d'Fäegkeet fir personaliséiert Ressourcentypen mat Semantik ze definéieren baséiert op linearer Logik: eng Ressource kann ni kopéiert oder implizit geläscht ginn, nëmme geréckelt. Funktionell ass dëst ähnlech wéi d'Fäegkeete vun der Rust Sprooch. Wäerter am Rust kënnen nëmmen un engem Numm gläichzäiteg zougewisen ginn. Wann Dir e Wäert un en aneren Numm zouzeechnen, mécht en net verfügbar ënner dem viregten Numm.
Zum Beispill werft de folgende Codestéck e Feeler: Benotze vum bewegt Wäert 'x'. Dëst ass well et keng Müllsammlung zu Rust gëtt. Wann d'Variabelen aus dem Ëmfang goen, gëtt d'Erënnerung op déi se bezéien och befreit. Einfach gesot, et kann nëmmen een "Besëtzer" vun den Donnéeën sinn. An dësem Beispill x ass den originelle Besëtzer an dann y gëtt den neie Besëtzer. .
Representatioun vun digitale Verméigen an oppenen Systemer
Et ginn zwou Eegeschafte vu kierperleche Verméigen déi schwéier digital ze representéieren sinn:
- Raritéit (Knappheet, ursprénglech Knappheet). D'Zuel vun de Verméigen (Emissioun) am System muss kontrolléiert ginn. Duplikatioun vun existente Verméigen muss verbueden sinn, an nei ze kreéieren ass eng privilegéiert Operatioun.
- Zougang Kontroll... De System Participant muss fäeg sinn Verméigen ze schützen mat Zougangskontrollpolitik.
Dës zwee Charakteristiken, déi natierlech fir kierperlech Verméigen sinn, musse fir digital Objete implementéiert ginn wa mir se als Verméige wëlle betruechten. Zum Beispill huet e rare Metal en natierlechen Defizit, an nëmmen Dir hutt Zougang dozou (hält et an Ären Hänn, zum Beispill) an Dir kënnt et verkafen oder ausginn.
Fir ze illustréieren wéi mir op dës zwou Eegeschafte ukomm sinn, loosst eis mat de folgende Sätz ufänken:
Virschlag # 1: Déi einfachst Regel Ouni Knappheet an Zougangskontroll
- G [K]: = n bezeechent en Update vun enger Nummer zougänglech mat engem Schlëssel К am globalen Zoustand vun der Blockchain, mat enger neier Bedeitung n.
- Transaktioun ⟨Alice, 100⟩ heescht datt dem Alice säi Kontbalance op 100 setzt.
Déi uewe genannte Léisung huet e puer grouss Probleemer:
- D'Alice kann eng onlimitéiert Unzuel u Mënzen kréien andeems se einfach schécken Transaktioun ⟨Alice, 100⟩.
- D'Mënzen, déi d'Alice dem Bob schéckt, sinn nëtzlos, well de Bob selwer eng onlimitéiert Unzuel u Mënze schéckt mat der selwechter Technik.
Virschlag # 2: Den Defizit berécksiichtegt
Elo iwwerwaache mir d'Situatioun sou datt d'Zuel vu Mënzen Ka war op d'mannst gläich n virun der Transfertransaktioun. Wéi och ëmmer, wärend dëst de Problem vu Knappheet opléist, gëtt et keng Informatioun iwwer wien d'Alice Mënzen schécken kann (fir de Moment kann iergendeen dëst maachen, d'Haapt Saach ass net d'Regel ze limitéieren fir de Betrag ze limitéieren).
Offer # 3: Kombinéiere vu Knappheet an Zougangskontroll
Mir léisen dëse Problem mat engem digitale Signaturmechanismus verifizéieren_sig ier Dir d'Gläichgewiicht iwwerpréift, dat heescht datt d'Alice hire private Schlëssel benotzt fir d'Transaktioun z'ënnerschreiwen an ze bestätegen datt si de Besëtzer vun hire Mënzen ass.
Blockchain Programméierungssproochen
Bestehend Blockchain Sprooche sti fir déi folgend Probleemer (se goufen all a Beweegung geléist (Notiz: leider, den Auteur vum Artikel appelléiert nëmmen op Ethereum a senge Vergläicher, also ass et derwäert se nëmmen an dësem Kontext ze huelen. Zum Beispill gëtt déi meescht vun de folgenden och am EOS geléist.))):
Indirekt Representatioun vun Verméigen. En Verméigen ass kodéiert mat engem Ganzt, awer en Ganzt ass net datselwecht wéi en Verméigen. Tatsächlech gëtt et keen Typ oder Wäert representéiert Bitcoin/Ether/<All Mënz>! Dëst mécht Schreiwen Programmer déi Verméigen benotzen schwéier a Feeler-ufälleg. Mustere wéi d'Verméigen op / vu Prozeduren ofginn oder Verméigen a Strukturen späicheren erfuerderen speziell Ënnerstëtzung vun der Sprooch.
Den Defizit ass net erweidert... Sprooch duerstellt nëmmen ee knapps Verméigen. Zousätzlech ginn d'Medikamenter géint Knappheet direkt an d'Semantik vun der Sprooch selwer gedréit. Den Entwéckler, wann hien e personaliséierten Verméigen wëllt erstellen, muss suergfälteg all Aspekter vun der Ressource selwer kontrolléieren. Dëst si genau d'Problemer vun Ethereum Smart Kontrakter.
D'Benotzer verëffentlechen hir Verméigen, ERC-20 Tokens, benotze ganz Zuelen fir souwuel de Wäert wéi och d'Gesamtversuergung ze bestëmmen. Wann ëmmer nei Tokens erstallt ginn, muss de Smart Kontraktcode onofhängeg d'Konformitéit mat den Emissiounsregele verifizéieren. Zousätzlech féiert déi indirekt Presentatioun vun Verméigen, a ville Fäll, zu eeschte Feeler - Duplikatioun, Duebelausgaben oder souguer e komplette Verloscht vun Verméigen.
Mangel u flexiblen Zougangskontroll... Déi eenzeg Zougangskontrollpolitik déi aktuell benotzt gëtt ass e Ënnerschrëftschema mat asymmetrescher Kryptografie. Wéi Knappheetsschutz, sinn Zougangskontrollpolitik déif an d'Semantik vun der Sprooch agebonne. Awer wéi d'Sprooch ze verlängeren fir Programmer ze erlaben hir eege Zougangskontrollpolitik ze definéieren ass dacks eng ganz komplizéiert Aufgab.
Dëst ass och wouer op Ethereum, wou Smart Kontrakter keng gebierteg Kryptografie Ënnerstëtzung fir Zougangskontroll hunn. D'Entwéckler mussen den Zougangskontroll manuell setzen, zum Beispill, den eenzege Besëtzer Modifikateur ze benotzen.
Och wann ech e grousse Fan vun Ethereum sinn, gleewen ech datt Verméigenseigenschaften natiirlech vun der Sprooch fir Sécherheetszwecker ënnerstëtzt solle ginn. Besonnesch d'Iwwerdroung vun Ether op e Smart Kontrakt involvéiert dynamesch Verschécken, wat eng nei Klass vu Bugs agefouert huet bekannt als Re-Entrancy Schwachstelle. Dynamesch Verschécken heescht hei datt d'Ausféierungslogik vum Code am Runtime (dynamesch) anstatt bei der Kompiléierungszäit (statesch) bestëmmt gëtt.
Also, an der Soliditéit, wann de Kontrakt A eng Funktioun am Kontrakt B nennt, kann de Kontrakt B Code lafen deen net vum Entwéckler vum Kontrakt A geduecht war, wat zu (Kontrakt A wierkt zoufälleg als Kontrakt B fir Suen zréckzezéien ier d'Kontosalden tatsächlech ofgezunn sinn).
Move Language Design Fundamentals
Éischt Uerdnung Ressourcen
Op engem héijen Niveau ass d'Interaktioun tëscht Moduler / Ressourcen / Prozeduren an der Move Sprooch ganz ähnlech wéi d'Relatioun tëscht Klassen / Objeten a Methoden an OOP Sproochen.
Move Moduler sinn ähnlech wéi Smart Kontrakter an anere Blockchains. De Modul deklaréiert Ressourcetypen a Prozeduren, déi d'Regele definéiere fir erstallt, zerstéieren an aktualiséieren deklaréiert Ressourcen. Awer all dës si just Konventiounen ("Jargon") Beweegt. Mir wäerten dëse Punkt e bësse méi spéit illustréieren.
Flexibilitéit
Move füügt Flexibilitéit un Libra duerch Scripting. All Transaktioun an der Libra enthält e Skript, wat am Fong de Kärprozedur vun der Transaktioun ass. De Skript kann entweder eng spezifizéiert Handlung ausféieren, zum Beispill Bezuelungen un eng spezifizéierter Lëscht vun Empfänger, oder aner Ressourcen weiderbenotzen - zum Beispill andeems Dir eng Prozedur rufft an där déi allgemeng Logik spezifizéiert ass. Dofir bidden Move Transaktiounsskripter méi Flexibilitéit. E Skript ka souwuel eemoleg wéi och widderhuelend Verhalen benotzen, während Ethereum nëmmen widderholl Skripte kann ausféieren (eng Method op eng intelligent Kontraktmethod nennen). De Grond firwat et "weiderverwendbar" genannt gëtt ass well d'Funktioune vun engem Smart Kontrakt e puer Mol ausgefouert kënne ginn. (Note: De Punkt hei ass ganz subtil. Engersäits existéieren och Transaktiounsskripter a Form vu Pseudo-Bytecode a Bitcoin. Op der anerer Säit, wéi ech et verstinn, erweidert Move dës Sprooch, am Wesentlechen, op den Niveau vun enger vollwäerter Smart Kontrakt Sprooch).
Sécherheet
De Move ausführbare Format ass Bytecode, wat engersäits eng méi héije Sprooch ass wéi d'Versammlungssprooch, awer méi niddereg wéi d'Quellcode. De Bytecode gëtt a Run-Time (on-Chain) fir Ressourcen, Typen a Gedächtnissécherheet iwwerpréift mat engem Bytecode Verifizéierer, an dann vum Dolmetscher ausgefouert. Dës Approche erlaabt Move d'Sécherheet vum Quellcode ze bidden, awer ouni de Kompiléierungsprozess an de Besoin fir e Compiler zum System ze addéieren. Eng Bytecode Sprooch ze bewegen ass eng wierklech gutt Léisung. Et brauch net aus der Quell kompiléiert ze ginn, sou wéi de Fall mat Solidity, an et ass keng Suergen iwwer méiglech Feeler oder Attacken op der Compiler Infrastruktur.
Verifizéierbarkeet
Mir zielen d'Kontrollen sou einfach wéi méiglech auszeféieren, well dëst alles on-chain gemaach gëtt (Notiz: online, wärend der Ausféierung vun all Transaktioun, sou datt all Verzögerung zu enger Verlängerung vum ganze Netz féiert), awer am Ufank ass de Sproochdesign prett fir off-chain statesch Verifizéierungsinstrumenter ze benotzen. Och wann dëst méi bevorzugt ass, ass fir de Moment d'Entwécklung vu Verifizéierungsinstrumenter (als separaten Toolkit) fir d'Zukunft ausgestallt ginn, an elo gëtt nëmmen dynamesch Verifizéierung an der Run-Time (on-chain) ënnerstëtzt.
Modularitéit
Plënneren Moduler bidden Datenabstraktioun a lokaliséiere kritesch Operatiounen op Ressourcen. D'Enkapselung, déi vum Modul geliwwert gëtt, kombinéiert mam Schutz vum Move Type System, garantéiert datt Eegeschafte, déi op den Modultypen gesat sinn, net mam Code ausserhalb vum Modul verletzt kënne ginn. Dëst ass e zimlech gutt duerchduechte Abstraktiounsdesign, dat heescht datt d'Donnéeën am Kontrakt nëmmen am Kader vum Kontrakt kënne änneren, awer net dobausse.
Plënneren Iwwerbléck
D'Transaktiouns Skriptbeispill weist datt béisaarteg oder virsiichteg Aktiounen vun engem Programméierer ausserhalb vun engem Modul d'Sécherheet vun de Modulressourcen net kompromittéiere kënnen. Als nächst wäerte mir Beispiller kucken wéi Moduler, Ressourcen, a Prozedure gi benotzt fir d'Libra Blockchain ze programméieren.
Peer-to-Peer Bezuelungen
D'Zuel vun de Mënzen, déi am Betrag spezifizéiert sinn, gëtt vum Sender vum Gläichgewiicht un den Empfänger transferéiert.
Et ginn e puer nei Saachen hei (rout markéiert):
- 0x0: Adress vum Kont wou de Modul gespäichert ass
- Währung: Modul Numm
- Coin: Ressource Typ
- De Mënzwäert, dee vun der Prozedur zréckgeet, ass e Ressourcewäert vum Typ 0x0.Currency.Coin
- plënneren (): Wäert kann net erëm benotzt ginn
- kopéieren (): Wäert ka méi spéit benotzt ginn
Parse de Code: am éischte Schrëtt rifft de Sender eng Prozedur mam Numm zréckzéien_vun_sender vun engem Modul gespäichert an 0x0.Währung. Am zweete Schrëtt transferéiert de Sender Fongen un den Empfänger andeems de Mënzenressourcewäert an d'Depositiounsprozedur vum Modul beweegt. 0x0.Währung.
Hei sinn dräi Beispiller vu Feeler am Code, déi duerch Schecken verworf ginn:
Duplizéiert Fongen andeems Dir den Uruff ännert bewegen (Mënz) op Kopie (Mënz). Ressourcen kënnen nëmme geréckelt ginn. Probéiert eng Quantitéit vun enger Ressource ze duplizéieren (zum Beispill andeems Dir rufft Kopie (Mënz) am Beispill hei uewen) féiert zu engem Feeler beim Iwwerpréiwung vum Bytecode.
Reuse vu Fongen andeems Dir spezifizéiert bewegen (Mënz) zweemol . Dobäizemaachen eng Linn 0x0.Currency.deposit (Kopie (some_other_payee), réckelen (Mënz)) zum Beispill, déi uewendriwwer erlaabt dem Sender d'Mënzen zweemol ze "verbréngen" - déi éischt Kéier mam Bezueler, an déi zweet mat some_other_payee. Dëst ass en ongewollt Verhalen dat net méiglech ass mat engem kierperleche Verméigen. Glécklecherweis wäert Move dëse Programm refuséieren.
Verloscht vu Fongen wéinst Refus bewegen (Mënz). Wann Dir d'Ressource net réckelt (zum Beispill andeems Dir d'Linn läscht mat bewegen (Mënz)), gëtt e Bytecode Verifizéierungsfehler geworf. Dëst schützt Move Programméierer aus zoufälleg oder béiswëlleg Verloscht vu Fongen.
Währung Modul
All Kont kann 0 oder méi Moduler enthalen (als Rechtecker ugewisen) an een oder méi Ressourcewäerter (als Zylinder ugewisen). Zum Beispill, e Kont op 0x0 enthält Modul 0x0.Währung an de Wäert vun der Ressource Typ 0x0.Currency.Coin. Kont op Adress 0x1 huet zwee Ressourcen an ee Modul; Kont op Adress 0x2 huet zwee Moduler an eng Ressource Wäert.
Nekotory Momenter:
- D'Transaktiounsskript ass atomar - entweder et gëtt komplett ausgefouert oder guer net.
- E Modul ass e laangliewegt Stéck Code dee weltwäit zougänglech ass.
- De globale Staat ass als Hash-Tabelle strukturéiert, wou de Schlëssel d'Kontoadress ass
- Konte kënnen net méi wéi ee Ressourcewäert vun engem bestëmmten Typ enthalen an net méi wéi ee Modul mat engem bestëmmten Numm (Kont op 0x0 kann net eng zousätzlech Ressource enthalen 0x0.Currency.Coin oder engem anere Modul genannt Währung)
- D'Adress vum deklaréierte Modul ass Deel vum Typ (0x0.Currency.Coin и 0x1.Currency.Coin sinn separat Typen déi net austauschbar benotzt kënne ginn)
- Programméierer kënne verschidde Instanzen vun dëser Zort Ressource an engem Kont späicheren andeems se hir personaliséiert Ressource definéieren - (Ressource TwoCoins {c1: 0x0.Currency.Coin, c2: 0x0.Currency.Coin})
- Dir kënnt op eng Ressource mam Numm ouni Konflikter bezeechnen, zum Beispill kënnt Dir op zwou Ressourcen verweisen TwoCoins.c1 и TwoCoins.c2.
Mënz Ressource Deklaratioun
Modul genannt Währung an eng Ressource Typ genannt Coin
Nekotory Momenter:
- Coin ass eng Struktur mat engem Feld vun Typ u64 (64-Bit net ënnerschriwwen ganz Zuel)
- Modul Prozeduren nëmmen Währung kënne Wäerter vun Typ erstellen oder zerstéieren Coin.
- Aner Moduler a Skripte kënnen nëmmen d'Wäertfeld duerch ëffentlech Prozedure vum Modul schreiwen oder referenzéieren.
Verkaf vun Depot
Dës Prozedur acceptéiert eng Ressource Coin als Input a kombinéiert et mat der Ressource Coinam Kont vum Empfänger gespäichert:
- Zerstéiert d'Input Ressource Coin an enregistréiert säi Wäert.
- Kritt e Link op eng eenzegaarteg Coin Ressource am Kont vum Empfänger gespäichert.
- Änneren de Wäert vun der Unzuel vun de Mënzen duerch de Wäert, deen am Parameter passéiert ass, wann d'Prozedur urufft.
Nekotory Momenter:
- Auspacken, BorrowGlobal - gebaut-an Prozeduren
- Auspacken Dëst ass deen eenzege Wee fir eng Ressource vum Typ T ze läschen. D'Prozedur hëlt eng Ressource als Input, zerstéiert se a bréngt de Wäert zréck, dee mat de Felder vun der Ressource ass.
- BorrowGlobal hëlt eng Adress als Input a gëtt eng Referenz op eng eenzegaarteg Instanz vun T publizéiert (Besëtz) vun dëser Adress
- & mut Mënz dëst ass e Link op d'Ressource Coin
Ëmsetzung vun withdraw_from_sender
Dës Prozedur:
- Kritt e Link op eng eenzegaarteg Ressource Coin, verbonne mam Kont vum Sender
- Reduzéiert de Wäert vun enger Ressource Coin iwwer de Link fir de spezifizéierte Betrag
- Erstellt a bréngt eng nei Ressource zréck Coin mat aktualiséiert Gläichgewiicht.
Nekotory Momenter:
- Depot kann duerch jiddereen verursaacht ginn, mä zréckzéien_vun_sender huet nëmmen Zougang zu de Mënzen vun der Opruff Kont
- GetTxnSenderAddress ähnlech wéi msg.sender an der Soliditéit
- OfleenenAusser ähnlech wéi verlaangen an der Soliditéit. Wann dës Scheck feelt, gëtt d'Transaktioun gestoppt an all Ännerungen ginn zréckgezunn.
- Pak et ass och eng agebaute Prozedur déi eng nei Ressource vum Typ T erstellt.
- Sou wéi Auspacken, Pak kann nëmmen am Modul genannt ginn, wou d'Ressource beschriwwen ass T
Konklusioun
Mir hunn d'Haaptcharakteristike vun der Move Sprooch iwwerpréift, et mat Ethereum verglach, an och mat der Basissyntax vu Skripte vertraut. Schlussendlech, ech recommandéieren Iech z'iwwerpréiwen . Et enthält vill Detailer iwwer Programméierungssprooch Designprinzipien, souwéi vill nëtzlech Linken.
Source: will.com