Le réseau Cudos est une blockchain spéciale conçue pour fournir un cloud computing haute performance, sans confiance et sans autorisation pour tous.

Dans ce didacticiel, nous allons déployer un contrat intelligent CosmWasm sur le réseau de test public Cudos.

1) Nœud RPC

Tout d’abord, vous devrez configurer votre environnement, au cours duquel vous créerez le conteneur binary-builder, que nous utiliserons pour interagir avec la blockchain.

Pour télécharger le contrat intelligent sur la blockchain, vous aurez également besoin d’accéder à un nœud RPC (= nœud complet avec le port 26657 ouvert). Vous pouvez utiliser celui-ci, tant qu’il est en place: https://sentry1.gcp-uscentral1.cudos.org:26657 .

Si vous n’avez pas accèsà un nœud RPC hébergé en externe (c’est-à-dire que le nœud ci-dessus est en panne pour une raison quelconque), vous pouvez toujours configurer et exécuter le vôtre.

2) Rouille

Les contrats intelligents CosmWasm sont écrits en Rust, nous devons donc installer le compilateur Rust.

# 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

Télécharger un contrat intelligent existant

Par souci de simplicité, nous allons utiliser le contrat CW20, qui déploie un jeton fongible (un peu comme ERC20) sur la chaîne. Si vous essayez de déployer votre propre contrat intelligent, vous pouvez passer à Compilation.

Le contrat intelligent CW20 peut être téléchargé à partir du référentiel CosmWasm/cw-plus sur GitHub. Pour CUDOS, nous devrons vérifier la version 0.9.0.

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

Compilation

Dans le répertoire racine du contrat, exécutez la commande suivante.

# 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

Une fois la compilation terminée, .wasm l’exécutable doit être copié dans le conteneur binary-builder.

# 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

Déploiement

Le contrat intelligent CW20 a besoin d’un compte propriétaire, qui pourra entre autres frapper et brûler des jetons. Si vous n’avez pas encore de compte, veuillez créer ou récupérer un compte existant que vous souhaitez utiliser en tant que titulaire du contrat.

# 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.

Afin de déployer le contrat, le compte propriétaire a besoin de jetons CUDOS pour payer l’essence, alors obtenez-en du robinet.

D’accord, nous sommes prêts à déployer le contrat intelligent.

$ 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

La sortie doit vous donner l’ID du contrat.

Instanciation

Un contrat intelligent déployé ne peut pas être interagi avec à moins qu’il ne soit instancié. L’instanciation est essentiellement le processus de transmission de valeurs personnalisées au contrat, comme le nom du jeton, le symbole, les décimales, etc., ce qui, dans un sens, « donne vie au contrat ».

Définissons d’abord nos paramètres d’initialisation personnalisés.

$ INIT=$('{"name":"<TOKEN_NAME>","symbol":"<TOKEN_SYMBOL>","decimals":<DECIMALS>,"initial_balances":[<ACCOUNTS>],"mint":{"minter":"<MINTER_ADDR>","cap":"<TOKEN_CAP>">
  • <TOKEN_NAME est > le nom que vous souhaitez donner à votre jeton CW20, par exemple « Super Cudos »
  • <TOKEN_SYMBOL est > le dénominateur de votre jeton CW20, par exemple « scudos »
  • <DECIMALS > est le nombre de décimales que votre jeton devrait avoir, par exemple 3 (= la plus petite valeur serait 0,001)
  • <COMPTES> est un tableau d’un ou plusieurs objets JSON tels que {"address": "<CUDOS_ADDR>","amount":<TOKEN_AMOUNT>} où <CUDOS_ADDR> est le cudos1... adresse qui est donnée <TOKEN_AMOUNT> jetons sur l’instanciation du contrat, par exemple {"address": "cudos1d0new9u2f80rcmmlw0zftxeh0385c2gwpmdv8v","amount":1000}
  • <TOKEN_CAP > est la quantité maximale de jetons que le minter peut frapper, par exemple « 100000000000000 »

Maintenant que nous avons personnalisé notre contrat CW20, instancions-le.

$ 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 est > l’ID du contrat que nous avons obtenu en le déployant

Maintenant, vérifiez l’état du contrat pour vous assurer qu’il est réellement instancié.

$ 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

Afin d’interagir avec le contrat, vous avez besoin de l’adresse du contrat.

$ 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')

Chaque contrat doit fournir des fichiers de schéma, qui vous indiquent comment vous pouvez interagir avec lui, un peu comme un ABI dans Ethereum. Vous pouvez les générer vous-même dans le répertoire racine du référentiel à l’aide de la commande suivante.

$ cargo schema

Prenons la transfer méthode par exemple. Le schéma nous indique que nous devons passer dans un "transfer" objet, avec un et un "amount" "recipient" .

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

Pour déclencher la transaction, utilisez la commande suivante. Notez que vous devrez payer de l’essence pour cela, car vous modifiez l’état du grand livre.

$ 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

Un exemple de requête serait de vérifier le solde des jetons d’un compte. Cela ne modifie pas l’état du grand livre et ne nécessite donc pas de payer pour le gaz.

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

Passez cela dans la commande suivante et vous obtiendrez le solde de l’adresse.

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

Et voilà, vous avez déployé, instancié et interagi avec succès avec un contrat intelligent! N’hésitez pas à expérimenter avec d’autres points de terminaison et contrats! J’espère que vous avez trouvé ce guide utile! Laissez-nous un applaudissement si vous l’avez fait!

Jusqu’à la prochaine fois!

Pour en savoir plus:

Site Web, Twitter, Telegram, YouTube, Discord, Medium, Podcast