Forstå Vyper: Det glatte New Ethereum-språket

En omfattende guide om Vyper, det glatte nye Ethereum-språket

Vyper er et generelt, eksperimentelt programmeringsspråk som kompileres ned til EVM (Ethereum Virtual Machine) bytekode, det samme gjør Soliditet. Imidlertid er Vyper designet for å forenkle prosessen massivt for å skape lettere forståelige smarte kontrakter som er mer gjennomsiktige for alle involverte parter, og som har færre inngangspunkter for et angrep..

Enhver kode som er målrettet mot EVM, må være hypereffektiv for å minimere gassen som trengs for at smarte kontrakter skal utføres, ettersom en kontrakt med ineffektiv kode bokstavelig talt koster mer eter å utføre, og kan fort bli uoverkommelig dyr, spesielt i brukstilfeller som mikro- transaksjoner. Sluttresultatet er at Vyper ser logisk ut som Solidity, og syntaktisk lik Python, men uten mange av de objektorienterte programmeringsparadigmene – kanskje krever en ny paradigmedefinisjon for transaksjonell programmering.

Å lære disse logiske og syntaktiske forskjellene nå, vil hjelpe deg med å bli en Vyper-utvikler i verdensklasse, siden Vyper fremdeles er i v0.1.0-beta.1 fra juni 2018!

Forstå Vyper

0. Sammenligning av Python, Vyper og Solidity

Her dekker vi det høye “hvorfor” av Vyper – noe som gir oss et springpunkt for å analysere og skrive Vyper-kode, inkludert Smart Contracts.

Nøkkelforbedring 1: Enkelhet

Vyper inneholder ikke mange av de konstruksjonene som er kjent for de fleste programmerere: Klassearv, funksjonsoverbelastning, operatøroverbelastning og rekursjon. Ingen av disse er teknisk nødvendige for et Turing-komplett språk, og de representerer sikkerhetsrisiko ved å øke kompleksiteten. På grunn av denne kompleksiteten vil disse konstruksjonene gjøre smarte kontrakter for vanskelige å forstå og overvåke av en lekmann, sett i soliditetskontrakter.

Mindre vanlige konstruksjoner som heller ikke er inkludert er modifikatorer (disse gjør det for enkelt å skrive misvisende kode), innebygd montering (dette bryter Ctrl + F) og binært fast punkt (tilnærminger er ofte nødvendig med et binært fast punkt).

Nøkkelforbedring 2: Sikkerhet

Med ordene fra Vyper-utviklerne selv, Vyper

“Vil bevisst forby ting eller gjøre ting vanskeligere hvis det finner det hensiktsmessig å gjøre det for å øke sikkerheten.”

Derfor er Vyper ikke en fullstendig erstatning for Solidity, men snarere et flott språk å bruke der sikkerhet er viktigst, for eksempel for smarte kontrakter som håndterer pasientens helsemetadata eller modellgradienter for desentralisert AI.; Pp0

Vyper-kode og syntaktiske forskjeller

Vyper ble bygget for å være så lik Python som mulig mens vi strever etter målene for sikkerhet og enkelhet, så den generelle følelsen av språkene er den samme, selv om det er mange forskjeller å merke seg.

Utføre en fil

Mens et Python-skript blir utført som

python file_name.py

, et vyper-skript er kompilert ved hjelp av

vyper filnavn.vy.

Statlige variabler

Statlige variabler er verdier som er permanent lagret i kontraktlagring og kan være av hvilken som helst type, for eksempel:

eksempelStatVariabelt: int256.

Kartlegging

Det første en Vyper-kontrakt inneholder, er lagringsfeltene for kontrakten, for eksempel en tokenbalansekartlegging:

saldo: offentlig (wei_value [adresse])

som er en tilstandsvariabel som definerer nøkler og tilsvarende verdier.

Vyper-kartlegginger er i utgangspunktet hash-tabeller som er initialisert, som vist ovenfor, slik at

“Alle mulige nøkler eksisterer og tilordnes til en verdi hvis byte-representasjon er alle nuller: standardverdien til en type.”

Nøkkeldataene lagres ikke i kartleggingen, men bare keccak256-hash for å slå opp verdien.

Ved å definere balanse, typen offentlig () er gitt, etterfulgt av kartleggingssyntaks: Hvor verditype av wei_value blir gitt først, etterfulgt av nøkkel (adresse) i parentes – ligner på Pythons håndtering av arrays.

Definisjoner

Du vil merke at Vyper bruker et kolon for å definere navn (som balanse) i motsetning til Pythons likhetstegn, selv om Python 3.6 inkluderer den samme syntaksen for variabel kommentar:

