Bereitstellen von NFT-Token auf TomoChain

Erstellen Sie Ihre einzigartigen ERC721-Token (z. B. CryptoKitties) auf TomoChain!

Dieser Artikel erklärt:

  • Was ist ein Nicht-Fungible Token (NFT)?
  • Anwendungsfälle von NFT
  • Schrittweise Anleitung zum Bereitstellen eines NFT-Tokens auf TomoChain

Was ist ein NFT (Non-Fungible Token)?

Fungible Token sind alle gleich und austauschbar. Zum Beispiel Dollar oder Bitcoins oder 1 Kilogramm reines Gold oder ERC20-Token. Alle TOMO-Münzen sind gleichwertig, sie sind gleich und haben den gleichen Wert. Sie sind 1: 1 austauschbar. Dies ist ein fungibles Zeichen.

Nicht fungible Token (NFTs) sind alle verschieden und speziell. Jedes Zeichen ist selten, mit einzigartigen Attributen und unterschiedlichem Wert. Zum Beispiel: CryptoKitty-Token, Sammelkarten, Flugtickets oder echte Kunstgemälde. Jeder Artikel hat seine eigenen Eigenschaften und Besonderheiten und ist eindeutig von einem anderen unterscheidbar. Sie sind nicht 1: 1 austauschbar. Sie sind unterscheidbar.

Stellen Sie sich Non-Fungible Tokens (NFT) als seltenes Sammlerstück im TomoChain-Netzwerk vor. Jedes Token hat einzigartige Eigenschaften, eigene Metadaten und spezielle Attribute

Non-Fungible Tokens (NFT) werden verwendet, um eine überprüfbare digitale Knappheit zu erzeugen. NFTs sind einzigartige und unverwechselbare Token, die Sie hauptsächlich auf EVM-Blockchains finden.

Vergleich: fungible und nicht fungible Token

Der ERC-721 ist die Standardschnittstelle für nicht-fungible Tokens (es gibt aber auch andere NFTs wie den ERC1155). ERC721 ist ein Regelsatz, der es anderen Personen / Apps / Verträgen erleichtert, mit Ihrem NFT zu kommunizieren.

ERC721 ist ein kostenloser, offener Standard, der beschreibt, wie nicht fungible oder eindeutige Token auf EVM-kompatiblen Blockchains erstellt werden. Während die meisten Token fungibel (nicht unterscheidbar) sind, sind alle ERC721-Token einzigartig und weisen individuelle Identitäten und Eigenschaften auf. Betrachten Sie sie als seltene, einzigartige Sammlerstücke - jede Einheit ist ein Unikat mit einer eigenen Seriennummer.

ERC20: Identische Token. ERC721: eindeutige Token

Einige nicht fungible Token mit hoher Nachfrage sind Anwendungen wie CryptoKitties, Decentraland, CryptoPunks und viele andere.

CryptoKitties

Ende 2017 haben NFTs mit dem Erfolg von CryptoKitties einen bemerkenswerten Einstieg in die Blockchain-Welt geschafft. Jedes Exemplar ist ein einzigartiges Sammlerstück mit einer eigenen Seriennummer, die mit der DNA-Karte verglichen werden kann. Dies löste ein beispielloses Interesse für NFTs aus, das das Ethereum-Netzwerk verstopfte. Allein der CryptoKitties-Markt erwirtschaftete zwei Wochen nach seiner Markteinführung 12 Millionen US-Dollar und insgesamt über 25 Millionen US-Dollar. Einige seltene Kryptokätzchen wurden sogar für 600 ETH (170.000 US-Dollar) verkauft.

Die Stärke von NFTs liegt in der Tatsache, dass jedes Token einzigartig ist und nicht mit einem anderen verwechselt werden kann - anders als beispielsweise Bitcoins, die untereinander austauschbar sind.

CryptoKitties

Kryptoartikel-Standard (ERC-1155)

