"Ink!" es el lenguaje de programación de Substrate y es una opción popular entre los desarrolladores que desean crear en la plataforma. Aunque Solidity sea compatible a través de [Solang],(https://github.com/hyperledger/solang) varios desarrolladores y proyectos desean trabajar con ink! debido al uso del lenguaje de programación Rust y a la compilación en WASM.
Un gran obstáculo para los equipos que trabajan con ink! es el hecho que los exploradores de blockchain para cadenas Substrate no poseen un mecanismo para decodificar fácilmente la información sobre las actividades que ocurren en la cadena. En su lugar, reciben un bytecode no legible para los humanos.
Esto ocurre debido a la falta de un servicio de verificación que tome el código fuente y verifique si coincide con el bytecode binario desplegado en la cadena.
Pero ahora esto es posible gracias a ink! de Web3 Labs. Un servidor, verificador y explorador para Sirato Substrate.
Este artículo te guiará a través de todo este proceso, permitiéndote:
- Crear un contrato inteligente en ink!
- Desplegarlo en una parachain.
- Verificar su código fuente utilizando el servicio de verificación de ink!
- Observar el contrato inteligente en ink! decodificado en Sirato.
Prerrequisitos
Necesitarás tener rustup instalado con la versión más reciente de Rust. Si estás utilizando una versión antigua, actualízala.
rustup update
Verifica si has añadido el componente del compilador rust-src.
rustup component add rust-src
Creando un contrato inteligente en ink!
El paquete cargo-contract proporciona una interfaz de línea de comandos (CLI) para desarrollar contratos inteligentes utilizando ink!. Deberás instalarlo (las compilaciones verificables sólo se pueden realizar a partir de la versión 2.0.2 en adelante).
cargo install cargo-contract
Para construir el contrato y generar una compilación reproducible, necesitas utilizar el Servicio de verificación de ink! que hemos creado para generar compilaciones verificables para los contratos inteligentes en ink! Esto asegura que se utilice el mismo entorno de construcción para la implementación y la verificación.
Si en el futuro, cuando el equipo de ink! publique una imagen oficial que admita construcciones determinísticas, integraremos el Servicio Verificador de ink! con la imagen oficial.
Esto se puede instalar usando el siguiente comando:
cargo install — git
[https://github.com/web3labs/ink-verifier-image.git](https://github.com/web3labs/ink-verifier-image.git)
Ahora, hemos creado nuestro contrato inteligente WASM. Utilizando el paquete cargo-contract, creamos el contrato flipper, que es un contrato simple que contiene un valor booleano que puede invertirse (flipped), de ahí el nombre.
cargo contract new flipper
Muévelo al directorio del contrato.
cd flipper
tree -L 1
.
├── Cargo.lock
├── Cargo.toml
└── lib.rs
Como alternativa, si estás trabajando con un contrato existente, puedes utilizarlo. Sin embargo, asegúrate que estés utilizando contratos en la versión 2.0.2 o superior.
Realizando una compilación verificable
Puedes realizar la compilación verificable con el siguiente comando:
build-verifiable-ink -i ghcr.io/web3labs/ink-verifier .
Una vez finalizado, verás una salida similar a la siguiente:
...
[5/5] Generating bundle
Original wasm size: 20.6K, Optimized: 1.4K
The contract was built in RELEASE mode.
Your contract artifacts are ready. You can find them in:
/build/package/src/target/ink
- flipper.contract (code + metadata)
- flipper.wasm (the contract's code)
- flipper.json (the contract's metadata)
adding: src/ (stored 0%)
adding: src/Cargo.lock (deflated 75%)
adding: src/Cargo.toml (deflated 52%)
adding: src/lib.rs (deflated 72%)
adding: flipper.contract (deflated 64%)
Verification package in /build/target/ink/package.zip
Archive: /build/target/ink/package.zip
Length Date Time Name
--------- ---------- ----- ----
0 2023-03-08 21:41 src/
105695 2023-03-08 21:28 src/Cargo.lock
573 2023-03-08 20:40 src/Cargo.toml
5177 2023-03-08 20:40 src/lib.rs
5278 2023-03-08 21:41 flipper.contract
--------- -------
116723 5 files
Si encuentras algún problema al ejecutar la compilación, puedes verificarla ejecutando los siguientes comandos:
cd ../
git clone https://github.com/web3labs/ink-verifier-image.git
cd ink-verifier-image
docker build . -t ink-verifier:develop
cd ../flipper
build-verifiable-ink -t develop .
Ahora, habrá un archivo de paquete zip disponible que contiene el código fuente del contrato, los metadatos y el binario WASM (puedes instalar jq y tree a través de homebrew si estás en OS X).
tree -L 3
.
├── Cargo.lock
├── Cargo.toml
├── lib.rs
└── target
└── ink
└── package.zip
A continuación, extraeremos los archivos.
unzip -qq -p target/ink/package.zip "*.contract" > target/ink/flipper.contract
unzip -qq -p target/ink/package.zip "*.contract" | jq "del(.source.wasm)" > target/ink/metadata.json
unzip -qq -p target/ink/package.zip "*.contract" | jq -r ".source.wasm" | xxd -r -p > target/ink/flipper.wasm
Desplegando tu contrato inteligente
Ahora que tienes una compilación verificada, desplegaremos este contrato en la Red de prueba Rococo. Ya hay una instancia de Sirato Substrate en funcionamiento en Rococo disponible en substrate.sirato.xyz.
Si necesitas tokens ROC para Rococo, puedes ver las instrucciones para obtenerlos aquí.
Ahora puedes utilizar la herramienta cargo-contract para cargar el código en Rococo y desplegar una nueva instancia del contrato.
cargo contract instantiate \
--constructor new \
--args false \
--url wss://rococo-contracts-rpc.polkadot.io \
--suri "your twelve or twenty-four word wallet seed phrase"
Una vez que se haya completado el upload y el despliegue, verás los detalles del hash del código y del contrato listados.
Dry-running new (skip with --skip-dry-run)
Success! Gas required estimated at Weight(ref_time: 330944206, proof_size: 0)
Confirm transaction details: (skip with --skip-confirm)
Constructor new
Args false
Gas limit Weight(ref_time: 330944206, proof_size: 0)
Submit? (Y/n):
Events
Event Balances ➜ Withdraw
who: 5Gc1RWvH2MtDYB7NKrMEuMsVTMApG3rCjYjPpYvZ8yh2yD3X
amount: 52.442068μROC
...
Code hash 0xbb42a8a8f4c8478c402eda3bca3cf86c6495e9e5c9eb41900c69e05ce15217bb
Contract 5D4K82dkLh3CLQrSLiRYV8EwY3NBjogAAeyWkZyjLBUcDP9u
Realizando la Verificación
Luego, puedes dirigirte al Sirato Rococo explorer y buscar el contrato en "Latest Contracts".
Desde allí, puedes navegar hasta el código desplegado, haciendo clic en la referencia del código que corresponde al hash del código devuelto por la llamada cargo contract instantiate.
Como alternativa, también puedes navegar directamente ingresando la URL https://substrate.sirato.xyz/codes/0x.
Ahora haz clic en la pestaña "Código fuente":
A continuación, carga el archivo package.zip que generaste anteriormente.
Ahora puedes iniciar el proceso de verificación, que inicia una compilación de los recursos proporcionados.
Una vez que el proceso haya finalizado, verás el mensaje Contract successfully verified
Al hacer clic en la navegación de archivos verificados, se mostrarán los metadatos asociados y los archivos fuente de tu contrato.
Si volvemos a nuestra instancia del contrato, cualquier método o evento será decodificado.
Podemos verificar esto invocando un método en el contrato. Para nuestro contrato implantado, invocaremos el método flip.
cargo contract call \
--contract 5D4K82dkLh3CLQrSLiRYV8EwY3NBjogAAeyWkZyjLBUcDP9u \
--message flip \
--url wss://rococo-contracts-rpc.polkadot.io \
--suri "your twelve or twenty-four words"
Ahora podemos ver el método decodificado llamado en Sirato.
Chainlens admite otros mecanismos para proporcionar metadatos a los contratos inteligentes. Puedes cargar un archivo ABI con una firma de la cuenta que implementó el código para hacerlo. Para obtener más información, puedes consultar el siguiente tutorial.
Soporte para la próxima generación de redes Web3
La capacidad de interpretar de manera segura la actividad de los contratos inteligentes ink! en la cadena es esencial para los desarrolladores y usuarios de redes Substrate que utilizan esta próxima generación de herramientas. Web3 Labs está comprometido a seguir construyendo esta infraestructura para apoyar a la comunidad Substrate y Dotsama.
El servicio de verificación público no se limita a la red Rococo. Funciona con cualquier red Substrate que haya sido definida en el paquete @polkadot / apps-config. También es accesible a través de su API, la cual puedes ver aquí.
Sin embargo, los usuarios necesitarán una instancia del explorador Chainlens en funcionamiento en tu red para mostrar la información decodificada sobre las actividades y eventos que ocurren con los contratos inteligentes ink!.
Si deseas probar el explorador del Chainlens Substrate, su repositorio de GitHub está disponible aquí. Sin embargo, si prefieres que alguien genere una instancia para tu red en tu nombre, no dudes en ponerte en contacto con el equipo para obtener más información sobre las opciones de implementación.
Este artículo fue escrito por Conor y traducido por Juliana Cabeza. La versión original en inglés se puede encontrar aquí.
Discussion (0)