kontekst = {} # tom ordbokssammenheng ["en"]: 2 # kommentere ordbokvariabelen

Hvor kolon-syntaksen er for variabel kommentar, og kolon brukes som tildelingsoperator som bare tildeler en type kommentar. Vyper bruker denne syntaksen for tildeling av ekte verdi.

Heltallstyper

Vyper har bare to heltallstyper: uint256 (for ikke-negative heltall) og int128 (for signerte heltall) – i motsetning til Solidity’s uint8 til uint256 i trinn 8, og samme for int8 til int256 (dette betyr 64 forskjellige søkeord for int-typer).

Booleanere, operatører, sammenligninger og funksjoner

Vyper har nesten identisk syntaks med Python for de fleste operatører, inkludert:

sanne og falske boolere; ikke, og, eller, ==, og! = operatorer; <, <=, ==,! =, >=, og > sammenligninger; og +, -, *, /, ** og% aritmetiske operatorer (bare for int128)

I tillegg til noen lignende innebygde funksjoner:

len (x) for å returnere lengden på en int; etasje (x) for å runde en desimal ned til nærmeste int; og ceil (x) for å avrunde en desimal opp til nærmeste int

Og noen nye:

sha3 (x) for å returnere sha3-hash som byte 32; concat (x, …) for å sammenkoble flere innganger; snitt (x, start = _start, len = _len) for å returnere stykke _len som starter ved _start

Lister

Lister i Vyper er erklært ved hjelp av formatet _navn: _ValueType [_Integer], mens verdiene og returuttalelsene settes, har den samme syntaksen som Py = thon.

For eksempel:

lst: int128 [3] # definer en liste lst = [1, 2, 3] # sett verdiene lst [2] = 5 # sett en verdi etter indeksretur lst [0] # returnerer 1

Structs

Structs er typer som du definerer, hvilke gruppevariabler og som du får tilgang til ved hjelp av struct.argname (som ligner på Python-ordbøker):

struct: {# definer strukturen

arg1: int128, arg2: desimal

} struct.arg1 = 1 #access arg1 i struct

Definere metoder

Metoder (kontraktsmetoder i Vyper) er definert på samme måte i Python og Vyper:

def metode ():

gjør noe()

I tillegg til hva Python gir, inkluderer Vyper etereumspesifikke dekoratører som f.eks @payable og @assert – førstnevnte brukes til å gjøre kontrakten i stand til å ta transaksjoner og sistnevnte tar et boolsk uttrykk:

Legg merke til def funksjonsnavn (arg1, arg2,…, argx) -> utgang: syntaks for å definere en funksjon. I motsetning til i Python definerer Vyper eksplisitt utgangstypen i def-linjen etter ->.

Konstruktorfunksjoner

Konstruktorfunksjoner går etter samme konvensjon som Python og instanserer en gitt kontrakt og parametere på blockchain. Init initialiserer programmet og kjøres bare én gang. For eksempel:

@public def __init __ (_ name: bytes32, _decimals: uint256, _initialSupply: uint256):

self.name = _name self.decimals = _decimals self.totalSupply = uint256_mul (_initialSupply, uint256_exp (convert (5, ‘uint256’), _decimals))

Som i Python blir selv brukt til å hevde forekomstvariabler. Ovennevnte funksjon er dekorert med @offentlig dekoratør å gi den offentlig synlighet og la eksterne enheter ringe den (i motsetning til standard – eller utelate dekoratøren – som er privat).

Dekoratøren @konstant brukes til å dekorere metoder som bare leser en tilstand, mens @som skal betales gjør det mulig å ringe hvilken som helst metode med en betaling.

arrangementer

Du kan logge hendelser ved hjelp av __Logg__ i indekserte strukturer, slik:

betaling: __log __ ({beløp: uint256, param2: indeksert (adresse)}) tot_payment: uint256 @public def pay ():

self.tot_payment + = msg.value log.payment (msg.value, msg.sender)

Skrive Vyper-kontrakter

La oss nå skrive et par enkle smarte kontrakter. Følgende kodebit tillater kontrakten å motta et NFT (ikke-fungibelt token) og kunne sende mot det tokenet.

@public def safeTransferFrom (_from: adresse, _til: adresse, _tokenId: uint256):

self._validateTransferFrom (_from, _to, _tokenId, msg.sender) self._doTransfer (_from, _to, _tokenId) if (_to.codesize > 0):

returnValue: bytes [4] = raw_call (_to, ‘xf0xb9xe5xba’, outsize = 4, gas = msg.gas)