Ein Schritt weiter im nicht fungiblen Token-Bereich ist der vom Enjin-Team vorgeschlagene ERC-1155-Standard, auch als „Crypto Item Standard“ bekannt. Dies ist eine verbesserte Version von ERC-721, die für Plattformen mit zehntausenden von digitalen Artikeln und Gütern geeignet ist.

Online-Spiele können bis zu 100.000 verschiedene digitale Objekte enthalten. Das aktuelle Problem mit ERC-721 ist, dass wir 100.000 separate Smart-Verträge bereitstellen müssen, wenn wir alle diese 100.000 Elemente mit einem Token versehen möchten.

Der ERC-1155-Standard kombiniert ERC-20- und ERC-721-Token in seinem Smart-Vertrag. Jedes Token wird im Vertrag mit einem minimalen Datensatz gespeichert, der es von anderen unterscheidet. Dies ermöglicht die Erstellung größerer Sammlungen, die mehrere verschiedene Elemente enthalten.

Anwendungsfälle von nicht fungiblen Token (NFT)

Die meisten Leute, die an ERC-721 oder NFT denken, beziehen sich auf die erfolgreichsten CryptoKitties. Es gibt jedoch viele andere Usability-Anwendungen für NFT-Verträge:

  • Softwaretitel oder Softwarelizenzen zur Gewährleistung von Piraterie, Datenschutz und Übertragbarkeit - wie Collabs.io
  • Wetten in Echtzeit auf das Ergebnis eines Live-Streaming-Videospiels
  • Das Spielen im Allgemeinen ist ein wichtiges Experimentier- und Entwicklungsfeld für die zukünftige Verwendung von NFT. TomoChain veranstaltet Mini-Wettbewerbe für Blockchain-Spiele und heißt alle Entwickler willkommen, Blockchain-Spiele zu erstellen
  • Konzert- und Sportmatch-Tickets können mit einem Token versehen und mit einem Namen versehen werden, um Betrug zu verhindern und gleichzeitig den Fans die Möglichkeit zu geben, an einem einzigen Ort all ihre früheren Veranstaltungserfahrungen zu sammeln
  • Digitale Kunst (oder physische Kunst!) Hat bereits das Spiel betreten und eine wichtige Verwendung von ERC721 gezeigt. Digitale Kunstauktionen waren die erste Anwendung und sind immer noch der erste Gedanke an nicht fungible Token-Standards. Die von Christie's organisierten Auktionen haben den Appell der Öffentlichkeit an Krypto-Sammlerstücke deutlich gemacht. Während dieser Veranstaltung wurden mehrere digitale Kunstobjekte verkauft. Höhepunkt war der Verkauf der „Celestial Cyber ​​Dimension“, eines ERC721 CryptoKitty-Kunstwerks, für 140.000 US-Dollar
  • Immobilienvermögen, um Übertragungen von Häusern, Grundstücken und anderen „symbolisierten“ Immobilien durch intelligente Verträge durchzuführen
  • Finanzinstrumente wie Kredite, Belastungen und andere Verpflichtungen oder ein Terminkontrakt zum Kauf von 1.000 Barrel Öl für 60.000 USD am 1. Mai
  • KYC-Konformitätsprüfung zur Überprüfung der Benutzer. Empfangen eines bestimmten NFT-Tokens in Ihrer Brieftasche, ähnlich dem blauen Häkchen bei Twitter - wie Wyre
  • und mehr…

Krypto-Sammlerstücke sind mehr als eine vorübergehende Begeisterung. Der Grund dafür ist leicht zu erkennen, insbesondere wenn Sie das Potenzial der Kryptosammeltechnologie betrachten, z.

Axie Infinity

Bereitstellen eines NFT-Tokens auf TomoChain

In diesem Artikel wird ein grundlegendes ERC721-Token mit der OpenZeppelin-Implementierung des ERC721-Standards erstellt. Schauen Sie sich die Links an, um sich mit den Anforderungen vertraut zu machen, die manchmal in den hervorragenden OpenZeppelin ERC721-Implementierungen verborgen sind.

