NFT in Cardano erstellen

In diesem Beitrag wird Schritt für Schritt erklärt, wie man eigene NFTs im Cardano Test Netzwerk erzeugen (minten) kann.

Damit jeder es einfach selbst ausprobieren kann, ist diese Anleitung für das Cardano Testnet geschrieben. Dabei handelt es sich um eine eigenständige Blockchain, auf der ohne irgendwelche kosten die Funktionalitäten von Cardano getestet werden können. Um NFTs auf dem Cardano Mainnet zu erstellen müssen in den späteren Befehlen einfach nur die Stellen wo „–$testnet“ steht durch „–mainnet“ ausgetauscht werden.

Voraussetzung für die Anleitung ist ein grundlegendes Verständnis für Blockchain und NFTs, sowie Basiskenntnisse im Umgang mit dem Terminal.

1. Bild bereitstellen

Um das NFT später mit einem Bild zu Verknüpfen, muss dieses Bild zunächst bereitgestellt werden. Im NFT selbst ist jedoch nicht das komplette Bild enthalten, da sonst die Blockchain sehr schnell viel zu groß werden würde. Aus diesem Grund wird im NFT ein Link zu dem entsprechenden Bild hinterlegt. Das Bild muss also über einen Link aus dem Internet erreichbar sein. Für NFTs hat sich dazu in der Praxis das Interplanetary Filesystem (IPFS) durchgesetzt. IPFS ist im Grunde ein verteiltes Dateisystem, bei dem die Daten nicht nur bei einem, sondern in Stücke zerteilt bei vielen liegen. Dadurch wird im Sinne von NFTs gewährleistet, dass die Bilder auch noch verfügbar sind, wenn der NFT Ersteller seine Server abschaltet.