hevde returnValue == ‘xf0xb9xe5xba’

Følgende demonstrerer @offentlig dekoratør, definere en funksjon med en enkelt parameter som eksplisitt er gitt en type, og et enkelt kodeorgan som bruker påstandssetninger for å verifisere om en bruker har stemmerett som en del av et “voting with delegation” program:

# Gi en velger rett til å stemme på denne stemmeseddelen # Dette kan bare kalles av formannen @public def give_right_to_vote (voter: address):

hevder msg.sender == self.chairperson # kast hvis avsenderen ikke er leder hevder ikke self.voters [velgeren] .stemte # kast hvis velgeren allerede har stemt hevder self.voters [velgeren.. vekt == 0 # kast hvis velgerens stemmer vekten er ikke 0

self.voters [voter] .weight = 1 self.voter_count + = 1

Etter å ha diskutert de syntaktiske og logiske skillene, er koden ikke altfor skremmende. vyper.online tilbyr hele kildekoden for “voting with delegation” -programmet, ved hjelp av strukturer for velgere og forslag, og følgende passende navngitte funksjoner:

def delegert (addr: adresse) -> bool def direkte_stemte (addr: adresse) -> bool def __init __ (_ forslagNavn: bytes32 [2]) def give_right_to_vote (voter: address) def forward_weight (delegate_with_weight_to_forward: address) def delegate (to: address) def vote (forslag: int128) def winning_proposal () -> int128 def vinnernavn () -> bytes32

Som med ethvert programmeringsspråk, gjør planlegging av hovedkonstruksjonene (i dette tilfellet funksjonskontrakter) på forhånd programmeringen mye lettere. Den største forskjellen i Vyper å huske på er mangelen på OOP-paradigmer. I den nåværende utviklingsfasen kan du ennå ikke ringe eksterne koder.

Hensynet til å tillate eksterne kodesamtaler kan sees i følgende utviklingsforslag:

# Ekstern kontrakt A:

def foo (): konstant def bar (): modifisering # Denne kontraktkontrakten B: a: A def baz (): a.foo () a.bar ()

Der kontrakt B påkaller kontrakt A, inkludert metoder innen A, i det enkleste eksempelet mulig.

Kjører Vyper

For å følge med på å skrive kode, gå til vyper.online, og skriv kodeeksemplene under “Source Code” -fanen og klikk “Compile” når du er klar. Den mest brukte klienten (men i pre-alpha) for Vyper-implementering og testutførelse er Py-EVM, utviklet i utgangspunktet av Vitalik selv, som lar brukeren legge til opkoder eller endre eksisterende uten å endre kjernebiblioteket, noe som muliggjør langt større modularitet og utvidbarhet enn med en typisk klient.

For å få Py-EVM, bruk bare pip install py-evm == 0.2.0a16.

3a. Implementere Vyper-kontrakter

Mens Py-EVM for tiden er i pre-alfa og kan være vanskelig å komme i gang, er det to enklere alternativer for å distribuere Vyper-kontrakter til offentlige testnett (og en bonus):

1) Lim inn bytekoden generert fra vyper.online i Mist eller geth

2) Bruk myetherwallet kontraktsmeny for å distribuere i gjeldende nettleser 3) (Kommende)

I fremtiden vil Vyper integreres med populus, slik at du enkelt kan distribuere Vyper-kontrakter

For enkelhets skyld vil vi distribuere kontrakter ved hjelp av alternativ (1) og Mist (et nytt brukergrensesnitt på toppen av geth i motsetning til den terminalbaserte geth). Siden Vyper kompilerer til samme Bytecode som Solidity, trenger vi ingen Vyper-spesifikke klienter, og kan følge disse litt rundkjøringstrinnene:

  1. Gå til vyper.online og klikk “Kompilere” på den forhåndsutfylte stemmegivningen “Kildekode”
  2. Kopier alt under “Bytecode” -fanen
  3. Installer Mist for operativsystemet ditt, hvis du ikke allerede har gjort det
  4. Tillat noden å laste ned og synkronisere (dette skjer automatisk)
  5. Velg “BRUK TESTNETTVERKET” i Mist-oppsettet
  6. Lag et passord (og husk det …)
  7. Skriv inn kontrakten
  8. Velg “Kontrakter” i Mist-grensesnittet
  9. Velg “BRUK NY KONTRAKT”
  10. Gå til fanen “KONTRAKT BYTEKODE”
  11. Lim inn Bytecode du kopierte fra vyper.online