Die Assets, die Ihre ERC721-Token (NFT) darstellen, beeinflussen einige der Entwurfsentscheidungen für die Funktionsweise Ihres Vertrags, insbesondere für die Erstellung neuer Token.

  • Sie können während der Tokenerstellung eine Erstversorgung mit Token definieren
  • Sie können eine Funktion haben, die nur vom Vertragsersteller (oder anderen - wenn Sie dies zulassen) aufgerufen werden kann und die beim Aufrufen neue Token ausstellt

In CryptoKitties können Spieler beispielsweise ihre Kätzchen „züchten“, wodurch neue Kätzchen (Token) entstehen. Wenn Ihr ERC721-Token jedoch etwas Greifbareres darstellt, wie z. B. Konzertkarten, möchten Sie möglicherweise nicht, dass Token-Inhaber mehr Token erstellen können. In einigen Fällen möchten Sie vielleicht sogar, dass Token-Inhaber in der Lage sind, ihre Token zu "verbrennen" und sie effektiv zu zerstören.

Beginnen wir mit dem NFT-Tutorial

Wir werden nun ein sammelbares NFT-Token wie CryptoKitties implementieren, jedoch mit einer einfacheren Logik.

Sie erfahren, wie Sie nicht fungible Token erstellen, Tests für Ihre intelligenten Verträge schreiben und mit ihnen interagieren, sobald sie bereitgestellt sind.

Wir bauen nicht fungible Sammlerstücke: Farbverlaufstoken. Jedes Token wird als eindeutiger CSS-Verlauf dargestellt und sieht ungefähr so ​​aus:

Farbverlaufsmarken

0. Voraussetzungen

Die ersten Voraussetzungen, die Sie haben sollten:

  • Installieren Sie Node.js & npm ("Node.js Package Manager")
  • Installieren Sie Truffle
npm install -g Trüffel

1. Erstellen Sie ein neues Projekt

Erstellen Sie ein neues Verzeichnis und verschieben Sie es hinein. Dann starte ein neues Truffle-Projekt:

mkdir nft-Tutorial
cd nft-tutorial
Trüffel init

Wir werden die OpenZeppelin ERC721-Implementierung verwenden, die schnell und einfach ist und eine breite Anwendung findet. Installieren Sie OpenZeppelin im aktuellen Ordner.

npm installiere openzeppelin-solidity

2. Bereiten Sie Ihre TOMO-Brieftasche vor

Erstellen Sie eine TOMO-Brieftasche. Dann nimm ein paar Token:

  • TomoChain (testnet): Holen Sie sich kostenlose Token aus dem Wasserhahn (grab ~ 60 TOMO)
  • TomoChain (mainnet): Sie benötigen echtes TOMO von Börsen
TomoWallet

Gehen Sie zum Menü Einstellungen, wählen Sie Brieftasche sichern und dann Weiter. Hier sehen Sie den privaten Schlüssel Ihrer Brieftasche und den 12-Wörter-Wiederherstellungssatz.

Notieren Sie sich Ihren 12-Wörter-Wiederherstellungssatz.

3. Schreiben des Smart Contract

3.1 GradientToken.sol

Wir verlängern jetzt die OpenZeppelin ERC721-Token-Verträge, um unser Farbverlaufstoken zu erstellen.

  1. Gehen Sie zu Verträge / Ordner und erstellen Sie eine neue Datei mit dem Namen GradientToken.sol
  2. Kopieren Sie den folgenden Code
