Das Cudos Network ist eine spezielle Blockchain, die entwickelt wurde, um leistungsstarkes, vertrauensloses und erlaubnisfreies Cloud-Computing für alle bereitzustellen.

In diesem Tutorial werden wir einen CosmWasm Smart Contract im öffentlichen Cudos Testnet bereitstellen.

1) RPC-Knoten

Zuerst müssen Sie Ihre Umgebung einrichten,in der Sie den Binary-Builder-Container erstellen, den wir für die Interaktion mit der Blockchain verwenden.

Um den Smart Contract in die Blockchain hochzuladen, benötigen Sie auch Zugriff auf einen RPC-Knoten (= vollständiger Knoten mit offenem Port 26657). Sie können dieses verwenden, solange es oben ist: https://sentry1.gcp-uscentral1.cudos.org:26657 .

Wenn Sie keinen Zugriff auf einen extern gehosteten RPC-Knotenhaben (d. h. der obige Knoten ist aus irgendeinem Grund ausgefallen), können Sie jederzeit Einen eigenen Knoten einrichten und ausführen.

2) Rost

CosmWasm Smart Contracts sind in Rustgeschrieben, daher müssen wir den Rust-Compiler installieren.

# Install rustup.
$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh# Use the latest stable version.
$ rustup default stable# Add the wasm32 target and make sure it was installed correctly.
$ rustup target add wasm32-unknown-unknown
$ rustup target list --installed

Laden Sie einen vorhandenen Smart Contract herunter

Der Einfachheit halber werden wir den CW20-Vertrag verwenden, der ein fungibles Token (ähnlich wie ERC20) in der Kette bereitstellt. Wenn Sie versuchen, Ihren eigenen Smart Contract bereitzustellen, können Sie mit kompilieren fortfahren.

Der CW20 Smart Contract kann aus dem CosmWasm/cw-plus Repository auf GitHub heruntergeladen werden. Für CUDOS müssen wir v0.9.0 auschecken.

$ git clone --depth 1 --branch v0.9.0 https://github.com/CosmWasm/cw-plus.git

Compilierung

Führen Sie im Stammverzeichnis des Vertrags den folgenden Befehl aus.

# Go to root directory of CW20 contract.
$ cd cw-plus# Optimize and compile the smart contract.
$ docker run --rm -v "$(pwd)":/code --mount type=volume,source="$(basename "$(pwd)")_cache",target=/code/target --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry cosmwasm/workspace-optimizer:0.12.4

Sobald die Kompilierung abgeschlossen ist, muss die .wasm ausführbare Datei in den Binary-Builder-Container kopiert werden.

# Make sure the binary-builder is in the list of running containers.
$ docker ps --format '{{.Name}}'# Copy the .wasm executable into the /usr/cudos directory of the binary-builder.
$ docker cp artifacts/cw20_base.wasm binary-builder:/usr/cudos

Einsatz

Der CW20 Smart Contract benötigt ein Eigentümerkonto, das unter anderem Token prägen und verbrennen kann. Wenn Sie noch kein Konto haben, erstellen oder stellen Sie bitte ein bestehendes Konto wieder her, das Sie als Vertragsinhaber verwenden möchten.

# Create a new owner account (if needed).
$ cudos-noded keys add owner --keyring-backend file# To recover an account, add the --recover flag to the command above.

Um den Vertrag bereitzustellen, benötigt das Eigentümerkonto einige CUDOS-Token, um für Gas zu bezahlen, also holen Sie sich einige aus dem Wasserhahn.

In Ordnung, wir sind bereit, den Smart Contract bereitzustellen.

$ docker exec -it binary-builder cudos-noded tx wasm store /usr/cudos/cw20_base.wasm --from owner --keyring-backend file --chain-id cudos-testnet-public --node https://sentry1.gcp-uscentral1.cudos.org:26657 --gas auto --gas-adjustment 1.3 -y | tee /dev/tty | tail -1 | tr -d '\r' | jq -r '.logs[0].events[-1].attributes[-1].value' | tee /dev/tty

Die Ausgabe sollte Ihnen die Vertrags-ID geben.

Instanziierung

Mit einem bereitgestellten Smart Contract kann nur dann interagiert werden, wenn er instanziiert wird. Die Instanziierung ist im Wesentlichen der Prozess der Übergabe benutzerdefinierter Werte an den Vertrag, wie der Name des Tokens, das Symbol, Dezimalstellen usw., der in gewissem Sinne „den Vertrag zum Leben erweckt“.

Lassen Sie uns zunächst unsere benutzerdefinierten Initialisierungsparameter festlegen.

