So erstellen Sie ein ICO auf NEO mit der Vertragsvorlage NEX ICO smart

Dieser Beitrag befasst sich mit der Neo-Ico-Vorlage von Neon Exchange (NEX) und deren Verwendung als ICO-Entwickler zum Konfigurieren, Kompilieren, Bereitstellen und Testen des ICO-Smart-Vertrags.

Der gesamte Prozess umfasst die folgenden Schritte:

  • Anpassung der ICO-Vorlage an Ihre Bedürfnisse
  • Kompilieren der Vertragsvorlage in NEO-Bytecode (AVM-Datei)
  • Bereitstellen des kompilierten Smart Contract mit Neo-Python
  • Aufrufen von Methoden für den bereitgestellten Vertrag (deploy, mintTokens, balanceOf,…)
  • Zu Testzwecken verwenden wir ein privates Netzwerk der NEO-Blockchain

Über die NEX ICO-Vorlage

Die Smart-Vertragsvorlage wurde Mitte Dezember veröffentlicht und in einem Blogbeitrag auf dem offiziellen Neon-Exchange-Medium vorgestellt. Die Vorlage enthält drei besonders interessante Neuerungen:

  • Volle NEP5 (.1) Kompatibilität
  • KYC / AML-Durchsetzung (optional): Die ICO-Betreiber können festlegen, dass die Teilnehmer überprüft werden müssen, bevor sie Beiträge leisten. Dies funktioniert, indem Teilnehmeradressen auf die Positivliste gesetzt werden, bevor sie die intelligente Vertragsmethode mintTokens erfolgreich aufrufen können
  • Vereinfachter Rückerstattungs- und Ablehnungsmechanismus: Die Vorlage enthält verschiedene Methoden, um ungültige ICO-Beiträge zu vermeiden und Rückerstattungen automatisch zu verarbeiten (z. B. wenn ein Teilnehmer noch nicht auf der Whitelist steht oder außerhalb des ICO-Fensters Beiträge leistet).

Eine ausführlichere Beschreibung finden Sie im offiziellen Blogbeitrag.

Vorbereitungen: Python 3.5 + Neo-Python

Stellen Sie sicher, dass Sie Python 3.5 installiert haben. Sie können es von der offiziellen Python-Downloadseite oder dem Paketmanager Ihrer Wahl herunterladen (unter macOS sollte es standardmäßig installiert sein, andernfalls verwenden Sie homebrew do it). Sie können Ihre Python-Version mit "python3.5 -V" überprüfen.

In diesem Handbuch wird Neo-Python verwendet. Richten Sie dies daher als ersten Schritt ein. Klonen Sie das Repository, richten Sie eine virtuelle Umgebung ein und installieren Sie die Anforderungen. Der gesamte Vorgang wird in der README-Datei zu neo-python als detaillierte Schritt-für-Schritt-Anleitung behandelt. Folgen Sie dieser Anleitung und Sie haben Neo-Python in kürzester Zeit einsatzbereit.

Konfigurieren der ICO-Vorlage

In diesem Abschnitt erfahren Sie, wie Sie die Vorlage an Ihren spezifischen ICO anpassen. Der erste Schritt ist das Klonen des ICO-Vorlagen-Repositorys, das Festlegen der virtuellen Umgebung und das Installieren der Abhängigkeiten:

$ git clone https://github.com/neonexchange/neo-ico-template.git
$ cd neo-ico-template /
$ python3.5 -m venv venv
$ source venv / bin / activate
(venv) $ pip install -r requirements.txt

Lassen Sie uns nun die Konfiguration des Smart-Vertrags untersuchen, insbesondere den Namen, das Symbol, das Eigentum, die Lieferung und die Anzahl der Token, die ein Teilnehmer zum Senden von NEO oder GAS erhält.

Alle wichtigen Einstellungen für das ICO können in nex / token / mytoken.py konfiguriert werden.

Eigentum