Pragma Solidität ^ 0,5,4;
'openzeppelin-solidity / contacts / token / ERC721 / ERC721Full.sol' importieren;
Import 'Openzeppelin-Solidität / Verträge / Eigentum / Ownable.sol';
// NFT-Farbverlaufstoken
// Speichert zwei Werte für jedes Token: äußere und innere Farbe
Vertrag GradientToken ist ERC721Full, Ownable {
  
  Verwenden von Counters für Counters.Counter;
  Counters.Counter private tokenId;
 
  struct Gradient {
    String äußere;
    String innen;
  }
  
  Farbverlauf [] öffentliche Farbverläufe;
  Konstrukteur(
    Name des Zeichenkettenspeichers,
    Zeichenfolgenspeichersymbol
  )
    ERC721Full (Name, Symbol)
    Öffentlichkeit
  {}
 
 
  // Gibt die äußeren und inneren Farben eines Tokens zurück
  Die Funktion getGradient (uint256 gradientTokenId) gibt die öffentliche Ansicht zurück (String-Speicher außen, String-Speicher innen) {
    Gradientenspeicher _gradient = gradients [gradientTokenId];
    Outer = _gradient.outer;
    inner = _gradient.inner;
  }
  // Erstelle ein neues Farbverlaufs-Token mit den Parametern "Outer" und "Inner"
  Funktion mint (String Memory _outer, String Memory _inner) public payable onlyOwner {
    uint256 gradientTokenId = tokenId.current ();
    
    Gradientenspeicher _gradient = Gradient ({Outer: _outer, Inner: _inner});
    gradients.push (_gradient);
   _mint (msg.sender, gradientTokenId);
    tokenId.increment ();
  }
 
}

Wir haben von zwei Verträgen geerbt: ERC721Voll, damit es ein nicht fungibles Token darstellt, und vom Ownable-Vertrag.

Jedes Token hat eine eindeutige Token-ID, z. B. eine Seriennummer. Wir haben auch zwei Attribute hinzugefügt: Inner und Outer, um CSS-Farben zu speichern.

Ownable ermöglicht das Verwalten von Berechtigungen. Es weist dem Bereitsteller den Besitz zu (wenn der Vertrag bereitgestellt wird) und fügt den Modifikator onlyOwner hinzu, mit dem Sie bestimmte Methoden nur auf den Vertragsinhaber beschränken können. Sie können auch das Eigentum übertragen. Sie können einen Dritten zum Ausgeben von Token, Brennen von Token usw. zulassen.

Unser Solidity Code ist einfach und ich würde ein tieferes Eintauchen in den ERC-721-Standard und die OpenZeppelin-Implementierung empfehlen.

Die in OpenZeppelin ERC721 zu verwendenden Funktionen finden Sie hier und hier.

Ein weiteres ERC721 Smart Contract-Beispiel von OpenZeppelin finden Sie hier.

4. Migrationen konfigurieren

4.1 Erstellen Sie die Migrationsskripte

Erstellen Sie im Verzeichnis migrations / eine neue Datei mit dem Namen 2_deploy_contracts.js und kopieren Sie Folgendes:

const GradientToken = artifacts.require ("GradientToken");
module.exports = function (deployer) {
 
  const _name = "Farbverlaufstoken";
  const _symbol = "GRAD";
  
  Bereitsteller zurückgeben
    .then (() => deployer.deploy (GradientToken, _name, _symbol));
};

Dieser Code implementiert oder migriert unseren Vertrag zu TomoChain mit dem Namen Gradient Token und dem Symbol GRAD.

4.2 Konfigurieren Sie truffle.js

Jetzt richten wir die Migrationen ein: die Blockchain, in der wir unseren Smart Contract bereitstellen möchten, geben die Brieftaschenadresse an, die bereitgestellt werden soll, Gas, Preis usw.

1. Installieren Sie den HDWalletProvider von Truffle, ein separates npm-Paket, um Transaktionen für Adressen zu suchen und zu signieren, die von einer 12-Wort-Mnemonik abgeleitet sind.

npm installiere truffle-hdwallet-provider

2. Öffnen Sie die Datei truffle.js (truffle-config.js unter Windows). Sie können hier die Migrationseinstellungen bearbeiten: Netzwerke, Ketten-IDs, Gas ... Sie haben mehrere Netzwerke, um Ihren ICO zu migrieren. Sie können Folgendes bereitstellen: lokal, Ganache, öffentliches Ropsten (ETH) -Testnetz, TomoChain (Testnetz), TomoChain (Mainnetz). , usw…