$ INIT=$('{"name":"<TOKEN_NAME>","symbol":"<TOKEN_SYMBOL>","decimals":<DECIMALS>,"initial_balances":[<ACCOUNTS>],"mint":{"minter":"<MINTER_ADDR>","cap":"<TOKEN_CAP>">
  • <TOKEN_NAME ist > der Name, den Sie Ihrem CW20-Token geben möchten, z. B. „Super Cudos“
  • <TOKEN_SYMBOL ist > der Nenner Ihres CW20-Tokens, z.B. „scudos“
  • <DECIMALS > ist die Anzahl der Dezimalstellen, die Ihr Token haben sollte, z. B. 3 (= kleinster Wert wäre 0,001)
  • <KONTEN> ist ein Array aus einem oder mehreren JSON-Objekten wie {"address": "<CUDOS_ADDR>","amount":<TOKEN_AMOUNT>} wo <CUDOS_ADDR> ist die cudos1... Adresse, die angegeben ist <TOKEN_AMOUNT> Token bei Vertragsinstanziierung, z. {"address": "cudos1d0new9u2f80rcmmlw0zftxeh0385c2gwpmdv8v","amount":1000}
  • <TOKEN_CAP > ist die maximale Menge an Token, die der Münzstätter prägen kann, z. B. „10000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Nachdem wir unseren CW20-Vertrag angepasst haben, lassen Sie uns ihn instanziieren.

$ docker exec -it binary-builder cudos-noded tx wasm instantiate <CONTRACT_ID> $INIT --from owner --label "CW20" --keyring-backend file --chain-id cudos-testnet-public --node https://sentry1.gcp-uscentral1.cudos.org:26657 --gas auto --gas-adjustment 1.3 -y
  • <CONTRACT_ID ist > die ID des Vertrags, die wir durch die Bereitstellung erhalten haben

Überprüfen Sie nun den Vertragsstatus, um sicherzustellen, dass er tatsächlich instanziiert wird.

$ docker exec -it binary-builder cudos-noded q wasm list-contract-by-code <CONTRACT_ID> --node https://sentry1.gcp-uscentral1.cudos.org:26657 --output json | jq -s

Um mit dem Vertrag interagieren zu können, benötigen Sie die Adresse des Vertrags.

$ CONTRACT_ADDR=$(docker exec -it binary-builder cudos-noded q wasm list-contract-by-code <CONTRACT_ID> --node https://sentry1.gcp-uscentral1.cudos.org:26657 --output json | jq -r '.contracts[-1]' | tee /dev/tty | tail -1 | tr -d '\r')

Jeder Vertrag muss Schemadateien bereitstellen, die Ihnen sagen, wie Sie damit interagieren können, ähnlich wie bei einem ABI in Ethereum. Mit dem folgenden Befehl können Sie sie selbst im Stammverzeichnis des Repositorys generieren.

$ cargo schema

Nehmen wir zum Beispiel die transfer Methode. Das Schema sagt uns, dass wir ein "transfer" Objekt mit einem und einem übergeben "amount" müssen. "recipient"

$ TRANSFER=$('{"transfer":{"amount":100,"recipient":"cudos1d0new9u2f80rcmmlw0zftxeh0385c2gwpmdv8v"}}')

Verwenden Sie den folgenden Befehl, um die Transaktion auszulösen. Beachten Sie, dass Sie dafür Benzin bezahlen müssen, da Sie den Status des Ledgers ändern.

$ docker exec -it binary-builder cudos-noded tx wasm execute $CONTRACT_ADDR --from owner --keyring-backend file --chain-id cudos-testnet-public --node https://sentry1.gcp-uscentral1.cudos.org:26657 --gas auto --gas-adjustment 1.3 -y

Ein Beispiel für eine Abfrage wäre die Überprüfung des Token-Saldos eines Kontos. Dies ändert nichts am Zustand des Ledgers und erfordert daher keine Zahlung für Gas.

$ BALANCE=$('{"balance":{"address":"cudos1d0new9u2f80rcmmlw0zftxeh0385c2gwpmdv8v"}}')

Übergeben Sie das in den folgenden Befehl und Sie erhalten den Saldo der Adresse.

$ docker exec -it binary-builder cudos-noded q wasm contract-state smart $CONTRACT_ADDR $BALANCE --node https://sentry1.gcp-uscentral1.cudos.org:26657

Und los geht’s, Sie haben einen Smart Contract erfolgreich bereitgestellt, instanziiert und mit ihm interagiert! Fühlen Sie sich frei, mit anderen Endpunkten und Verträgen zu experimentieren! Hoffentlich fanden Sie diesen Leitfaden nützlich! Hinterlassen Sie uns eine Klatsche, wenn Sie es getan haben!

Bis zum nächsten Mal!

Weitere Informationen:

Website, Twitter, Telegramm, YouTube, Discord, Medium, Podcast