Es ist wichtig, den Rechteinhaber festzulegen, der Zugriff auf die administrativen Methoden des Vertrags hat.

  • Für eine Live-Bereitstellung sollten Sie speziell für diesen ICO eine Brieftasche erstellen (in der Neo-Python-Eingabeaufforderung: „neo> create wallet ico.wallet“).
  • Sie müssen den „Skript-Hash“ der Brieftasche abrufen und diesen als Wert für die Eigentümervariable des Smart-Vertrags verwenden. Wenn Sie die Brieftasche mit neo-python öffnen und die Details ausdrucken ("neo> wallet"), wird eine Infozeile mit dem Skript-Hash ausgegeben:
[I 171218 15:24:14 UserWallet: 470] Skript-Hash b '# \ xba \' \ x03 \ xc52c \ xe8 \ xd6 \ xe5 "\ xdc2 39 \ xdc \ xd8 \ xee \ xe9 '
  • Zu Testzwecken können Sie einfach die Brieftasche verwenden, die mit dem privatenet Docker-Image bereitgestellt wird, das den folgenden Skript-Hash hat:
b '# \ xba \' \ x03 \ xc52c \ xe8 \ xd6 \ xe5 "\ xdc2 39 \ xdc \ xd8 \ xee \ xe9 '

Legen Sie den Skript-Hash als Wert für die Variable "owner" in mytoken.py # 16 fest.

Einstellungen für Token, Supply, Token-Wert, Caps und ICO-Zeitfenster

  • Ändern Sie den Namen des Tokens und des Symbols.
  • Entscheiden Sie sich für den Gesamtbetrag und den Anfangsbetrag der Eigentümer und setzen Sie ihn in den Variablen "total_supply" und "initial_amount".
  • Stellen Sie dann ein, wie viele Token ein Teilnehmer beim Senden von NEO oder GAS erhalten soll, und stellen Sie dies in den Variablen „tokens_per_neo“ und „tokens_per_gas“ ein.
  • Sollte es eine Obergrenze für Teilnehmer geben, können Sie diese mit „max_exchange_limited_round“ definieren.
  • Stellen Sie abschließend die Startzeit des ICO und die Endzeit basierend auf der NEO-Blockhöhe ein. Setzen Sie zu Testzwecken die Variable block_sale_start auf 1 und das Ende auf 1 + 100000.

Verschiedene

Wenn Sie den KYC-Prozess deaktivieren möchten, entfernen Sie einfach die KYC-Prüfung unter crowdsale.py # 149 ("wenn nicht self.get_kyc_status (attachments.sender_addr, storage)"). Siehe auch die Kommentare im Code.

Wenn Sie Benutzern ermöglichen möchten, GAS zusätzlich zu NEO zu senden, müssen Sie es aktivieren, indem Sie die Zeilen in crowdsale.py # 136 auskommentieren.

Testen und Kompilieren der ICO-Vorlage in NEO-Bytecode

Während der Konfiguration und Anpassung der ICO-Vorlage ist es äußerst hilfreich, die verschiedenen Methoden kontinuierlich zu testen. neo-python bietet integrierte Funktionen zum Erstellen der Smart Contract- und Testmethodenaufrufe mit benutzerdefinierten Parametern.

Erstellen wir zum Beispiel den SC und testen Sie die "name" -Methode. Öffnen Sie die Neo-Python-Eingabeaufforderung und verwenden Sie einen Befehl wie diesen (ersetzen Sie den Pfad zur Vorlage durch den relativen Pfad zu Ihrem Vorlagenverzeichnis):