Die Testnet- und Mainnet-Netzwerkkonfigurationen sind in der offiziellen TomoChain-Dokumentation - Netzwerke beschrieben. Wir benötigen den RPC-Endpunkt, die Ketten-ID und den HD-Ableitungspfad.

Ersetzen Sie die Datei truffle.js durch diesen neuen Inhalt:

const HDWalletProvider = require ('truffle-hdwallet-provider');
const infuraKey = "a93ffc ... ";
// const fs = require ('fs');
// const mnemonic = fs.readFileSync (". secret"). toString (). trim ();
const mnemonic = '<12-WORT-WIEDERHERSTELLUNGSPHASE HIER ANLEGEN>';
module.exports = {
  Netzwerke: {
    // Nützlich zum Testen. Der Name "Entwicklung" ist speziell - Trüffel verwendet ihn standardmäßig
    Entwicklung: {
      Host: "127.0.0.1", // Localhost (Standard: keine)
      Port: 8545, // Standard-Ethereum-Port (Standard: keiner)
      network_id: "*", // Beliebiges Netzwerk (Standard: keine)
    },
    // Nützlich für die Bereitstellung in einem öffentlichen Netzwerk.
    // NB: Es ist wichtig, den Provider als Funktion zu verpacken.
    ropsten: {
      // provider: () => neuer HDWalletProvider (mnemonic, `https://ropsten.infura.io/$ {infuraKey}`),
      Anbieter: () => neuer HDWalletProvider (
        Gedächtnisstütze,
        `https://ropsten.infura.io/$ {infuraKey}`,
        0,
        1,
        wahr,
        "m / 44 '/ 889' / 0 '/ 0 /", // Mit HDPath wie TOMO verbinden
      ),
      network_id: 3, // Ropstens ID
      gas: 5500000, // Ropsten hat eine niedrigere Blockgrenze als mainnet
      // Confirmations: 2, // # von Confs, die zwischen Bereitstellungen warten sollen. (Standard: 0)
      // timeoutBlocks: 200, // Anzahl der Blöcke vor dem Timeout einer Bereitstellung (Minimum / Standard: 50)
      // skipDryRun: true // Trockenlauf vor Migrationen überspringen? (Standard: false für öffentliche Netze)
    },
    // Nützlich für die Bereitstellung in TomoChain Testnet
    tomotestnet: {
      Anbieter: () => neuer HDWalletProvider (
        Gedächtnisstütze,
        "https://testnet.tomochain.com",
        0,
        1,
        wahr,
        "m / 44 '/ 889' / 0 '/ 0 /",
      ),
      network_id: "89",
      Gas: 3000000,
      gasPrice: 10000000000000, // Für die Bereitstellung von TomoChain sind mindestens 10 TOMO erforderlich, um Spam-Angriffe abzuwehren
    },
    // Nützlich für die Bereitstellung im TomoChain-Hauptnetz
    Tomomainnet: {
      Anbieter: () => neuer HDWalletProvider (
        Gedächtnisstütze,
        "https://rpc.tomochain.com",
        0,
        1,
        wahr,
        "m / 44 '/ 889' / 0 '/ 0 /",
      ),
      network_id: "88",
      Gas: 3000000,
      gasPrice: 10000000000000, // Für die Bereitstellung von TomoChain sind mindestens 10 TOMO erforderlich, um Spam-Angriffe abzuwehren
    },
    // Nützlich für private Netzwerke
    // Privatgelände: {
      // provider: () => neuer HDWalletProvider (mnemonic, `https: // network.io`),
      // network_id: 2111, // Dieses Netzwerk gehört dir in der Cloud.
      // production: true // Behandelt dieses Netzwerk wie ein öffentliches Netz. (Standard: false)
    //}
  },
  // Setze hier Standard-Mokka-Optionen, benutze spezielle Reporter etc.
  Mokka: {
    // Timeout: 100000
  },
  // Konfigurieren Sie Ihre Compiler
  Compiler: {
    solc: {
      version: "0.5.4", // genaue version aus solc-bin holen (default: truffle's version)
      // docker: true, // verwende "0.5.1", das du lokal mit docker installiert hast (default: false)
      // settings: {// In den Solidity-Dokumenten finden Sie Hinweise zur Optimierung und zur evmVersion
      // Optimierer: {
      // aktiviert: false,
      // läuft: 200
      //},
      // evmVersion: "byzantium"
      //}
    }
  }
}

