🇵🇹
DAO Lunes Labs - PT
  • 👋Seja Bem-vindo a DAO Lunes Labs
  • Overview
    • 🚪Introdução
    • 🚀Manifesto DAO Lunes Labs
    • 🍕Tokenomics
    • 👑Proposta de Valor
    • 🧑‍🚀Comunidade e Participação
    • 🗺️Roadmap
    • 💼Compromisso com Ética e Responsabilidade
    • 👾Programa de Bug Bounty: Lunes Security Initiative (LSI)
  • Developers
    • 💽Para Nodes
      • 🥾Instalar Node
        • 🏗️Rust toolchain
        • 🐧Linux
    • 🖥️Para Desenvolvedores
      • 📑Smart Contract Ink! 4.x
        • ✨Configuração
          • 📐Criando um projeto com ink!
          • 🖥️Compile Seu Contrato
          • ⛓️Executar um nó Lunes
          • ⬆️Implante seu contrato
          • 🔛Chame Seu Contrato
          • 🛠️Solução de problemas
        • 🪄Fundamentos
          • 👾Modelo de Contrato
          • 👨‍🚀Armazenando Valores
          • 🔭Lendo Valores do Armazenamento
          • 🦸‍♂️Alterando os Valores de Armazenamento
          • 🎡Eventos
          • 👨‍🔧Seletores
          • 🪶Definições de Trait
          • 🗣️Chamadas entre Contratos (Cross-Contract Calls)
          • 🦸Contratos Atualizáveis
          • 🤺Funções do Ambiente
          • 🏟️Tipos de Ambiente de Cadeia
          • 💠Metadados
          • 🧪Testes de Contrato
          • 🕵️‍♂️Depuração de Contratos
          • 🔬Verificação de Contrato
        • 🎙️Macros e Atributos
          • 📇#[ink::contract]
          • 👽#[ink(anonymous)]
          • 👷#[ink(constructor)]
          • 📏#[ink(default)]
          • 🎢#[ink(event)]
          • 🛩️#[ink(impl)]
          • 📧#[ink(message)]
          • 👨‍💼#[ink(namespace = "…")]
          • 💸#[ink(payable)]
          • ⚡#[ink(selector = S:u32)]
          • 💽#[ink(storage)]
          • 💣#[ink(topic)]
          • ⛓️#[ink::chain_extension]
        • 💽Storege & Data Structires
          • Working with Mapping
          • Storage Layout
          • Custom Data Structures
          • Metadata Format
        • 👾Frontend Development
          • Getting Started
          • Connect Wallet
          • Hooks
            • All Hooks
            • Contracts
              • useCall
              • useCallSubscription
              • useContract
              • useDryRun
              • useEventSubscription
              • useEvents
              • useTx
              • useTxPaymentInfo
            • Wallets
              • useWallet
              • useAllWallets
              • useInstalledWallets
              • useUninstalledWallets
            • API
              • useApi
              • useBalance
              • useBlockHeader
          • Configuration
          • useink / core
            • Contracts
              • Call
              • decodeCallResult
              • decodeError
              • getRegistryError
              • toAbiMessage
          • useink / chains
            • Getting Started
            • Chain Configurations
            • ChainId
          • useink / notifications
            • Getting Started
            • Configuration
            • useNotifications
            • toNotificationLevel
          • useink / utils
            • Getting Started
            • Pick Helpers
            • tx Helpers
            • Types
        • 💡Examples
          • 📔Smart Contracts
          • 📱Dapps
        • 🛠️Tools
          • 🖌️OpenBrush
      • 📒Smart Contract - EVM
        • Create ERC-20 Ink Token!
      • 💰Desenvolvendo uma Wallet Lunes
        • 👾Transações de Tokens PSP22
    • 🎨Para Designers
      • 🖌️Brand Lunes
Powered by GitBook
On this page
  • Realizando uma compilação verificável​
  • Verificando um contrato inteligente ink!