neo> build path-to-template / ico_template.py test 0710 05 Richtig Falsch name []
LADEN UND SPEICHERN! ../nex/neo-ico-template/ico_template.py
Selbstmethode zum Trimmen der Last
Selbstmethode zum Trimmen der Last
Gespeicherte Ausgabe in path-to-template / ico_template.avm
[I 171219 14:21:29 EventHub: 102] [test_mode] [SmartContract.Execution.Success] [70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6] [b'NEX Template ']
-------------------------------------------------- ---------
Aufruf von path-to-template / ico_template.py mit Argumenten ['name', '[]']
Testbereitstellungsaufruf erfolgreich
Insgesamt 462 Operationen verwendet
Ergebnis b'NEX Template '
Kosten für TX-Gas: 0,001
-------------------------------------------------- -----------

Dieser Schritt kompiliert auch den Python-Code in den NEO-Bytecode und erstellt eine Datei mit dem Namen "ico_template.avm" (im Vorlagenverzeichnis neben der Datei "ico_template.py").

Alternativ können Sie den Python-Smart-Vertragscode auch manuell kompilieren. Weitere Informationen hierzu finden Sie in der README-Vorlage.

Starten eines privaten Netzwerks der NEO-Blockchain

Der nächste Schritt besteht darin, ein privates Netzwerk der NEO-Blockchain zu starten, um den kompilierten Smart Contract mit Neo-Python bereitzustellen.

Mit Docker können Sie ganz einfach ein privates Netzwerk einrichten: https://hub.docker.com/r/metachris/neo-privnet-with-gas/. Befolgen Sie einfach die Anweisungen auf der Website, um es in Betrieb zu nehmen (siehe auch diesen Beitrag).

Sie können bestätigen, dass das private Netzwerk mit "docker ps" ausgeführt wird.

Stellen Sie nun mit Neo-Python eine Verbindung zum privaten Netzwerk her. Wenn Sie prompt.py mit dem Argument "-p" starten, wird das lokale private Netz verwendet:

$ python prompt.py -p
NEO cli. Geben Sie "help" ein, um zu beginnen
neo>

Die Blockanzahl am unteren Rand des Terminals sollte bei 2115 liegen und steigen. Laden Sie die private brieftasche wallet.json herunter, öffnen Sie sie (Passwort: coz, siehe auch Beschreibung des Docker-Hubs) und erstellen Sie die Brieftasche neu:

neo> open wallet neo-privnet.wallet
[Passwort]> coz
Geöffnete Brieftasche bei neo-privnet.wallet
neo> wallet neu aufbauen

Warten Sie nun einige Sekunden und überprüfen Sie, ob alle NEO- und GAS-Daten verfügbar sind, indem Sie den Befehl "wallet" eingeben, der alle Informationen enthält:

neo> Brieftasche

Bereitstellen des Smart Contract

Jetzt haben wir einen kompilierten Smart-Vertrag, ein privates Netzwerk der laufenden Blockchain und Neo-Python, das vollständig mit einer Brieftasche mit viel NEO und GAS eingerichtet ist. Der nächste Schritt ist die Bereitstellung des Smart Contract mit Neo-Python.

In diesem Beispiel habe ich den kompilierten Smart-Vertrag (ico_template.avm-Datei) in das Neo-Python-Verzeichnis kopiert, wodurch die Bereitstellung in der Blockchain vereinfacht wird:

neo> import contract ico_template.avm 0710 05 Richtig Falsch
Vertragseigenschaften: 1
Bitte füllen Sie die folgenden Vertragsdetails aus:
[Vertragsname]> Nex ICO-Vorlage
[Vertragsversion]> 1
[Vertragsautor]> nex
[Vertrags-E-Mail]> nex
[Vertragsbeschreibung]> nex
Smart Contract erstellen ....
                 Name: nex ico template
              Version 1
               Urheber: nex
                Email: nex
          Beschreibung nex
        Benötigt Speicher: Richtig
 Benötigt dynamischen Aufruf: Falsch
{
    "returntype": "05",
    ...
}