3. Denken Sie daran, die Datei truffle.js mit Ihrer eigenen Wallet-Wiederherstellungsphrase zu aktualisieren. Kopieren Sie die 12 zuvor aus Ihrer Brieftasche erhaltenen Wörter und fügen Sie sie als Wert der mnemonischen Variablen ein.

konst.
Warnung: In der Produktion wird dringend empfohlen, die Mnemonik in einer anderen geheimen Datei (geladen von Umgebungsvariablen oder einem sicheren geheimen Verwaltungssystem) zu speichern.

4.3 Ganache

Sie können die Ganache-Blockchain verwenden, um Ihre intelligenten Verträge lokal zu testen, bevor Sie zu einer öffentlichen Blockchain wie Ethereum (Ropsten) oder Tomochain migrieren.

Installieren Sie Ganache in einem separaten Konsolenfenster und führen Sie es aus:

npm install -g ganache-cli
ganache-cli -p 8545

Ganache wird gestartet und lauscht auf Port 8545. Automatisch stehen Ihnen 10 Brieftaschen mit ihren privaten Schlüsseln und jeweils 100 ETH zur Verfügung. Sie können sie zum Testen Ihrer intelligenten Verträge verwenden.

Ganache

5. Hinzufügen von Tests

Wir werden jetzt Tests hinzufügen, um unsere intelligenten Verträge zu überprüfen.

Wenn Sie Verträge bereitstellen, ist in der Regel der Bereitsteller Ihr erster Vertrag. Dieser Test wird das überprüfen.

Erstellen Sie GradientTokenTest.js im Verzeichnis / test und schreiben Sie den folgenden Test:

const GradientToken = artifacts.require ("GradientToken");
Vertrag ("Farbverlaufstoken", Konten => {
  it ("Sollte als erstes einen Besitzer angeben", async () => {
    Instanz = warten lassen GradientToken.deployed ();
    let owner = warte auf instance.owner ();
    assert.equal (Eigentümer, Konten [0]);
  });
});

Hier führen wir den Vertragsblock aus, der unseren Vertrag bereitstellt. Wir warten auf die Bereitstellung des Vertrags und fordern Owner () an, der die Adresse des Inhabers zurückgibt. Dann wird angenommen, dass die Adresse des Eigentümers mit dem Konto [0] übereinstimmt.

Hinweis: Stellen Sie sicher, dass Ganache auf einer anderen Konsole ausgeführt wird.

Führen Sie den Test aus:

Trüffeltest
Testen

Der Test sollte bestehen. Dies bedeutet, dass der Smart-Vertrag ordnungsgemäß funktioniert und das, was von ihm erwartet wurde, erfolgreich ausgeführt wurde.

Weitere Tests hinzufügen

Jedes NFT-Token hat eine eindeutige ID. Das erste geprägte Zeichen hat die ID: 0, das zweite die ID: 1 und weiter und weiter ...

Jetzt testen wir die Münzfunktion. Fügen Sie den folgenden Test hinzu:

describe ("mint", () => {
  it ("Erstellt ein Token mit den angegebenen äußeren und inneren Farben", async () => {
    Instanz = warten lassen GradientToken.deployed ();
    let owner = warte auf instance.owner ();
    let token0 = warte auf instance.mint ("# ff00dd", "#ddddff");
    let token1 = wait instance.mint ("# 111111", "# ffff22");
    let token2 = wait instance.mint ("# 00ff00", "# ffff00");
    let gradients1 = warte auf instance.getGradient (1);
    assert.equal (gradients1.outer, "# 111111");
    assert.equal (gradients1.inner, "# ffff22");
  });
});

