Contrats intelligents du futur? Vyper et Plutus

En tant que développeur, une chose que vous devez réaliser est l’importance d’une éducation constante. Le monde de la crypto-monnaie et de la blockchain est en constante évolution. La norme il y a un an pourrait être complètement hors de propos dans quelques mois. Donc, dans l’esprit de ce changement constant, nous allons vous donner une idée de ce à quoi ressembleront les contrats intelligents et le code Vyper et Plutus. Ethereum prévoit d’utiliser Vyper pour ses futurs contrats, tandis que Cardano a choisi Plutus comme son choix de langage de programmation de contrat intelligent.

Contrats intelligents du futur? Vyper et Plutus

Solidity est le langage de contrat intelligent de choix pour Ethereum à partir de maintenant. Solidity a été développé par Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai et plusieurs anciens contributeurs principaux d’Ethereum pour permettre l’écriture de contrats intelligents sur des plates-formes blockchain telles qu’Ethereum..

Il a été influencé par de nombreux programmes et concepts de programmation populaires. Il contient des éléments de programmation orientée objet, de développement Web, de langage d’assemblage, etc. et couvre un large éventail de cas d’utilisation. pourtant, audit les contrats de solidité peuvent être très difficiles car ils peuvent être extrêmement permissifs et compliqués.

Vyper est un langage basé sur Python conçu uniquement pour la lisibilité et la simplicité. Étant donné que python lui-même est l’un des langages de programmation les plus faciles à comprendre et les plus utilisés, il est à espérer que les personnes non techniques pourront monter et commencer à coder leurs propres contrats intelligents. Vyper a été développé comme un langage minimaliste et simple qui se concentre sur des cas d’utilisation triviaux (par exemple, il ne peut pas être utilisé pour coder un Dapp complexe) et n’est pas aussi flexible que la solidité.

Ainsi, bien que cela puisse limiter quelque peu la flexibilité du contrat, il fournit un plus

«Un régime simple, pragmatique et facilement auditable pour la lecture et l’écriture de contrats intelligents, qui tente de saisir clairement l’intention de celui qui écrit le code.»

Il semble que les gros bonnets Ethereum et Ethereum Classic soient complètement derrière Vyper pour deux raisons principales:

  • L’implémentation de partitionnement d’Ethereum et Casper FFG ont été codés dans Vyper.

  • L’Ethereum Commonwealth qui maintient et développe Ethereum Classic a également déclaré vouloir adopter Vyper comme langage de contrat intelligent par défaut..

L’approche minimaliste de Vyper supprime l’héritage, les appels récursifs des modificateurs d’état et la surcharge de l’opérateur qui cède la place aux attaques vectorielles à limite de gaz. De plus, il dispose également de tonnes de contrôles de débordement pour les grandes opérations arithmétiques. En raison de son approche, non seulement Vyper est efficace en termes de ressources, mais il est également difficile d’écrire du code malveillant sans qu’il soit repéré lors de l’audit..

Contrat Vyper Smart

Jetons un coup d’œil à un contrat Vyper smart courtoisie CoinPupil. Il s’agit d’un contrat ERC-20 simple et direct.

# Événements

Transfert: événement ({_ de: indexé (adresse), _ vers: indexé (adresse), _valeur: uint256})

Approbation: événement ({_ propriétaire: indexé (adresse), _spender: indexé (adresse), _valeur: uint256})

# Variables d’état

nom: public (bytes32)

symbole: public (octets32)

totalSupply: public (uint256)

décimales: public (int128)

soldes: int128 [adresse]

autorisé: int128 [adresse] [adresse]

# Fonction constructeur / Instanciation de contrat

@Publique

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

self.name = _nom

self.symbol = _symbole

self.decimals = _decimals

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

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

# Solde du compte

@Publique

@constant

def balanceOf (_owner: adresse) -> uint256:

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

# Envoyer _amount de jetons _à l’adresse

@Publique

transfert def (_to: adresse, _amount: int128 (uint256)) -> booléen:

if self.balances [msg.sender] >= _amount et

self.balances [_to] + _amount >= self.balances [_to]:

self.balances [msg.sender] – = _amount # Soustraire de l’expéditeur

self.balances [_to] + = _amount # Ajouter la même chose au destinataire

retourne True

autre:

retourne False

# Transfert de jetons autorisés

@Publique

def transferFrom (_from: adresse, _to: adresse, _valeur: int128 (uint256)) -> booléen:

si _valeur <= self.allowed [_from] [msg.sender] et

_évaluer <= self.balances [_from]:

self.balances [_from] – = _value # diminution du solde de l’adresse de départ.

self.allowed [_from] [msg.sender] – = _value # diminution de l’allocation.

self.balances [_to] + = _value # augmenter le solde de l’adresse à.

retourne True

autre:

retourne False

# Autoriser _spender à retirer du compte jusqu’à concurrence du montant _value.

