Framtidens smarta kontrakt? Vyper och Plutus

Som utvecklare är en sak som du bör inse vikten av ständig utbildning. Världen med kryptovaluta och blockchain är i ett konstant tillstånd av rörelse. Normen för ett år sedan kan vara helt irrelevanta månader framöver. Så, i den anda av denna ständiga förändring, kommer vi att ge dig en uppfattning om hur Vyper och Plutus smarta kontrakt och kod kommer att se ut. Ethereum planerar att använda Vyper för sina framtida kontrakt, medan Cardano har valt Plutus som sitt val av smarta programmeringsspråk för kontrakt.

Framtidens smarta kontrakt? Vyper och Plutus

Soliditet är det smarta kontraktsspråket som valts för Ethereum just nu. Solidity utvecklades av Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai och flera tidigare Ethereum-kärnbidragare för att möjliggöra att skriva smarta kontrakt på blockchain-plattformar som Ethereum.

Det har påverkats av många populära program och programmeringskoncept. Den har inslag av objektorienterad programmering, webbutveckling, monteringsspråk etc. och täcker ett brett spektrum av användningsfall. i alla fall, granskning soliditetskontrakt kan vara riktigt svåra eftersom de kan vara extremt tillåtna och komplicerade.

Vyper är ett Python-baserat språk som enbart är byggt för läsbarhet och enkelhet. Eftersom python i sig är ett av de mest lättförståeliga och mest använda programmeringsspråken, hoppas man att icke-tekniska personer kommer att kunna hoppa på och börja koda sina egna smarta kontrakt. Vyper har utvecklats som ett minimalistiskt, enkelt språk som fokuserar på triviala användningsfall (t.ex. att det inte kan användas för att koda en komplex Dapp) och inte är så flexibel som soliditet.

Så även om det kan begränsa kontraktets flexibilitet något ger en mer

”Ett enkelt, pragmatiskt och lätt granskbart system för läsning och skrivning av smarta kontrakt, som försöker tydligt fånga avsikten hos den som skriver koden.”

Det ser ut som Ethereum och Ethereum Classic bigwigs är helt bakom Vyper av två huvudskäl:

  • Ethereums skärningsimplementering och Casper FFG har kodats i Vyper.

  • Ethereum Commonwealth som underhåller och utvecklar Ethereum Classic har också uttalat att de vill använda Vyper som ett standardspråk för smarta kontrakt.

Vypers minimalistiska tillvägagångssätt avskaffar arv, tillståndsmodifierare rekursivt samtal och operatörsöverbelastning vilket ger plats för gasbegränsande vektorattacker. Dessutom har den också massor av överflödskontroller för stora aritmetiska operationer. På grund av sitt tillvägagångssätt är inte bara Vyper-resurseffektiv, det är också svårt att skriva skadlig kod utan att den upptäcks under granskningen.

Vyper Smart Contract

Låt oss titta på ett smart Vyper-avtal med tillstånd CoinPupil. Detta är ett enkelt och enkelt ERC-20-kontrakt.

# Evenemang

Överföring: händelse ({_ från: indexerad (adress), _ till: indexerad (adress), _värde: uint256})

Godkännande: händelse ({_ ägare: indexerad (adress), _spender: indexerad (adress), _värde: uint256})

# Statliga variabler

namn: public (bytes32)

symbol: offentlig (bytes32)

totalSupply: public (uint256)

decimaler: offentlig (int128)

saldon: int128 [adress]

tillåtet: int128 [adress] [adress]

# Konstruktörsfunktion / Instantiering av kontrakt

@offentlig

def __init __ (_ namn: bytes32, _symbol: bytes32, _decimaler: uint256, _initialSupply: uint256):

självnamn = _namn

self.symbol = _symbol

self.decimals = _decimals

self.totalSupply = _initialSupply * konvertera (10, ‘uint256’) ** _decimaler

self.balances [msg.sender] = konvertera (self.totalSupply, ‘int128’)

# Kontobalans

@offentlig

@konstant

def balanceOf (_ägare: adress) -> uint256:

return convert (self.balances [_owner], ‘uint256’)

# Skicka _mängden tokens _ till adressen

@offentlig

def överföring (_ till: adress, _belopp: int128 (uint256)) -> bool:

om self.balances [msg.sender] >= _belopp och

självbalanser [_to] + _belopp >= självbalanser [_to]:

self.balances [msg.sender] – = _belopp # Subtrahera från avsändaren

self.balances [_to] + = _belopp # Lägg till samma till mottagaren

återvänd True

annan:

returnera Falskt

# Överföring av tillåtna tokens

@offentlig

def transferFrom (_from: address, _to: address, _value: int128 (uint256)) -> bool:

om _värde <= self.allowed [_from] [msg.sender] och

_värde <= självbalanser [_from]:

self.balances [_from] – = _value # minskar saldot från adressen.

self.allowed [_from] [msg.sender] – = _värde # minskningstillägg.

self.balances [_to] + = _värde # incease balance of to address.

återvänd True

annan:

returnera Falskt