Dieser Test ist einfach. Zuerst überprüfen wir, ob wir neue Token prägen können. Wir prägen 3 Spielsteine. Dann erwarten wir, dass die eindeutigen äußeren und inneren Attribute des Tokens mit tokenId = 1 korrekt gespeichert werden, und wir bestätigen dies mit der zuvor erstellten Funktion getGradient.

Der Test ist bestanden.

Testen

6. Bereitstellung

6.1 Starten Sie die Migration

Sie sollten Ihren Smart-Vertrag bereits erstellt haben. Ansonsten ist es jetzt ein guter Zeitpunkt, dies mit der Trüffelkompilierung zu tun.

Hinweis: Vergewissern Sie sich, dass Sie genügend TOMO-Token in Ihrer Brieftasche haben !! Ich empfehle mindestens 60 TOMO, um diesen intelligenten Vertrag bereitzustellen

Migrieren Sie zurück in unserem Terminal den Vertrag zu TomoChain testnet network:

Trüffelmigration - Netzwerk tomotestnet

Die Bereitstellung im TomoChain-Hauptnetz ist sehr ähnlich:

Trüffel migrieren - Netzwerk Tomomainnet

Die Migrationen beginnen ...

Migrationen starten ...
=====================
> Netzwerkname: 'tomotestnet'
> Netzwerk-ID: 89
> Blockgaslimit: 84000000
1_initial_migration.js
=====================
Bereitstellen von "Migrationen"
   ----------------------
   > Transaktions-Hash: 0x67c0f12247d0bb0add43e81e8ad534df9cd7d3473ef76f5b60cee3e3d34bae1a
   > Blöcke: 2 Sekunden: 5
   > Vertragsadresse: 0x6056dC38715C7d2703a8aA94ee68A964eaE86fdc
   > account: 0x169397F515Af9E93539e0F483f8A6FC115de660C
   > Restbetrag: 90,05683
   > verwendetes Gas: 273162
   > Gaspreis: 10000 gwei
   > Wert gesendet: 0 ETH
   > Gesamtkosten: 2.73162 ETH
> Speichern von Artefakten
   -------------------------------------
   > Gesamtkosten: 2.73162 ETH
2_deploy_contracts.js
====================
'GradientToken' bereitstellen
   -------------------------
   > Transaktions-Hash: 0xca09a87ad8f834644dcb85f8ea89beff74b818eff11d355e0774e6b60c51718c
   > Blöcke: 2 Sekunden: 5
   > Vertragsadresse: 0x8B830F38b798B7b39808A059179f2c228209514C
   > account: 0x169397F515Af9E93539e0F483f8A6FC115de660C
   > Saldo: 60,64511
   > verwendetes Gas: 2941172
   > Gaspreis: 10000 gwei
   > Wert gesendet: 0 ETH
   > Gesamtkosten: 29.41172 ETH
> Speichern von Artefakten
   -------------------------------------
   > Gesamtkosten: 29.41172 ETH
Zusammenfassung
=======
> Gesamtbereitstellungen: 2
> Endgültige Kosten: 32.14334 ETH

Herzliche Glückwünsche! Sie haben Ihr nicht fungibles Token (NFT) bereits für TomoChain bereitgestellt! Die Bereitstellungsgebühren betrugen 32,14 TOMO.

Lesen Sie den ausgegebenen Text auf dem Bildschirm. Die Vertragsadresse für das NFT-Token lautet (Ihre Adresse wird anders lauten):

0x8B830F38b798B7b39808A059179f2c228209514C
Hinweis: TomoChains Smart Contract Creation-Gebühr: Gaspreis 10000 Gwei, Gaslimit> = 1000000

