Cudos Network es una cadena de bloques de propósito especial diseñada para proporcionar computación en la nube de alto rendimiento, sin confianza y sin permisos para todos.

En este tutorial, implementaremos un contrato inteligente cosmWasm en la red de prueba pública de Cudos.

1) Nodo RPC

Primero, tendrás que configurar tu entorno,durante el cual crearás el contenedor de constructor binario, que usaremos para interactuar con la cadena de bloques.

Para cargar el contrato inteligente en la cadena de bloques, también necesitará acceso a un nodo RPC (= nodo completo con el puerto 26657 abierto). Puede usar este, siempre y cuando sea: https://sentry1.gcp-uscentral1.cudos.org:26657 .

Si no tiene accesoa un nodo RPC alojado externamente (es decir, el nodo anterior está inactivo por alguna razón), siempre puede configurar y ejecutar el suyo propio.

2) Óxido

Los contratos inteligentes de CosmWasm están escritos en Rust,por lo que necesitamos instalar el compilador de 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

Descargar un contrato inteligente existente

En aras de la simplicidad, vamos a utilizar el contrato CW20, que despliega un token fungible (al igual que ERC20) en la cadena. Si está intentando implementar su propio contrato inteligente, puede saltar a Compilación.

El contrato inteligente CW20 se puede descargar desde el repositorio CosmWasm/cw-plus en GitHub. Para CUDOS, tendremos que pagar v0.9.0.

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

Compilación

En el directorio raíz del contrato, ejecute el siguiente comando.

# 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

Una vez que haya terminado de compilar, el .wasm ejecutable debe copiarse en el contenedor del generador binario.

# 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

Despliegue

El contrato inteligente CW20 necesita una cuenta de propietario, que entre otras cosas podrá acuñar y quemar tokens. Si aún no tiene una cuenta, cree o recupere una existente que le gustaría usar como propietario del contrato.

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

Para implementar el contrato, la cuenta del propietario necesita algunos tokens CUDOS para pagar la gasolina, así que obtenga algunos del grifo.

Muy bien, estamos listos para implementar el contrato inteligente.

$ 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 salida debe proporcionarle el ID del contrato.

Instanciación

No se puede interactuar con un contrato inteligente implementado a menos que se cree una instancia. La instanciación es esencialmente el proceso de pasar valores personalizados al contrato, como el nombre del token, el símbolo, los decimales, etc., lo que en cierto sentido «da vida al contrato».

Primero establezcamos nuestros parámetros de inicialización personalizados.

$ INIT=$('{"name":"<TOKEN_NAME>","symbol":"<TOKEN_SYMBOL>","decimals":<DECIMALS>,"initial_balances":[<ACCOUNTS>],"mint":{"minter":"<MINTER_ADDR>","cap":"<TOKEN_CAP>">
  • <TOKEN_NAME es > el nombre que le gustaría darle a su token CW20, por ejemplo, «Super Cudos»
  • <TOKEN_SYMBOL es > el denominador de su token CW20, por ejemplo, «scudos»
  • <DECIMALS > es el número de decimales que debe tener su token, por ejemplo, 3 (= el valor más pequeño sería 0.001)
  • <CUENTAS> es una matriz de uno o más objetos JSON como {"address": "<CUDOS_ADDR>","amount":<TOKEN_AMOUNT>} Dónde <CUDOS_ADDR> es el cudos1... dirección que se proporciona <TOKEN_AMOUNT> tokens en la instanciación del contrato, por ejemplo, {"address": "cudos1d0new9u2f80rcmmlw0zftxeh0385c2gwpmdv8v","amount":1000}
  • <TOKEN_CAP > es la cantidad máxima de tokens que el minter puede acuñar, por ejemplo, «10000000000000»

Ahora que hemos personalizado nuestro contrato CW20, vamos a instanciarlo.

$ 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 es > la identificación del contrato que obtuvimos al implementarlo.

Ahora, verifique el estado del contrato para asegurarse de que realmente esté instanciado.

$ 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

Para interactuar con el contrato, necesita la dirección del contrato.

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

Cada contrato debe proporcionar archivos de esquema, que le digan cómo puede interactuar con él, al igual que un ABI en Ethereum. Puede generarlos usted mismo dentro del directorio raíz del repositorio utilizando el siguiente comando.

$ cargo schema

Tomemos el transfer método, por ejemplo. El esquema nos dice que necesitamos pasar un "transfer" objeto, con un y un "amount" "recipient" .

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

Para desencadenar la transacción, utilice el siguiente comando. Tenga en cuenta que tendrá que pagar gasolina por ello, ya que está alterando el estado del libro mayor.

$ 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 ejemplo para una consulta sería comprobar el saldo de tokens deuna cuenta. Esto no altera el estado del libro mayor y, por lo tanto, no requiere pagar por el gas.

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

Pase eso al siguiente comando y obtendrá el saldo de la dirección.

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

¡Y ahí lo tienes, has implementado, instanciado e interactuado con éxito con un contrato inteligente! ¡Siéntase libre de experimentar con otros puntos finales y contratos! ¡Con suerte, esta guía te ha resultado útil! ¡Déjanos un aplauso si lo hiciste!

¡Hasta la próxima!

Aprende más:

Sitio web, Twitter, Telegram, YouTube, Discord, Medium, Podcast