Als Entwickler sollten Sie sich darüber im Klaren sein, wie wichtig ständige Weiterbildung ist. Die Welt der Kryptowährung und Blockchain ist in ständiger Bewegung. Die Norm vor einem Jahr könnte in Monaten völlig irrelevant sein. Im Geiste dieses ständigen Wandels geben wir Ihnen eine Vorstellung davon, wie intelligente Verträge und Code von Vyper und Plutus aussehen werden. Ethereum plant, Vyper für seine zukünftigen Verträge zu verwenden, während Cardano Plutus als Wahl für die Programmiersprache für intelligente Verträge ausgewählt hat.

Intelligente Verträge der Zukunft? Vyper und Plutus

Solidity ist ab sofort die Smart-Vertragssprache der Wahl für Ethereum. Solidity wurde von Gavin Wood, Christian Reitwiessner, Alex Beregszaszi, Yoichi Hirai und mehreren ehemaligen Ethereum-Mitarbeitern entwickelt, um das Schreiben intelligenter Verträge auf Blockchain-Plattformen wie Ethereum zu ermöglichen.

Es wurde von vielen populären Programmen und Programmierkonzepten beeinflusst. Es enthält Elemente der objektorientierten Programmierung, Webentwicklung, Assemblersprache usw. und deckt eine breite Palette von Anwendungsfällen ab. jedoch, Prüfung Soliditätsverträge können sehr schwierig sein, da sie äußerst freizügig und kompliziert sein können.

Vyper ist eine Python-basierte Sprache, die ausschließlich auf Lesbarkeit und Einfachheit ausgelegt ist. Da Python selbst eine der am leichtesten verständlichen und am weitesten verbreiteten Programmiersprachen ist, ist zu hoffen, dass nicht-technische Personen in der Lage sind, ihre eigenen intelligenten Verträge zu codieren. Vyper wurde als minimalistische, einfache Sprache entwickelt, die sich auf triviale Anwendungsfälle konzentriert (z. B. kann sie nicht zum Codieren eines komplexen Dapps verwendet werden) und nicht so flexibel wie Solidität ist.

Während dies die Flexibilität des Vertrags etwas einschränken kann, ist dies der Fall bietet mehr

“Ein unkompliziertes, pragmatisches und leicht überprüfbares System zum Lesen und Schreiben intelligenter Verträge, das versucht, die Absicht desjenigen, der den Code schreibt, klar zu erfassen.”

Es sieht so aus, als ob Ethereum und Ethereum Classic Bigwigs aus zwei Hauptgründen vollständig hinter Vyper stehen:

  • Die Sharding-Implementierung von Ethereum und Casper FFG wurden in Vyper codiert.

  • Das Ethereum Commonwealth, das Ethereum Classic unterhält und weiterentwickelt, hat außerdem erklärt, dass es Vyper als Standardsprache für intelligente Verträge übernehmen möchte.

Der minimalistische Ansatz von Vyper beseitigt die Vererbung, rekursive Aufrufe von Statusmodifikatoren und die Überladung von Operatoren, was zu Angriffen auf Gaslimitvektoren führt. Darüber hinaus gibt es unzählige Überlaufprüfungen für große Rechenoperationen. Aufgrund seines Ansatzes ist Vyper nicht nur ressourceneffizient, es ist auch schwierig, schädlichen Code zu schreiben, ohne dass er während der Überwachung entdeckt wird.

Vyper Smart Vertrag

Werfen wir einen Blick auf einen Vyper-Smart-Vertrag mit freundlicher Genehmigung CoinPupil. Dies ist ein einfacher und unkomplizierter ERC-20-Vertrag.

# Veranstaltungen

Übertragung: Ereignis ({_ von: indiziert (Adresse), _zu: indiziert (Adresse), _Wert: uint256})

Genehmigung: Ereignis ({_ Eigentümer: indiziert (Adresse), _Spender: indiziert (Adresse), _Wert: uint256})

.

# Zustandsvariablen

Name: public (bytes32)

Symbol: öffentlich (bytes32)

totalSupply: public (uint256)

Dezimalstellen: public (int128)

Guthaben: int128 [Adresse]

erlaubt: int128 [Adresse] [Adresse]

.

# Konstruktorfunktion / Vertragsinstanziierung

@Öffentlichkeit

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

self.name = _name

self.symbol = _symbol

self.decimals = _decimals

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

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

.

# Kontostand

@Öffentlichkeit

@Konstante

def balanceOf (_owner: address) -> uint256:

.

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

.

# _Anzahl der Token _ an Adresse senden

@Öffentlichkeit

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

.

wenn self.balances [msg.sender] >= _Betrag und

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

self.balances [msg.sender] – = _amount # Vom Absender subtrahieren

self.balances [_to] + = _amount # Fügen Sie dem Empfänger dasselbe hinzu

return True

sonst:

falsch zurückgeben

.

# Übertragung von erlaubten Token

@Öffentlichkeit

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

.

if _value <= self.allowed [_from] [msg.sender] und

_Wert <= self.balances [_from]:

.

self.balances [_from] – = _value # Saldo von Adresse verringern.

self.allowed [_from] [msg.sender] – = _value # Zulage verringern.

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