-------------------------------------------------- -------------------------------------------------- ---------------------------------
Testbereitstellungsaufruf erfolgreich
Insgesamt ausgeführte Operationen: 11
Ergebnisse ['IOp-Schnittstelle: ']
Bereitstellen TX-Gaskosten aufrufen: 490,0
Bereitstellen von Invoke TX Fee: 0.0
-------------------------------------------------- -------------------------------------------------- ---------------------------------
Geben Sie Ihr Passwort ein, um fortzufahren und diesen Vertrag bereitzustellen
[Passwort]> coz
[I 171218 12:59:31 Transaktion: 380] Überprüfung der Transaktion: b ''

Der Befehl, den wir verwendeten, war „import contract ico_template.avm 0710 05 True False“, was bedeutet, dass die Datei ico_template.avm mit den Parametertypen 0710 (String und Array) und dem Rückgabetyp Byte-Array importiert wird. Die Parameter „True False“ am Ende bedeuten „Need Storage“ (Ja) und „Support Dynamic Invoke“ (Nein). Siehe auch die neo-Dokumente zu SC-Parametertypen.

Zu diesem Zeitpunkt wird der Vertrag bereitgestellt. Warten Sie einige Blöcke, bis es in der Blockchain angezeigt wird:

neo> tx 

Ersetzen Sie durch den tatsächlichen Hash am Ende des vorherigen Schritts. Sobald die Transaktion gefunden wurde, können Sie nach dem Smart-Vertrag suchen, um weitere Informationen zu erhalten. In diesem Beispiel suchen wir nach "nex", weil wir das im Schritt "Smart Contract Deployment" verwendet haben:

neo> vertragsuche nex
Es wurden 1 Ergebnisse für nex gefunden
Selbstvertragseigenschaften: 1
{
    "email": "nex",
    "Eigenschaften": {
        "dynamic_invoke": false,
        "storage": wahr
    },
    "code_version": "nex",
    "name": "nex",
    "description": "nex",
    "author": "nex",
    "code": {
        "Rückgabetyp": 5,
        ...
        Hash: 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6,
        Parameter: 0710
    },
    "version": 0
}

In diesem Fall enthält der ICO-Smart-Vertrag den Hash 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6, den wir für alle Methodenaufrufe verwenden müssen.

Methoden aufrufen

Der ICO-Smart-Vertrag hat mehrere Methoden, von denen einige vom Eigentümer aufgerufen werden müssen und andere von jedem aufgerufen werden können.

Dieses Diagramm bietet einen groben Überblick über die Phasen und relevanten Smart-Contract-Methoden:

ICO-Stufen und ausgewählte Methoden

Weitere Informationen zu den verschiedenen verfügbaren Methoden, einschließlich der hier nicht aufgeführten, finden Sie in NEP-5.1 und im Neon Exchange-Blogbeitrag.

Der erste Schritt ist das Aufrufen der Bereitstellungsmethode des Smart-Vertrags, bei der die anfängliche Menge von Tokens als im Umlauf befindliche Tokens im Vertragsspeicher gespeichert wird. Bei Neo-Python verwenden wir den Befehl testinvoke mit dem Smart Contract Hash, um die Methode deploy (ohne Argumente) aufzurufen:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 deploy []

Die leeren Klammern bedeuten, dass für die Bereitstellungsmethode keine Argumente übergeben werden müssen.

Nachdem die Verteilungsmethode aufgerufen wurde und die Transaktion in der Blockchain angezeigt wird, können wir mit der Verteilungsmethode die Anzahl der bereits im Umlauf befindlichen Token überprüfen:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 circulation []
[I 171218 16:11:31 EventHub: 102] [test_mode] [SmartContract.Storage.Get] [70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6]
[I 171218 16:11:31 EventHub: 102] [Testmodus] [SmartContract.Execution.Success] [70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6] [b '\ x00 \ xa01 \ xa9_ \ xe3 \ x00']
-------------------------------------------------- -------------------------------------------------- ---------------------------------
Testaufruf erfolgreich
Operationen gesamt: 969
Ergebnisse ["ByteArray: bytearray (b '\\ x00 \\ xa01 \\ xa9 _ \\ xe3 \\ x00')"]
TX-Gaskosten aufrufen: 0.0
TX-Gebühr erheben: 0,001
-------------------------------------------------- -------------------------------------------------- ---------------------------------