Distribuere kontrakten

  1. Velg “DEPLOY” og skriv inn passordet fra tidligere
  2. Bekreft at Vyper-kontrakten er distribuert
  3. Gå til “Lommebøker” -fanen i Mist
  4. Rull ned til “Siste transaksjoner”
  5. Du burde se kontrakten vi nettopp distribuerte!

*Selv om det er i tilstanden “Opprette kontrakt”, da den ikke utvinnes og valideres

Konklusjon

Denne guiden gir en logisk og syntaktisk introduksjon til Vyper, slik at vi kan begynne å programmere og distribuere kontrakter. Med kunnskapen fra denne veiledningen, bør du kunne bidra til utviklingen av Vyper, dens dokumentasjon, og fortsette å lære ved å kode på vyper.online.

Igjen, Vyper er ikke ment å erstatte Solidity, men da en studie fant over 34.000 sårbare kontrakter, er behovet for sterkere sikkerhet i dette rommet større enn noensinne, noe som gir Vyper en viktig fremtid i Ethereum

Videre lesing og veikart

Siden Vyper fremdeles er i eksperimentell utvikling, er den offisielle dokumentasjonen og GitHub de mest omfattende ressursene, med følgende verdi:

01.Vyper’s Community Gitter

02.Vyper verktøy og ressurser

03. “Ethereum Book ”-sider på Vyper

04.Studie: “Finne de grådige, fortapte og selvmordskontraktene i stor skala”

05.“Steg-for-trinn-guide: Komme i gang med Ethereum Mist Wallet”

07.Testing og distribusjon av Vyper-kontrakter

08. “Bygg din første smarte Ethereum-kontrakt med soliditet – veiledning ” [Å generalisere trinnene for å passe Vyper er ganske grei]

Vypers utviklingstrinn til versjon 1.0 fokuserer på grensesnitt (samt forbedringer i blant annet interne og eksterne samtaler), som definerer begrensninger slik at du kan kommunisere med ethvert objekt som implementerer det grensesnittet. Grensesnitt muliggjør alternative løsninger for oppgradering av smarte kontrakter, så de er ikke nødvendige for grunnleggende funksjoner, og du kan begynne å kode i Vyper selv om språket er ufullstendig.

Utviklingsplanen til versjon 1.0, hentet og redigert fra Vypers gitter:

01.To typer filer: grensesnitt (ett grensesnitt per fil) og kontrakter (en kontrakt

per fil).

02. Du kan definere et grensesnitt som ERC721Metadata i en grensesnittfil og også i

en kontraktsfil.

03. Grensesnittfilen er en-til-en fullt kompatibel med Ethereum ABI.

04. Skriv en oversetter fra Grensesnitt Solidity til Vyper.

05. Lag et bibliotek med alle de endelige ERC-grensesnittene, selv om du må lage det manuelt

dem.

06.Import grensesnitt fra grensesnittfilene til kontrakter.

07. Et grensesnitt er en type som dekorerer en adresse.

08. Grensesnitt kan arve andre grensesnitt.

09. Studer nøye grensesnitt-ID fra ERC-165 og reproduserer eksemplene gitt i

ERC-721 dette gjelder hvordan grensesnitt arver andre grensesnitt.

10. Grensesnitt kan ha valgfrie funksjoner. (Et brudd fra soliditet.)

11. Kontrakter kan implementere grensesnitt.

12. En kontrakt som implementerer et grensesnitt, men som ikke implementerer et påkrevd

funksjon er en FEIL.

13. En kontrakt som implementerer et grensesnitt, men som ikke implementerer et valgfritt

funksjonen er verken en FEIL eller en ADVARSEL.

14. Gi nytt navn til @public til @external for å matche soliditet.

15. Introdusere en ny funksjonsdekoratør @internal som gjør det mulig å ringe en funksjon

internt.

16. Gjeninnføre funksjonssamtalen som for øyeblikket brukes til eksterne samtaler (fjernet i

trinn 14), men har det anvendelse på interne samtaler.

17.Implementere eksterne samtaler som dette: Eksternt hoppeanropstabell -> LOADCALLDATA

pakke ut -> legg til funksjonsparametere for å stable -> ring intern funksjon -> gjør funksjon

ting.

18. Implementere interne samtaler som dette: legg til funksjonsparametere for å stable -> ring internt

funksjon -> gjør funksjonstingene.

Som du kan se fra koden vi har skrevet, gjør Vyper store fremskritt i utviklingen, og har bare noen få store oppdateringer (delt inn i de mindre trinnene ovenfor) til 1.0 er utgitt!

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me