Der einfachste Weg um IPFS zu nutzen, ist es die Desktop Anwendung zu installieren (https://github.com/ipfs/ipfs-desktop/releases). Downloaded hier je nach Betriebsystem den entsprechenden Installer (für Windows z.B. IPFS-Desktop-Setup-0.17.0.exe) und installiert IPFS-Desktop.

Wenn der Desktop Client installiert ist, startet ihn und klickt auf der linken Seite auf Dateien. Hier können jetzt alle Bilder importiert werden, welche mit NFTs verknüpft werden sollen. Wenn ein Bild importiert wurde, erscheint es in der Liste. Im NFT wird die CID der Datei (die Zeichenfolge unter dem Dateinamen) hinterlegt. Um die CID zu kopieren kann man rechts bei der Datei auf die drei Punkte klicken und dann in dem Menü auf CID kopieren klicken. Die CID von dem Bild welches in den folgenden Schritten zum NFT werden soll, wird später nochmal benötigt.

2. Cardano Node einrichten

Um mit dem Cardano Netzwerk kommunizieren zu können wird ein Cardano Node benötigt. Mit Hilfe des Cardano Node können Transaktionen auf der Blockchain ausgeführt werden.

Der einfachste Weg einen Cardano Node bereitzustellen, ist das Ausführen des offiziellen Cardano Node Docker Containers. Hierfür muss, falls noch nicht geschehen, zunächst Docker installiert werden. Hierfür empfiehlt es sich Docker Desktop zu installieren (https://www.docker.com/products/docker-desktop).

Wenn Docker Desktop installiert ist, kann der Cardano Node Container ausgeführt werden. Dazu müssen im Terminal die folgenden Befehle ausgeführt werden:

• Herunterladen des neuesten Cardano Node Container Images:

docker image pull inputoutput/cardano-node:latest

• Erstellen der lokalen Volumes (persistente Speicher) für den Container:

docker volume create cardano-node-data
docker volume create cardano-node-ipc

• Ausführen des Containers:
  (<Magic Number> muss durch die reelle Testnet Magic Nummer ersetzt werden. Diese steht unter „networkMagic“ auf der folgenden Seite https://book.world.dev.cardano.org/environments/preview/shelley-genesis.json)

testnet='testnet <Magic Number>'

docker run --name cardano-node -e NETWORK=$testnet -e CARDANO_NODE_SOCKET_PATH=/ipc/node.socket -v cardano-node-ipc:/ipc -v cardano-node-data:/data inputoutput/cardano-node

• Öffnen einer Kommandozeile in dem Container:
  (Zweites Terminal unter Windows öffnen)

docker exec -it cardano-node bash

Der Cardano Node ist nun eingerichtet und kann nun für das Erstellen des NFTs genutzt werden. In dem zweiten Terminal werden alle nachfolgenden Schritte direkt im Container ausgeführt.

Alle weiteren Schritte sollten erst ausgeführt werden, wenn der Cardano Node komplett mit der Blockchain synchronisiert ist. Dies kann 30 bis 50 Minuten dauern. Den aktuellen Synchronisierungsstand kann man sich wie folgt anzeigen lassen:

cardano-cli query tip --$testnet

3. NFT erzeugen

Wichtig für NFTs ist die Einzigartigkeit und Unveränderbarkeit. Beides kann auf einfache Art mithilfe von Native Assets in Cardano erreicht werden. Zum einen wird nur eine Signatur zum erzeugen und löschen des Tokens erlaubt und zum anderen wird auch nur ein einziger Token erzeugt. Das erzeugte NFT ist in diesem Beispiel 10000 Slots veränderbar. So kann das NFT noch einen gewissen Zeitraum nach Erstellung verändert und gelöscht werden. Wenn also Fehler beim Erzeugen gemacht werden, ist dies nicht für diesen Zeitraum nicht so schlimm.

Setup

Alle nachfolgenden Schritte werden innerhalb des Cardano Node Containers ausgeführt (zweites Terminal aus dem Schritt davor).

• Arbeitsverzeichnis erstellen:

mkdir nft
cd nft/

• Variablen setzen:

tokenname="NFT"
tokenamount="1"
fee="0"
output="0"
testnet="testnet <Hier die Magic Number wie oben eintragen>"

• Variable mit der CID vom hochgeladenen Bild aus Schritt 1 setzen:

ipfs_hash="hier die CID aus Schritt 1 einfügen"

• Schlüssel erzeugen:

cardano-cli address key-gen --verification-key-file payment.vkey --signing-key-file payment.skey

• Cardano Adresse für Testnetzwerk erzeugen:

cardano-cli address build --payment-verification-key-file payment.vkey --out-file payment.addr --$testnet

• Adresse in Variable speichern:

address=$(cat payment.addr)

Test Ada auf Adresse laden

Jede Transaktion auf der Blockchain kostet eine gewisse Gebühr (mindestens 1 Ada). Im Cardano Testnetzwerk kann man sich zum Testen kostenlos 1000 tAda auf eine Cardano Adresse überweisen lassen.

Zunächst muss die gerade erzeugte Cardano Adresse kopiert werden. Die Adresse kann über folgenden Befehl angezeigt werden:

cat $address

Nachdem die Adresse kopiert wurde, muss diese in dem Tool auf folgender Seite eingefügt werden (alles andere bleibt default): https://testnets.cardano.org/en/testnets/cardano/tools/faucet/

Über den Request Funds Button wird das Test Ada eurer Adresse hinzugefügt. Dies kann ein paar Minuten dauern.

Um zu überprüfen, ob das tAda schon transferiert wurde, kann der folgende Befehl genutzt werden:

cardano-cli query utxo --address $address --$testnet

Protokollparameter exportieren

Für spätere Zwecke werden einige Protokollparameter benötigt. Diese können mit folgendem Kommando in eine Datei geschrieben werden:

cardano-cli query protocol-parameters --$testnet --out-file protocol.json

Policy ID erstellen

Um die Regeln für das Erstellen und Zerstören des Tokens festzulegen, wird eine sogenannte policy erstellt. Dazu gehören zum einen ein Schlüsselpaar und zum anderen ein Skript File.

• Zunächst wird für die Policy ein neues Verzeichnis erstellt:

mkdir policy

• In diesem Verzeichnis wird nun das Schlüsselpaar erzeugt:

cardano-cli address key-gen --verification-key-file policy/policy.vkey --signing-key-file policy/policy.skey

Nun wird das Skript File erstellt. In diesem wird festgelegt, dass nur eine Signatur erlaubt ist und das Erzeugen und Zerstören des Token nur innerhalb der ersten 10000 Slots nach der erstmaligen Erstellung möglich sind.

Zunächst muss der aktuelle Slot herausgefunden werden. Der Slot kann aus der Ausgabe des folgenden Kommandos abgelesen werden: (Wichtig: Diese Slotnummer muss um 10000 erhöht werden)

cardano-cli query tip --$testnet

• Die um 10000 erhöhte Slotnummer wird nun in einer Variable gespeichert:

slotnumber="Hier Slotnummer einfügen"

• Um das Policy Skript File zu erstellen müssen die nachfolgenden Kommandos in der entsprechenden Reihenfolge ausgeführt und die um 10000 erhöhte Slotnummer ergänzt werden:

echo "{" >> policy/policy.script
echo "  \"type\": \"all\"," >> policy/policy.script 
echo "  \"scripts\":" >> policy/policy.script 
echo "  [" >> policy/policy.script 
echo "   {" >> policy/policy.script 
echo "     \"type\": \"before\"," >> policy/policy.script 
echo "     \"slot\": HIER SLOTNUMMER ERGÄNZEN" >> policy/policy.script
echo "   }," >> policy/policy.script 
echo "   {" >> policy/policy.script
echo "     \"type\": \"sig\"," >> policy/policy.script 
echo "     \"keyHash\": \"$(cardano-cli address key-hash --payment-verification-key-file policy/policy.vkey)\"" >> policy/policy.script 
echo "   }" >> policy/policy.script
echo "  ]" >> policy/policy.script 
echo "}" >> policy/policy.script

• Nun wird der Pfad zum Skript ebenfalls in einer Variable gespeichert:

script="policy/policy.script"

• Zuletzt wird die policyID generiert:

cardano-cli transaction policyid --script-file ./policy/policy.script >> policy/policyID

Metadaten erstellen

Zusätzlich zur Policy benötigt ein NFT auch Metadaten. Hier sind die wichtigsten Informationen zum NFT enthalten. Dazu zählen insbesondere der Name, die Beschreibung und der Pfad zum Bild. Die Metadaten werden in einer JSON Datei (metadata.json) gespeichert.

• Die metadata.json Datei kann wie folgt erstellt werden. In den Nachfolgenden Kommandos müssen entsprechend Name und Beschreibung angepasst werden:

echo "{" >> metadata.json
echo "  \"721\": {" >> metadata.json 
echo "    \"$(cat policy/policyID)\": {" >> metadata.json 
echo "      \"$(echo $tokenname)\": {" >> metadata.json
echo "        \"description\": \"Hier könnte deine NFT Beschreibung stehen\"," >> metadata.json
echo "        \"name\": \"Mein erster NFT\"," >> metadata.json
echo "        \"id\": \"1\"," >> metadata.json
echo "        \"image\": \"ipfs://$(echo $ipfs_hash)\"" >> metadata.json
echo "      }" >> metadata.json
echo "    }" >> metadata.json 
echo "  }" >> metadata.json 
echo "}" >> metadata.json

Token mit Transaktion erzeugen

Nun ist es an der Zeit den NFT zu erzeugen. Dies geschieht mit Hilfe einer Transaktion auf der Blockchain.

• Zunächst müssen noch ein paar Variablen gesetzt werden:

cardano-cli query utxo --address $address --$testnet

txhash="TxHash aus der Ausgabe einfügen"
txix="TxIx aus der Ausgabe einfügen"
funds="Amount aus der Ausgabe einfügen"
policyid=$(cat policy/policyID)

• Jetzt kann das Raw File der Transaktion erzeugt werden:

cardano-cli transaction build-raw \
--fee $fee  \
--tx-in $txhash#$txix  \
--tx-out $address+$output+"$tokenamount $policyid.$tokenname" \
--mint="$tokenamount $policyid.$tokenname" \
--minting-script-file $script \
--metadata-json-file metadata.json  \
--invalid-hereafter $slotnumber \
--out-file matx.raw

• Die Gebühr, welche bei der Transaktion anfällt muss nun anhand des Raw Files berechnet und gesetzt werden:

fee=$(cardano-cli transaction calculate-min-fee --tx-body-file matx.raw --tx-in-count 1 --tx-out-count 1 --witness-count 1 --$testnet --protocol-params-file protocol.json | cut -d " " -f1)

• Der Wert für die übrigen tAda muss entsprechend auch berechnet und gesetzt werden:

output=$(expr $funds - $fee)

• Mit den neuen Werten wird das Raw File überschrieben:

cardano-cli transaction build-raw \
--fee $fee \
--tx-in $txhash#$txix \
--tx-out $address+$output+"$tokenamount $policyid.$tokenname" \
--mint="$tokenamount $policyid.$tokenname" \
--minting-script-file $script \
--metadata-json-file metadata.json \
--invalid-hereafter $slotnumber \
--out-file matx.raw

• Die Transaktion wird nun signiert:

cardano-cli transaction sign \
--signing-key-file payment.skey \
--signing-key-file policy/policy.skey \
--$testnet --tx-body-file matx.raw \
--out-file matx.signed

• Zuletzt wird die Transaktion ausgeführt:

cardano-cli transaction submit --tx-file matx.signed --$testnet

Der NFT ist nun erstellt worden und sollte über den Cardano Explorer sichtbar sein (es kann ggf. ein paar Minuten dauern bis die Transaktion abgeschlossen ist).

Öffnet die folgende Seite und sucht nach eurer Cardano Adresse: https://explorer.cardano-testnet.iohkdev.io/de

Hier sollte der NFT nun sichtbar sein (allerdings sieht man hier nicht das Bild, sondern nur die Metadaten)

Hilfreiche Links

• Cardano Explorer: https://preprod.cardanoscan.io/
• Cardano Developer Portal: https://developers.cardano.org/
• Cardano Testnets Dokumentation: https://testnets.cardano.org/en/testnets/cardano/overview/
• IPFS Dokumentation: https://docs.ipfs.io/