Contractes intel·ligents del futur? Vyper i Plutus

Com a desenvolupador, una cosa que hauríeu de tenir en compte és la importància d’una educació constant. El món de la criptomoneda i la cadena de blocs es troba en un estat de moviment constant. La norma de fa un any podria ser completament irrellevant d’aquí a uns mesos. Per tant, amb l’esperit d’aquest canvi constant, us farem una idea de com seran els contractes i el codi intel·ligents de Vyper i Plutus. Ethereum planeja utilitzar Vyper per als seus futurs contractes, mentre que Cardano ha escollit Plutus com a llenguatge de programació de contractes intel·ligents.

Contractes intel·ligents del futur? Vyper i Plutus

La solidesa és el llenguatge de contracte intel·ligent elegit per Ethereum ara mateix. Solidity va ser desenvolupat per Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai i diversos antics col·laboradors bàsics d’Ethereum per permetre escriure contractes intel·ligents en plataformes blockchain com Ethereum.

Ha estat influït per molts programes i conceptes de programació populars. Té elements de programació orientada a objectes, desenvolupament web, llenguatge assemblador, etc. i cobreix una àmplia gamma de casos d’ús. malgrat això, auditoria els contractes de solidesa poden ser realment difícils, ja que poden ser extremadament permisius i complicats.

Vyper és un llenguatge basat en Python que es crea únicament per facilitar la llegibilitat i la simplicitat. Atès que Python és un dels llenguatges de programació més fàcilment entesos i àmpliament utilitzats, s’espera que persones no tècniques puguin saltar i començar a codificar els seus propis contractes intel·ligents. Vyper s’ha desenvolupat com un llenguatge minimalista i senzill que se centra en casos d’ús trivials (per exemple, no es pot utilitzar per codificar un Dapp complex) i no és tan flexible com la solidesa.

Així, tot i que pot frenar una mica la flexibilitat del contracte, sí proporciona un més

“Un règim senzill, pragmàtic i fàcilment auditable per llegir i escriure contractes intel·ligents, que intenta captar clarament la intenció de qui escriu el codi”.

Sembla que Ethereum i Ethereum Classic fanals estan completament darrere de Vyper per dos motius principals:

  • La implementació de sharding d’Ethereum i Casper FFG s’han codificat a Vyper.
  • Ethereum Commonwealth, que manté i desenvolupa Ethereum Classic, també ha declarat que volen adoptar Vyper com a llenguatge de contractes intel·ligents per defecte.

L’enfocament minimalista de Vyper elimina l’herència, les trucades recursives dels modificadors d’estat i la sobrecàrrega de l’operador que dóna pas als atacs vectorials límit de gas. A més, també té un munt de controls de desbordament per a grans operacions aritmètiques. A causa del seu enfocament, Vyper no només és eficient en recursos, sinó que també és difícil escriure codi maliciós sense que es vegi durant l’auditoria..

Vyper Smart Contract

Vegem un contracte intel·ligent de Vyper per cortesia CoinPupil. Es tracta d’un contracte ERC-20 senzill i directe.

# Esdeveniments

Transferència: esdeveniment ({_ de: indexat (adreça), _to: indexat (adreça), _valor: uint256})

Aprovació: esdeveniment ({_ propietari: indexat (adreça), _spender: indexat (adreça), _valor: uint256})

(…)

# Variables d’estat

nom: públic (bytes32)

símbol: públic (bytes32)

totalSupport: públic (uint256)

decimals: públic (int128)

saldos: int128 [adreça]

permès: int128 [adreça] [adreça]

(…)

# Funció constructora / Instanciació del contracte

@public

def __init __ (_ nom: bytes32, _symbol: bytes32, _decimals: uint256, _initialSupply: uint256):

self.name = _nom

self.symbol = _símbol

self.decimals = _decimals

self.totalSupply = _initialSupply * convert (10, ‘uint256’) ** _decimals

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

(…)

# Saldo del compte

@public

@constant

def balanceOf (_owner: address) -> uint256:

(…)

retorn de conversió (self.balances [_owner], ‘uint256’)

(…)

# Envia _cantitat de fitxes _adreça

@public

transferència def (_to: address, _amount: int128 (uint256)) -> bool:

(…)

si self.balances [msg.sender] >= _import i

autoequilibris [_to] + _cantitat >= autoequilibris [_to]:

self.balances [msg.sender] – = _amount # Resta del remitent

self.balances [_to] + = _amount # Afegiu el mateix al destinatari

tornar True

en cas contrari:

tornar Fals

(…)

# Transferència de fitxes permeses

@public

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

(…)

si _valor <= self.allowed [_from] [msg.sender] i

_valor <= autoequilibris [_de]:

(…)

self.balances [_from] – = _value # disminueix el saldo de l’adreça.

self.allowed [_from] [msg.sender] – = _valor # disminució assignació.