*** Fehlerbehebung ***

  • Fehler: Die Kosten für die Erstellung intelligenter Verträge werden nicht berücksichtigt. Warum? Die Erhöhung der Transaktionsgebühren für die intelligente Vertragserstellung ist eine der Möglichkeiten, die TomoChain bietet, um sich vor Spam-Angriffen zu schützen. Lösung: Bearbeiten Sie die Datei truffle.js und fügen Sie mehr Gas / gasPrice für die Bereitstellung hinzu.
  • Fehler: unzureichende Mittel für Gas * Preis + Wert. Warum? Sie haben nicht genug Token für Benzingebühren in Ihrer Brieftasche. Lösung: Sie benötigen mehr Geld in Ihrem Portemonnaie, um es einzusetzen, zum Wasserhahn zu gehen und mehr Token zu erhalten.

7. Interaktion mit dem intelligenten Vertrag

7.1 Neue Token prägen

Um nun ein neues Farbverlaufstoken zu erstellen, können Sie Folgendes aufrufen:

GradientToken (gradientTokenAddress) .mint ("# 001111", "# 002222")

Sie können diese Funktion über MyEtherWallet / Metamask oder Web3 aufrufen. In einer DApp oder einem Spiel wird dies wahrscheinlich über einen Klick auf eine Schaltfläche in einer Benutzeroberfläche aufgerufen.

Verwenden Sie MyEtherWallet (MEW), um mit dem Vertrag zu interagieren. Wir verwenden MetaMask, um eine Verbindung mit der GradientToken-Besitzermappe in TomoChain (testnet) herzustellen. Anschließend rufen wir die Funktion mint () auf, um das erste Token zu prägen.

MyEtherWallet

In MyEtherWallet sind unter Menü Vertrag> Mit Vertrag interagieren zwei Dinge erforderlich:

  • Vertragsadresse: Diese Adresse haben Sie bei der Bereitstellung erhalten
  • ABI: file build / contract / GradientToken.json, suche "abi": […] und kopiere alles in Klammern, einschließlich Klammern. Dann auf MEW einfügen

Rechts sehen Sie eine Dropdown-Liste mit den Funktionen. Wählen Sie Minze. MEW zeigt zwei Felder: äußeres und inneres. Geben Sie zwei Farben wie # ff0000 oder # 0000ff ein und klicken Sie auf die Schaltfläche Schreiben. Bestätigen Sie mit MetaMask.

MEW: Interagiere mit dem Vertrag

Hier ist unsere Vertragsadresse und die neue Münztransaktion:

TomoScan

Sie können MEW verwenden, um Funktionen wie getGradient zu schreiben und zu lesen! Auf diese Weise können Sie überprüfen, ob die Werte korrekt sind, totalSupply, transfer tokens ...

Hinweis: In Ethereum (Ropsten) ändert sich die Etherscan-Seite mit unserem migrierten Vertrag, nachdem das erste Token geprägt wurde. Ein neuer Link wird angezeigt, um den ERC721-Token-GRAD zu verfolgen.
Ethereum (Ropsten): Vor und nach „Minze ()“Ropsten: Farbverlaufsmarke

Was kommt als nächstes?

Einige Vorschläge, um fortzufahren:

  • Sie können Ihren einzigartigen NFT-Token viele verschiedene Attribute hinzufügen
  • Sie können eine Verbindung zu einem JS-Front-End herstellen und Ihre Token anzeigen
  • Sie können einige Schaltflächen für die Interaktion mit den Token verwenden (Kaufen, Verkaufen, Ändern, Übertragen, Ändern von Attributen / Farben usw.).
  • Sie können diesen Basiscode durchlaufen und ein neues CryptoKitties-Spiel erstellen :)
Farbverlaufsmarken

Herzliche Glückwünsche! Sie haben Informationen zu nicht fungiblen Token, Anwendungsfällen von NFTs und zur Bereitstellung von NFT-Token auf TomoChain erhalten.

Jetzt freuen wir uns auf Ihre tollen Ideen!

Quellcode

Der Quellcode für dieses Tutorial ist auf Github verfügbar.