.

return True

sonst:

falsch zurückgeben

.

# Erlauben Sie _spender, bis zum _Wertbetrag vom Konto abzuheben.

@Öffentlichkeit

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

.

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

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

.

return True

.

# Erhalten Sie die Erlaubnis einer Adresse

@Öffentlichkeit

def allowance (_owner: address, _spender: address) -> uint256:

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

In diesem Vertrag:

  • Die “self” -Methode wird verwendet, um die Instanzvariablen ihrer Klasse zur Verdeutlichung anzuzeigen.

  • @public und @private werden verwendet, um die Sichtbarkeit und Sichtbarkeit der ABI-Schnittstelle (Application Binary Interface) für Verträge festzulegen, über die externe Akteure (andere Verträge oder Brieftaschenadressen) sie aufrufen können.

Plutus

Cardano hat Haskell und Plutus als Sprache ihrer Wahl ausgewählt. Haskell wird zum Codieren von Cardano verwendet, während Plutus für die intelligente Vertragserstellung verwendet wird. Beide sind funktionale Sprachen.

Was meinen wir damit??

Die zwei Familien der Sprachen (Ein kleiner Umweg)

Wenn es um Programmiersprachen geht, gibt es zwei Familien:

  • Imperativ
  • Funktionell.

Imperative Programmiersprachen

In einem zwingenden Ansatz muss der Codierer alle Schritte aufschreiben, die der Computer ausführen muss, um ein Ziel zu erreichen. Alle unsere traditionellen Programmiersprachen wie C ++, Java und sogar Solidity sind wichtige Programmiersprachen. Diese Art von Programmieransatz wird auch als algorithmische Programmierung bezeichnet.

Nehmen wir ein Beispiel dafür, was wir damit meinen. Schauen wir uns C ++ an. Angenommen, wir möchten 5 und 3 hinzufügen.

int a = 5;

int b = 3;

int c;

c = a + b;

Wie Sie sehen, übernimmt der Additionsprozess mehrere Schritte und jeder Schritt ändert ständig den Status des Programms, da alle nacheinander einzeln ausgeführt werden.

Ein Additionsprozess dauerte vier Schritte und die Schritte sind:

  • Deklarieren einer Ganzzahl a und Zuweisen des Werts 5.

  • Deklarieren einer Ganzzahl b und Zuweisen des Werts 3.

  • Ganzzahl deklarieren c.

  • Addiere die Werte von und b und speichere sie in c.

Funktionale Programmiersprachen

Die zweite Familie von Programmiersprachen sind funktionale Sprachen. Diese Art der Programmierung wurde entwickelt, um einen funktionalen Ansatz zur Problemlösung zu entwickeln. Diese Art von Ansatz wird als deklarative Programmierung bezeichnet.

Wie funktioniert die funktionale Programmierung??

Angenommen, es gibt eine Funktion f (x), mit der wir eine Funktion g (x) berechnen möchten, und dann möchten wir diese verwenden, um mit einer Funktion h (x) zu arbeiten. Anstatt alle in einer Sequenz zu lösen, können wir einfach alle in einer einzigen Funktion wie dieser zusammenfassen:

h (g (f (x)))

Dies erleichtert die mathematische Argumentation des funktionalen Ansatzes. Aus diesem Grund sollen funktionale Programme einen sichereren Ansatz für die intelligente Vertragserstellung darstellen. Dies hilft auch bei der einfacheren formalen Überprüfung, was bedeutet, dass es einfacher ist, mathematisch zu beweisen, was ein Programm tut und wie es sich verhält. Dies gibt Cardano die Eigenschaft „High Assurance Code“.

Genau deshalb ist der funktionale Ansatz so wünschenswert.

Und genau das nutzt Cardano Haskell, um sein Ökosystem und Plutus für ihre intelligenten Verträge zu kodieren. Sowohl Haskell als auch Plutus sind funktionale Sprachen.

Zurück zu Plutus

Plutus ist eine übergeordnete und vereinfachte Version von Haskell. Dies bedeutet, dass es wie Haskell eher Ähnlichkeiten mit der Mathematik als mit der Programmierung aufweist. Plutus ist beabsichtigt zur Verwendung durch

“Finanzinstitute, Orte, die elektronischen Handel betreiben, und andere solche Finanzgeschäfte mit Geld auf dem Spiel.”

Schauen wir uns also einige grundlegende Plutus-Programmierungen an. Der folgende Code wurde übernommen Cardano docs.

Dieses einfache Plutus-Programm zeigt Addition, Multiplikation, Fakultät und Fibonacci::

hinzufügen: Nat -> Nat -> Nat {

addiere Null n = n;

addiere (Suc m) n = Suc (addiere m n)

}}

mul: Nat -> Nat -> Nat {

mul Zero _ = Zero;

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

}}

Sie können im Code selbst die Unterschiede zwischen einem funktionalen Ansatz und einem imperativen Ansatz erkennen.

Fazit

Die sich ständig verändernde Welt der Krypto und Blockchain bedeutet, dass wir ständig auf Trab sein müssen. Kenntnisse dieser neuen Programmiersprachen sind für alle Kopfgeldjäger und Entwickler von entscheidender Bedeutung.

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