self.balances [_to] + = _value # incease balance of to address.

(…)

tornar True

en cas contrari:

tornar Fals

(…)

# Permetre que _spender es retiri del compte fins a la quantitat de _valor.

@public

aprovar def (_spender: address, _amount: int128 (uint256)) -> bool:

(…)

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

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

(…)

tornar True

(…)

# Obteniu el permís d’una adreça

@public

bonificació per defecte (_ propietari: adreça, _spender: adreça) -> uint256:

retorn de conversió (self.allowed [_owner] [_ spender], ‘uint256’)

En aquest contracte:

  • El mètode “self” s’utilitza per mostrar les variables d’instància de la seva classe a efectes d’aclariment.
  • @public i @private s’utilitzen per configurar la visibilitat i l’exposició dels contractes La interfície ABI (Application Binary Interface) que permet als agents externs (altres contractes o adreces de cartera) trucar-la.

Plutus

Cardano ha escollit Haskell i Plutus com a llengües preferides. Haskell s’utilitzarà per codificar Cardano, mentre que Plutus s’utilitzarà per a la creació de contractes intel·ligents. Tots dos són llenguatges funcionals.

Què volem dir amb això??

Les dues famílies d’idiomes (un petit desviament)

Quan es tracta de llenguatges de programació, hi ha dues famílies:

  • Imperatiu
  • Funcional.

Llenguatges de programació imperatius

En un enfocament imperatiu, el programador ha de deixar tots els passos que ha de fer l’ordinador per assolir un objectiu. Tots els nostres llenguatges de programació tradicionals com C ++, Java i fins i tot Solidity són llenguatges de programació imperatius. Aquest tipus d’enfocament de programació també s’anomena programació algorítmica.

Prenguem un exemple del que volem dir amb això. Vegem C ++. Suposem que volem afegir 5 i 3.

int a = 5;

int b = 3;

int c;

c = a + b;

Per tant, com podeu veure, el procés d’addició pren diversos passos i cada pas canvia constantment l’estat del programa, ja que tots s’executen al seu torn individualment..

Un procés d’addició va durar quatre passos i els passos són els següents:

  • Declarar un enter a i assignar-li el valor 5.
  • Declarar un enter b i assignar-li el valor 3.
  • Declarar un enter c.
  • Afegint els valors de ib i emmagatzemant-los a c.

Llenguatges de programació funcionals

La segona família de llenguatges de programació són els llenguatges funcionals. Aquest estil de programació es va crear per construir un enfocament funcional per a la resolució de problemes. Aquest tipus d’enfocament s’anomena programació declarativa.

Com funciona la programació funcional?

Suposem que hi ha una funció f (x) que volem utilitzar per calcular una funció g (x) i després la volem utilitzar per treballar amb una funció h (x). En lloc de resoldre tots els que apareixen en una seqüència, simplement podem unir-los tots en una sola funció com aquesta:

h (g (f (x)))

Això fa que l’enfocament funcional sigui més fàcil de raonar matemàticament. És per això que se suposa que els programes funcionals són un enfocament més segur per a la creació de contractes intel·ligents. Això també facilita la verificació formal més senzilla, cosa que significa pràcticament que és més fàcil demostrar matemàticament què fa i com actua un programa. Això dóna a Cardano la seva propietat del “Codi d’alta garantia”.

És precisament per això que l’enfocament funcional és tan desitjable.

I això és exactament el que Cardano utilitza Haskell per codificar el seu ecosistema i Plutus per als seus contractes intel·ligents. Tant Haskell com Plutus són llenguatges funcionals.

Tornar a Plutus

Plutus és una versió simplificada i superior de Haskell. Això significa que, com Haskell, té més similituds amb les matemàtiques que amb la programació. Plutus ho és previst per a ús de

“Institucions financeres, llocs que fan comerç electrònic i altres operacions financeres d’aquest tipus amb diners en joc”.

Per tant, fem una ullada a la programació bàsica de Plutus. S’ha extret el següent codi Documents de Cardano.

Aquest senzill programa Plutus mostra suma, multiplicació, factorial i Fibonacci:

afegir: Nat -> Nat -> Nat {

afegir zero n = n;

afegir (Suc m) n = Suc (afegir m n)

}

mul: Nat -> Nat -> Nat {

mul Zero _ = Zero;

mul (Suc m) n = afegir (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)) = afegir (fib n) (fib (Suc n))

}

Podeu veure al propi codi les diferències entre un enfocament funcional i un enfocament imperatiu.

Conclusió

El món en constant canvi de criptografia i cadena de blocs vol dir que hem d’estar sempre a l’alçada. Tenir coneixement d’aquests nous llenguatges de programació és absolutament fonamental per a tots els caçadors de recompenses i desenvolupadors.

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me
Like this post? Please share to your friends:
map