# Tillåt _spender att ta ut från kontot upp till _värdesbeloppet.

@offentlig

def godkänna (_spender: adress, _belopp: int128 (uint256)) -> bool:

self.allowed [msg.sender] [_ spender] = _belopp

log.Approval (msg.sender, _spender, convert (_amount, ‘uint256’))

återvänd True

# Få ersättning för en adress

@offentlig

def-tillägg (_ägare: adress, _ utgivare: adress) -> uint256:

return convert (self.allowed [_owner] [_ spender], ‘uint256’)

I detta kontrakt:

  • Metoden ”själv” används för att visa förekomstvariablerna i sin klass för förtydligande.

  • @public och @private används för att ställa in synligheten och exponeringen för kontrakts-ABI-gränssnittet (Application Binary Interface) som gör det möjligt för externa aktörer (andra kontrakt eller plånboksadresser) att kalla det.

Plutus

Cardano har valt Haskell och Plutus som sina språk. Haskell kommer att användas för att koda Cardano, medan Plutus kommer att användas för att skapa smarta kontrakt. Båda är funktionella språk.

Vad menar vi med det?

De två språkfamiljerna (en liten omväg)

När det gäller programmeringsspråk finns det två familjer:

  • Nödvändigt
  • Funktionell.

Imperativa programmeringsspråk

I ett tvingande tillvägagångssätt måste kodaren lägga ner alla steg som datorn behöver ta för att nå ett mål. Alla våra traditionella programmeringsspråk som C ++, Java och även Solidity är tvingande programmeringsspråk. Denna typ av programmeringsmetod kallas också algoritmisk programmering.

Låt oss ta ett exempel på vad vi menar med det. Låt oss titta på C ++. Antag att vi vill lägga till 5 och 3.

int a = 5;

int b = 3;

int c;

c = a + b;

Så som du kan se tar tilläggsprocessen över flera steg och varje steg ändrar ständigt programmets tillstånd eftersom de alla körs i tur och ordning individuellt.

En tilläggsprocess tog fyra steg och stegen är:

  • Deklarerar ett heltal a och tilldelar värdet 5 till det.

  • Deklarerar ett heltal b och tilldelar värdet 3 till det.

  • Deklarera ett heltal c.

  • Lägga till värdena för och b och lagra dem i c.

Funktionella programmeringsspråk

Den andra familjen av programmeringsspråk är funktionella språk. Denna typ av programmering skapades för att bygga ett funktionellt tillvägagångssätt för problemlösning. Denna typ av strategi kallas deklarativ programmering.

Så hur fungerar funktionell programmering?

Antag att det finns en funktion f (x) som vi vill använda för att beräkna en funktion g (x) och sedan vill vi använda den för att arbeta med en funktion h (x). Istället för att lösa alla dessa i en sekvens kan vi helt enkelt klubba dem alla i en enda funktion så här:

h (g (f (x)))

Detta gör det funktionella tillvägagångssättet lättare att resonera matematiskt. Det är därför som funktionella program ska vara ett säkrare tillvägagångssätt för att skapa smarta kontrakt. Detta hjälper också till enklare formell verifiering vilket i stort sett betyder att det är lättare att matematiskt bevisa vad ett program gör och hur det fungerar. Detta ger Cardano egenskapen “High Assurance Code”.

Det är just därför det funktionella tillvägagångssättet är så önskvärt.

Och det är precis vad Cardano använder Haskell för att koda sitt ekosystem och Plutus för sina smarta kontrakt. Både Haskell och Plutus är funktionella språk.

Tillbaka till Plutus

Plutus är en högre och enklare version av Haskell. Det betyder att det som Haskell har fler likheter med matematik snarare än programmering. Plutus är avsedd för användning av

“Finansinstitut, platser som gör elektronisk handel och andra sådana finansiella transaktioner med pengar på spel.”

Så, låt oss ta en titt på grundläggande Plutus-programmering. Följande kod har tagits från Cardano dokumenterar.

Detta enkla Plutus-program visar addition, multiplikation, faktoria och Fibonacci:

lägg till: Nat -> Nat -> Nat {

lägg till noll n = n;

lägg till (Suc m) n = Suc (lägg till m n)

}

mul: Nat -> Nat -> Nat {

mul Noll _ = Noll;

mul (Suc m) n = lägg till (mul m n) n

}

fac: Nat -> Nat {

fac Zero = Suc Zero;

fac (Suc n) = mul (Suc n) (fac n)

}

fib: Nat -> Nat {

fib Zero = Suc Zero;

fib (Suc Zero) = Suc Zero;

fib (Suc (Suc n)) = add (fib n) (fib (Suc n))

}

Du kan se i själva koden skillnaderna mellan ett funktionellt tillvägagångssätt och ett tvingande tillvägagångssätt.

Slutsats

Den ständigt föränderliga världen av krypto och blockchain betyder att vi ständigt måste vara på tårna. Att ha kunskap om dessa nya programmeringsspråk är helt avgörande för alla bountyjägare och utvecklare.

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