@Publique

def approuver (_spender: adresse, _amount: int128 (uint256)) -> booléen:

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

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

retourne True

# Obtenez l’allocation d’une adresse

@Publique

allocation def (_owner: adresse, _spender: adresse) -> uint256:

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

Dans ce contrat:

  • La méthode «self» est utilisée pour afficher les variables d’instance de sa classe à des fins de clarification.

  • @public et @private permettent de paramétrer la visibilité et l’exposition des contrats Interface ABI (Application Binary Interface) qui permet aux acteurs externes (autres contrats ou adresses de portefeuille) de l’appeler.

Plutus

Cardano a choisi Haskell et Plutus comme langues de choix. Haskell sera utilisé pour coder Cardano, tandis que Plutus sera utilisé pour la création de contrats intelligents. Les deux sont des langages fonctionnels.

Qu’est-ce que nous entendons par là?

Les deux familles de langues (un petit détour)

En ce qui concerne les langages de programmation, il existe deux familles:

  • Impératif
  • Fonctionnel.

Langages de programmation impératifs

Dans une approche impérative, le codeur doit noter toutes les étapes que l’ordinateur doit suivre pour atteindre un objectif. Tous nos langages de programmation traditionnels comme C ++, Java et même Solidity sont des langages de programmation impératifs. Ce type d’approche de programmation est également appelé programmation algorithmique.

Prenons un exemple de ce que nous entendons par là. Regardons C ++. Supposons que nous voulions ajouter 5 et 3.

int a = 5;

int b = 3;

int c;

c = a + b;

Ainsi, comme vous pouvez le voir, le processus d’ajout prend plusieurs étapes et chaque étape change constamment l’état du programme car ils sont tous exécutés à tour de rôle individuellement.

Un processus d’ajout a nécessité quatre étapes et les étapes sont les suivantes:

  • Déclarer un entier a et lui attribuer la valeur 5.

  • Déclarer un entier b et lui attribuer la valeur 3.

  • Déclarer un entier c.

  • Ajouter les valeurs de et b et les stocker dans c.

Langages de programmation fonctionnels

La deuxième famille de langages de programmation est constituée des langages fonctionnels. Ce style de programmation a été créé pour construire une approche fonctionnelle de la résolution de problèmes. Ce type d’approche est appelé programmation déclarative.

Alors, comment fonctionne la programmation fonctionnelle?

Supposons qu’il y ait une fonction f (x) que nous voulons utiliser pour calculer une fonction g (x) et ensuite nous voulons l’utiliser pour travailler avec une fonction h (x). Au lieu de les résoudre tous dans une séquence, nous pouvons simplement les regrouper tous ensemble dans une seule fonction comme celle-ci:

h (g (f (x)))

Cela rend l’approche fonctionnelle plus facile à raisonner mathématiquement. C’est pourquoi les programmes fonctionnels sont censés être une approche plus sûre de la création de contrats intelligents. Cela facilite également la vérification formelle plus simple, ce qui signifie qu’il est plus facile de prouver mathématiquement ce qu’un programme fait et comment il se comporte. Cela donne à Cardano sa propriété «High Assurance Code».

C’est précisément pourquoi l’approche fonctionnelle est si souhaitable.

Et c’est exactement ce que Cardano utilise Haskell pour coder leur écosystème et Plutus pour leurs contrats intelligents. Haskell et Plutus sont tous deux des langages fonctionnels.

Retour à Plutus

Plutus est une version simplifiée et de niveau supérieur de Haskell. Cela signifie que, comme Haskell, il a plus de similitudes avec les mathématiques que la programmation. Plutus est destiné à utiliser par

«Institutions financières, lieux de commerce électronique et autres opérations financières de ce type avec de l’argent en jeu.»

Jetons donc un œil à la programmation de base de Plutus. Le code suivant a été extrait de Documents Cardano.

Ce programme simple de Plutus montre l’addition, la multiplication, la factorielle et Fibonacci:

ajouter: Nat -> Nat -> Nat {

ajouter Zéro n = n;

ajouter (Suc m) n = Suc (ajouter m n)

}

mul: Nat -> Nat -> Nat {

mul Zéro _ = Zéro;

mul (Suc m) n = ajouter (mul m n) n

}

fac: Nat -> Nat {

fac Zéro = Suc zéro;

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

}

fib: Nat -> Nat {

fib zéro = Suc zéro;

fib (Suc zéro) = Suc zéro;

fib (Suc (Suc n)) = ajouter (fib n) (fib (Suc n))

}

Vous pouvez voir dans le code lui-même les différences entre une approche fonctionnelle et une approche impérative.

Conclusion

Le monde en constante évolution de la crypto et blockchain signifie que nous devons être constamment sur nos gardes. Avoir la connaissance de ces nouveaux langages de programmation est absolument essentiel pour tous les chasseurs de primes et développeurs.

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