O ink! é a linguagem de programação do Substrate e é uma escolha popular para desenvolvedores que desejam criar na plataforma. Embora o Solidity seja suportado via Solang, vários desenvolvedores e projetos desejam trabalhar com ink! devido ao uso da linguagem de programação Rust e à compilação em WASM.
Um grande obstáculo para as equipes que trabalham com ink! é o fato dos exploradores blockchain para cadeias Substrate não possuírem um mecanismo para decodificar facilmente as informações sobre as atividades que ocorrem na cadeia. Em vez disso, eles recebem um bytecode legível não-humano.
Isso ocorre devido à falta de um serviço de verificação que pegue o código-fonte e verifique se ele corresponde ao bytecode binário implantado na cadeia.
Mas agora isso é possível graças ao ink! do Web3 Labs! servidor, verificador e explorador do Sirato Substrate.
Este artigo o guiará por todo esse processo, permitindo que você:
Crie um contrato inteligente ink!
Implante-o em um parachain
Verifique seu código-fonte usando o serviço de verificação ink!
Veja o contrato inteligente ink! decodificado em Sirato
Pré-requisitos
Você precisará ter rustup instalado com a versão mais recente do Rust. Se você estiver executando uma versão antiga, atualize-a.
rustup update
Verifique se você adicionou o componente do compilador rust-src.
rustup component add rust-src
Criando um contrato inteligente ink!
O pacote cargo-contract fornece uma CLI para o desenvolvimento de contratos inteligentes usando ink!. Você precisará instalá-lo. As compilações verificáveis (podem ser executadas apenas a partir da versão 2.0.2 em diante —.
cargo install cargo-contract
Para construir o contrato e gerar uma compilação reproduzível, você precisa usar o Serviço de verificador ink ! que geramos para criar compilações verificáveis para os contratos inteligentes ink!. Isso garante que o mesmo ambiente de construção seja usado para implantação e verificação.
Se, no futuro, quando a equipe ink! publicar uma imagem oficial que suporta construções determinísticas, integraremos o Serviço verificador ink! com a imagem oficial.
Isso pode ser instalado usando o seguinte comando:
cargo install — git
[https://github.com/web3labs/ink-verifier-image.git](https://github.com/web3labs/ink-verifier-image.git)
Agora criamos nosso contrato inteligente WASM. Usando o pacote cargo-contract, criamos o contrato flipper, o qual é um contrato simples que contém um valor booleano que pode ser revertido (flipped), daí o nome.
cargo contract new flipper
Mova-o para o diretório do contrato
cd flipper
tree -L 1
.
├── Cargo.lock
├── Cargo.toml
└── lib.rs
Como alternativa, se você estiver trabalhando com um contrato existente, poderá usá-lo. No entanto, verifique se você está usando os contratos versão 2.0.2 ou superior.
Executando uma compilação verificável
Você pode executar a compilação verificável com o seguinte comando:
build-verifiable-ink -i ghcr.io/web3labs/ink-verifier .
Após concluído, você verá uma saída semelhante a abaixo.
...
[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
Se você tiver algum problema ao executar a compilação, poderá verificá-la executando os seguintes 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 .
Agora haverá um pacote de arquivo zip disponível que contém o código-fonte do contrato, os metadados e o binário WASM ( você pode instalar o jq e o tree via homebrew se estiver no OS X ).
tree -L 3
.
├── Cargo.lock
├── Cargo.toml
├── lib.rs
└── target
└── ink
└── package.zip
Em seguida, extraímos os arquivos.
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
Implantando seu contrato inteligente
Agora que você tem uma compilação verificada, implantaremos este contrato na Rede de teste Rococo. Já existe uma instância do Sirato Substrate em execução na Rococo disponível em substrate.sirato.xyz.
Se você precisar de tokens ROC para Rococo, poderá visualizar as instruções para obtê-los aqui.
Agora você pode usar a ferramenta cargo-contract para fazer upload do código para Rococo e implantar uma nova instância do 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"
Depois que o upload e a implantação forem concluídos, você verá detalhes do hash do código e do 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
Executando verificação
Você pode então ir para o Sirato Rococo explorer e procurar o contrato em “Latest Contracts”.
A partir daí, você pode navegar para o código implantado clicando na referência do código que corresponde ao hash do código retornado pela chamada cargo contract instantiate.
Como alternativa, você pode navegar diretamente digitando o URL https://substrate.sirato.xyz/codes/0x.
Agora clique na guia código fonte:
Em seguida, faça o upload do arquivo package.zip que você gerou anteriormente.
Agora você pode iniciar o processo de verificação que inicia uma compilação dos recursos fornecidos.
Depois que o processo terminar, você verá a mensagem Contract successfully verified.
Clicando na Navegação dos arquivos verificados será exibido os metadados associados e os arquivos de origem do seu contrato.
Se voltarmos à nossa instância de contrato, quaisquer métodos ou eventos serão decodificados.
Podemos verificar isso invocando um método no contrato. Para o nosso contrato implantado, invocamos o método flip.
cargo contract call \
--contract 5D4K82dkLh3CLQrSLiRYV8EwY3NBjogAAeyWkZyjLBUcDP9u \
--message flip \
--url wss://rococo-contracts-rpc.polkadot.io \
--suri "your twelve or twenty-four words"
Agora podemos ver o método decodificado chamado no Sirato.
O Sirato suporta outros mecanismos para fornecer metadados para contratos inteligentes. Você pode fazer upload de um arquivo ABI com uma assinatura da conta que implantou o código para fazer isso. Para mais informações, você pode consultar o seguinte tutorial.
Suporte à próxima geração de redes Web3
A capacidade de interpretar com segurança a atividade dos contratos inteligentes ink! na cadeia é essencial para desenvolvedores e usuários de redes Substrate que utilizam esta próxima geração de ferramentas. O Web3 Labs está comprometido em continuar a construir essa infraestrutura para apoiar a comunidade Substrate e Dotsama.
O serviço de verificação pública não se limita à rede Rococo. Ele funciona com quaisquer redes substrates que foram definidas no pacote @polkadot / apps-config. Também é acessível através de sua API, que você pode ver aqui.
Seus usuários, no entanto, exigirão uma instância do explorador Sirato em execução na sua rede para exibir as informações decodificadas sobre atividades e eventos que ocorrem com os contratos inteligentes ink!.
Se você deseja experimentar o explorador do Sirato Substrate, seu repositório GitHub está disponível aqui. No entanto, se você preferir que alguém gere uma instância para sua rede em seu nome, fique à vontade para contactar a equipe e para saber mais sobre as opções de implantação.
Este artigo foi escrito por Conor e traduzido por Adriano P. de Araujo. O original em inglês pode ser encontrado aqui.
Oldest comments (0)