Was this helpful?

  1. Developers
  2. Para Desenvolvedores
  3. Smart Contract Ink! 4.x
  4. Fundamentos

Verificação de Contrato

Last updated 1 year ago

Was this helpful?

A verificação de contrato é o processo de corresponder um contrato ink! implantado com o código-fonte e os metadados gerados quando ele foi construído.

O processo de verificação para linguagens de contrato inteligente baseadas em Wasm é mais complexo do que linguagens baseadas em EVM, como o Solidity, devido ao compilador Rust não fornecer compilações determinísticas de contratos.

Para verificar um contrato ink! ou Wasm, o processo de verificação deve recompilar o contrato em um ambiente de hospedagem idêntico ao qual foi originalmente construído. A forma mais simples de fazer isso é usando um contêiner Docker.

Como isso não será possível com contratos inteligentes existentes, foi criado um mecanismo alternativo onde um implantador de contrato pode fornecer um arquivo de metadados assinado para associar ao contrato. Esta abordagem também é detalhada abaixo.

NOTA: No momento atual, a ferramenta CLI cargo-contract não fornece uma imagem Docker para criação de compilações verificáveis do ink!.

A seguinte issue foi criada com detalhes sobre isso. Como solução intermediária, a Web3 Labs está publicando uma imagem de contêiner para verificação do código-fonte de contratos inteligentes ink!.

A Web3 Labs disponibilizou uma versão pública de seu para atender aos ecossistemas ink! e DotSama. Isso pode ser usado em conjunto com o contêiner de imagem de compilação verificável para verificar contratos inteligentes ink!.

Os seguintes passos delineiam como criar uma compilação verificável e posteriormente verificá-la usando esses serviços.

Realizando uma compilação verificável

You should already be familiar with using cargo-contract to .

You will need to install the ink! verified image crate:

Você já deve estar familiarizado com o uso do cargo-contract para .

Você precisará instalar o crate ink-verified-image:

cargo install — git 
https://github.com/web3labs/ink-verifier-image.git

Agora você pode realizar uma compilação verificada executando o seguinte comando na pasta do projeto de contratos inteligentes:

build-verifiable-ink -i ghcr.io/web3labs/ink-verifier .

NOTA: As compilações reproduzíveis só funcionam com o cargo-contract >= 2.0.2 e contratos gerados com essa versão em diante. Para contornar isso, você pode usar o arquivo de metadados assinado.