In diesem Fall ist das Ergebnis dieses Byte-Arrays: b ’\ x00 \ xa01 \ xa9_ \ xe3 \ x00 '. Wir können es mit Python 3 wie folgt in eine Ganzzahl umwandeln:

>>> val = b '\ x00 \ xa01 \ xa9_ \ xe3 \ x00'
>>> int.from_bytes (val, byteorder = "little")
250000000000000

Wie Sie sehen können, stellt das Byte-Array den ganzzahligen Wert 250000000000000 dar, der 2500000.00000000 Token ist, die anfängliche Menge von 2,5 Millionen Token für die in mytoken.py angegebenen Besitzer.

Der Befehl crowdsale_available gibt die verbleibende Anzahl von Tokens zurück, die in diesem Crowdsale verfügbar sind:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 crowdsale_available []
-------------------------------------------------- -------------------------------------------------- ---------------------------------
Testaufruf erfolgreich
Operationen gesamt: 1047
Ergebnisse ['Integer: 750000000000000']
TX-Gaskosten aufrufen: 0.0
TX-Gebühr erheben: 0,001
-----------------------------

In diesem Fall sind noch alle 7,5-Millionen-Token verfügbar.

In dieser Vorlage gibt es einige spezielle intelligente Vertragsmethoden: crowdsale_register und crowdsale_status.

Der ICO-Betreiber muss Adressen auf die Whitelist setzen, damit er teilnehmen kann. Um eine Adresse wie ATELFGeypfK15uwNvRdQe1zaD3vw38976L auf die Positivliste zu setzen, rufen Sie crowdsale_register folgendermaßen auf:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 crowdsale_register ["ATELFGeypfK15uwNvRdQe1zaD3vw38976L"]

Nachdem diese Transaktion abgeschlossen wurde, können Sie den Crowdsale-Status der Adresse mit diesem Befehl überprüfen:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 crowdsale_status ["ATELFGeypfK15uwNvRdQe1zaD3vw38976L"]

Sobald eine Adresse kyc_registered ist, können Benutzer am ICO teilnehmen, indem sie die Methode mintTokens mit einem angehängten NEO / GAS aufrufen.

So würde dieser Aufruf von Neo-Python mit 5 angehängten NEO ausgegeben:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 mintTokens [] --attach-neo = 5

Sobald dieser Anruf durchgeführt wurde, können Sie den Kontostand mit der Standard-NEP-5-Methode balanceOf überprüfen:

neo> testinvoke 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 balanceOf ["ATELFGeypfK15uwNvRdQe1zaD3vw38976L"]

Und das ist es! Wir haben alle Schritte ausgeführt, die zum Ausführen eines ICO mit der NEX-ICO-Vorlage erforderlich sind. Über weitere NEP-5-Methoden können Sie sich hier informieren.

Schließlich möchten Sie in Neo-Python diesen NEP-5-Token zu Ihrer Brieftasche hinzufügen. Sie können dies mit "Token importieren" tun. Anschließend werden die Salden in Ihrer Brieftasche angezeigt:

neo> Token 70b3f7098a9a3f2361a1f0c312e9842ec4ca6dc6 importieren

Übrigens, es wird einen Artikel geben, der einige der Nuancen und Fallstricke des neo-boa smart contract compilers erklärt!

Vielen Dank an die Leute von Neon Exchange für die Open-Sourcing-Software. Es wird für viele Projekte hilfreich sein!

Wenn Sie Fragen oder Feedback haben, wenden Sie sich über @metachris an den Autor.

Verweise

  • neo-ico-template
  • NEP5 (.1)
  • Neo-Python
  • neo-boa
  • Neon Exchange