...
 [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, você pode compilá-la manualmente 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 arquivo zip do pacote disponível que contém o código-fonte do contrato, metadados e o binário Wasm:

tree -L 3
.
├── Cargo.lock
├── Cargo.toml
├── lib.rs
└── target
    └── ink
        └── package.zip

Após a implantação, será necessário anotar o hash do código do contrato para poder verificá-lo.

Verificando um contrato inteligente ink!

Por favor, escreva em português.

O processo de verificação envolve as seguintes etapas:

  1. O solicitante faz o upload do arquivo de pacote de origem para uma rede e hash de código

  2. O servidor verifica o seguinte:

    • O código-fonte para a rede e hash de código não está sendo verificado ou já foi verificado

    • Existem recursos suficientes no host para iniciar uma nova verificação

  3. O servidor faz o download do código Wasm original correspondente à rede e hash de código fornecidos

  4. O servidor transmite o arquivo de arquivamento se for um arquivo compactado

  5. O servidor move os arquivos de encenação para o diretório de processamento

  6. O servidor executa um processo de contêiner para a imagem do verificador para verificar o pacote em processamento. Consulte o fluxo de trabalho de verificação do código-fonte para obter detalhes.

  7. No caso de saída do contêiner, o servidor move os artefatos verificados para o diretório de publicação se a verificação for bem-sucedida, caso contrário, mantém um registro no diretório de erros.

Depois que um contrato for verificado, você poderá usar os endpoints /contract/{codeHash}/metadata.json e /contract/{codeHash}/src para recuperar os metadados e o código-fonte, respectivamente.

Sirato Substrate é um explorador de contratos inteligentes para contratos ink!. Ele integra-se ao serviço de verificação de contratos, permitindo que os usuários façam upload de arquivos de pacote gerados pela imagem de construção verificável por meio da interface do usuário do Sirato, em vez de usar o endpoint da web.

Além disso, uma vez que um contrato tenha sido verificado, os detalhes de qualquer atividade do contrato e eventos que ocorram em uma parachain ou cadeia Substrate são decodificados para o usuário no Sirato.

A partir daí, você pode navegar até o código implantado clicando na referência do código que corresponde ao código hash retornado pela chamada de instanciação do contrato do cargo contract.

Alternativamente, você pode navegar diretamente digitando a URL https://substrate.sirato.xyz/codes/0x<code-hash>.

Agora clique na guia de código-fonte:

Em seguida, faça o upload do arquivo package.zip verificado que você gerou anteriormente.

Agora você pode iniciar o processo de verificação, que inicia uma compilação dos recursos fornecidos.

Ao clicar em "Contract successfully verified", serão exibidos os arquivos de metadados e código-fonte associados ao seu contrato.

Ao clicar em "Procurar arquivos verificados", serão exibidos os metadados e arquivos de código-fonte associados ao seu contrato.

Se voltarmos para a instância do contrato, todos os métodos ou eventos agora serão decodificados.

Podemos verificar isso invocando um método no contrato. Agora podemos ver o método decodificado que foi chamado no Sirato.

Envio de metadados não verificados

O serviço de verificação suporta o envio de metadados de contrato assinados como uma alternativa adicional aos metadados gerados por builds reproduzíveis. Por favor, observe que os metadados assinados não são verificados e o proprietário do código hash é confiável.

Essa funcionalidade responde a:

  1. O suporte para dados de build_info está disponível apenas a partir do cargo-contract 2.0.2.

  2. Ainda não há uma imagem ou procedimento oficial em relação a builds reproduzíveis.

  3. No entanto, queremos expandir a utilidade do serviço nesse meio tempo.

Embora não seja a forma ideal de associar os metadados a um determinado código hash, isso impede a exploração trivial por meio de:

  • Verificar se a assinatura é do proprietário da conta do código hash.

  • Verificar se a mensagem assinada corresponde ao sha256 do metadata.json enviado + o código hash do bytecode do contrato enviado.

Se você estivesse usando o , você veria uma saída semelhante à seguinte:

Agora que você criou a compilação verificada, pode .

Usando o aplicativo web de verificação

O Serviço de é um serviço web RESTful criado para verificar contratos inteligentes implantados usando pallet-contracts.

A Web3 Labs hospeda uma instância pública do serviço em . Uma interface Swagger para o serviço também está disponível em .

Ele funciona com qualquer rede que esteja definida no pacote .

Para verificar um contrato implantado usando o serviço, você precisará usar o endpoint /verify/{network}/{codeHash} , que está documentado .

Usando o Sirato

Por exemplo, para verificar um contrato implantado na parachain Rococo, você pode acessar a instância do Sirato em .

Para fornecer metadados assinados, você precisará usar o endpoint /upload/{network}/{codeHash}, que está documentado .

No corpo da solicitação, você precisará assinar esta mensagem usando a conta que enviou o contrato. Você pode usar a e verificação no Polkadot.js.

Também é possível usar o Sirato para isso, você pode encontrar instruções .

🖥️
📑
🪄
🔬
serviço de verificação
​
compile your contract
compilar seu contrato
exemplo flipper
implantar seu contrato
​
Verificação ink!
ink-verifier.sirato.xyz
ink-verifier.sirato.xyz/api/api-docs/
@polkadot/apps-config
aqui
​
substrate.sirato.xyz
aqui
ferramenta de assinatura
aqui