O que é o ink! da Parity?

Por ocasião do ink! utrapassar 1.000 estrelas no Github, mergulhamos profundamente nessa linguagem de programação de contrato inteligente.

ink! é uma linguagem de programação para contratos inteligentes - uma das várias que as blockchains construídas com a estrutura Substrate podem escolher. É uma linguagem opinativa que nós da Parity construímos estendendo a popular linguagem de programação Rust com a funcionalidade necessária para torná-la compatível com contrato inteligente.

Obrigado por ajudar a ink! ultrapassar 1.000 estrelas no GitHub!

O repositório ink! ultrapassou recentemente mil estrelas no GitHub. Agora é o terceiro repositório Parity com mais estrelas no GitHub, depois do Substrate e de Polkadot. Queremos dizer um grande “Obrigado!” a todos que contribuíram para que isso acontecesse! Nos últimos anos, vimos contribuições de todas as formas, trazendo o projeto para onde está hoje. Obrigado por escrever seus contratos em ink!, por criar problemas e solicitações de recebimento, por nos fornecer um feedback bom e construtivo, por responder a perguntas no Substrate StackExchange, por criar ferramentas de terceiros para ink!, por escrever postagens de blog sobre nós, e para a realização de workshops!

Muita coisa aconteceu nos últimos anos no mundo de ink!. O primeiro commit foi em dezembro de 2018 e nossa versão atual é v3.3.1. Estamos trabalhando duro para enviar a próxima grande iteração com a v4.0 em breve. Um ponto em aberto que surge regularmente é que nunca escrevemos uma postagem no blog explicando do início ao fim o que é ink! é e como ele se relaciona com Substrate e Polkadot. Portanto, esta ocasião é uma ótima oportunidade para fazer exatamente isso!

Como ink! se relaciona com o Substrate?

Antes que possamos falar sobre ink! primeiro precisamos esclarecer o que é o Substrate e seu palete de Contratos ((pallet-contracts). Substrate é uma estrutura para a construção de blockchains, que podem ser blockchains autônomas ou blockchains conectadas à Kusama ou Polkadot como as chamadas parachains. O Substrate contém vários módulos, que na terminologia do Substrate são chamados de paletes. O Substrate vem com um conjunto de paletes para muitos requisitos que as blockchains modernas normalmente têm – staking, tokens fungíveis, tokens não fungíveis, governança, etc.

O Substrate também possui um módulo para contratos inteligentes chamado palete de contratos. Se uma parachain for desenvolvida no Substrate, ela poderá adicionar facilmente a funcionalidade de contrato inteligente incluindo esse palete.

Aonde ink! entra no jogo? ink! é uma linguagem de programação, especificamente, é uma linguagem específica de domínio incorporada (eDSL) para a popular linguagem de programação Rust. Isso significa que você pode usar toda a sintaxe normal do Rust, além de alguns detalhes que adicionamos para tornar a linguagem adequada ao mundo dos contratos inteligentes. O palete de Contratos leva os contrato em ink! e os executa de forma segura. Então resumindo:

Com ink! você pode escrever contratos inteligentes em Rust para blockchains construídas com o Substrate que incluem o palete de Contratos.

Contratos inteligentes vs. Parachains

Uma das primeiras perguntas que normalmente recebemos quando alguém aprende sobre Substrate, Polkadot ou Kusama é quando desenvolver uma parachain versus quando desenvolver um contrato inteligente.

A distinção aqui é que, no contexto de Polkadot e Kusama, um parachain aluga um slot por alguns meses ou até dois anos. O acordo com uma concessão é que a parachain obtém um slot fixo para executar sua lógica de negócios (normalmente chamada de função de transição de estado) e pode persistir seu estado modificado em um bloco. Na terminologia do Substrate, essa função de transição de estado é chamada de tempo de execução da cadeia (chain’s runtime).

A distinção para outros ecossistemas aqui é que, no contexto de Polkadot, parachains e contratos inteligentes existem em diferentes camadas da pilha: contratos inteligentes ficam no topo das parachains. Parachains geralmente seriam descritas como blockchains de camada 1 – exceto que eles não precisam construir sua própria segurança e são atualizáveis e interoperáveis.

É digno de nota que a função de transição de estado de uma parachain não é mais validada - cabe à parachain definircomo ela utiliza seu tempo de slot. Depois que uma parachain garante um slot vinculando tokens (ou adquirindo-os de sua comunidade por meio de crowdloan), o slot é essencialmente pré-pago, sem taxas adicionais necessárias para executar a lógica de negócios da cadeia. Isso significa que a parachain pode construir seu próprio mundo (blockchain)! Por exemplo, ela pode decidir como as taxas de transação são cobradas ou até mesmo se as taxas de transação são cobradas. Essas opções são cruciais ao construir modelos de negócios novos ou mais fáceis de usar.

Outros fatores distintivos entre as parachains que observamos na natureza são as diferenças em como a governança da cadeia ou a criptoeconomia funcionam. Existem algumas restrições sobre como a parachain pode construir seu mundo. Como a física no mundo real, ela precisa seguir certas regras básicas. Para Polkadot e Kusama, esse é, por exemplo, o algoritmo de consenso para a Relay Chain se comunicar com a parachain. Dessas regras básicas emergem as vantagens de Polkadot e Kusama. Vantagens como a segurança compartilhada acima mencionada, comunicação entre cadeias ou tempo de execução garantido.

Para contratos inteligentes, por outro lado, uma parachain existente deve incluir o palete de contratos para que os usuários implantem contratos inteligentes. O contrato inteligente implantado é sempre um código não confiável. Qualquer pessoa (ou qualquer programa) que tenha tokens da cadeia pode fazer upload de um contrato inteligente sem precisar de permissão. Os contratos inteligentes permitem a implantação sem permissão de programas independentes de confiança em uma blockchain. O palete de Contratos deve assumir que esses programas são contraditórios, deve colocar vários pilares de segurança para garantir que o contrato não possa, por exemplo, paralisar a cadeia ou causar corrupção estatal de outros contratos. Para o palete de Contratos, esses pilares de segurança incluem mecanismos como medição de gás ou depósitos para armazenamento de dados on-chain.

Para reafirmar essa importante distinção: desenvolver um tempo de execução de parachain é diferente de desenvolver um contrato inteligente – um contrato inteligente fica no topo de um parachain.

A desvantagem é que, com uma parachain, você tem a liberdade de decidir (quase) todas as regras que compõem a parachain. Com um contrato inteligente, fica-se limitado pelo que a cadeia permite e pelos pilares de segurança que necessariamente precisam estar em vigor.

Um contrato inteligente, por outro lado, tem menos atrito para desenvolvê-lo e implantá-lo. Os desenvolvedores não precisam pensar em governança, criptoeconomia etc. Bastam alguns tokens e podem seguir seu caminho, implantando um contrato inteligente. É simples assim.

Como funciona o palete de contrato?

Projetamos intencionalmente o palete de Contratos de forma que seja desacoplado da linguagem usada para escrever contratos inteligentes. O palete é apenas o ambiente de execução e recebe arquivos WebAssembly como entrada. Contratos inteligentes para este palete devem ser compilados para a arquitetura de destino WebAssembly (Wasm).

Para desenvolvedores, isso significa que eles podem usar ink! para escrever contratos inteligentes, mas também podem optar sobre outras linguagens. No momento, existem três linguagens para escolher:

O ink! da Parity para Rust.
ask! para AssemblyScript.
O compilador Solang para Solidity.

Não é difícil adicionar novas linguagens. Só precisa haver um compilador para a linguagem até o WebAssembly, então é possível implementar a API de paletes de contratos. Esta API no momento consiste em cerca de 15-20 funções para qualquer coisa que um contrato inteligente possa desejar: acesso ao armazenamento, funcionalidade criptográfica, informações ambientais como números de bloco, acesso a funções para obter números aleatórios ou rescindir o contrato, etc. Nem tudo isso precisa ser implementado na linguagem — ink! “Hello, World!”requer apenas seis funções de API. O esquema a seguir descreve essa relação:

Achamos que esse design é mais à prova de futuro do que algumas arquiteturas encontradas em ecossistemas concorrentes. Não há um acoplamento rígido entre a linguagem e o ambiente de execução. WebAssembly é um padrão da indústria e uma infinidade de linguagens de programação hoje em dia podem ser compiladas para WebAssembly. Se em, digamos, dez anos, os pesquisadores criarem uma linguagem inovadora para escrever contratos inteligentes (ou um subconjunto de uma linguagem existente), desde que haja um compilador WebAssembly, será fácil tornar essa linguagem compatível com o palete de contratos .

Por que incluir o Palete de Contratos em uma parachain?

Existem alguns casos de uso para incluir a funcionalidade de contrato inteligente em uma parachain. Distinguimos três grandes:

Caso 1: Contratos inteligentes como “cidadãos de primeira classe”

O caso de uso mais óbvio é uma parachain que fornece contratos inteligentes como um “cidadão de primeira classe”, o que significa que os contratos inteligentes são a proposta de valor central da cadeia.

Essas cadeias normalmente pegam o palete de Contrato pronto para uso e criam alguma inovação adicional em cima dele. Exemplos disso são:

Astar: construiu uma camada em cima do palete de Contratos para que os desenvolvedores de contratos possam obter uma renda passiva sempre que seus contratos estiverem sendo usados.
Phala: utiliza o palete de Contratos em um ambiente de execução confiável, permitindo a execução e a interoperabilidade confidenciais de contratos inteligentes.
Aleph Zero: usa o palete de Contratos em um contexto de zero-knowledge.
t3rn: usa o palete Contratos como um bloco de construção para permitir a execução multicadeia para contratos inteligentes.

Caso 2: Contratos inteligentes como “cidadãos de segunda classe”

Há outro caso de uso não tão óbvio para o palete de Contratos: contratos inteligentes como “cidadãos de segunda classe” em uma cadeia existente. Com isso queremos dizer que a proposta de valor central da cadeia não tem nada a ver com contratos inteligentes, mas ainda os inclui como um complemento.

Fornecemos uma API (chamada de extensões de cadeia) com a qual uma parachain pode expor certas partes de sua lógica de negócios para desenvolvedores de contratos inteligentes. Com isso, os desenvolvedores de contratos inteligentes podem utilizar as primitivas da lógica de negócios da cadeia para criar um novo aplicativo sobre ela. Pense, por exemplo, em uma blockchain de corretora descentralizada. Essa cadeia, em sua forma mais simples, teria um livro de pedidos para fazer lances e pedidos - não há necessidade de receber programas não independentes de confiança e completos de fora. A parachain pode decidir expor o livro de pedidos em contratos inteligentes, dando aos desenvolvedores externos a opção de construir novos aplicativos que utilizam o livro de pedidos. Por exemplo, para carregar algoritmos de negociação como contratos inteligentes para a cadeia.

Contratos inteligentes aqui são uma oportunidade para ajudar a aumentar o envolvimento do usuário. E o faturamento pela utilização da cadeia já vem embutido no palete - os usuários precisam pagar taxas de gas para a execução de seu contrato inteligente.

Caso 3: Contratos inteligentes como primeiro passo para Polkadot ou Kusama

Um terceiro grande caso de uso para o palete de contratos é prototipar uma ideia como um contrato inteligente de prova de conceito antes de alugar um slot de parachain dedicado em Polkadot ou Kusama.

O tempo para desenvolver um contrato inteligente e implantá-lo é menor do que a história de integração de uma parachain. Pode-se implantar primeiro um contrato inteligente de prova de conceito, ver se ele ganha força e a ideia se mantém no mundo real. Só posteriormente, uma vez que seja necessário, por exemplo taxas de transação mais baratas, execução mais eficiente ou um mecanismo de governança para a comunidade, o contrato inteligente pode ser migrado para um tempo de execução de parachain dedicado com seu próprio slot. Contratos em ink! e tempos de execução do Substrate são escritos em Rust e compartilham primitivas semelhantes, isso permite um caminho claro para um projeto passar de um contrato inteligente para seu próprio tempo de execução. Os desenvolvedores podem reutilizar grandes partes de seu código, seus testes, bem como front-end e código do client.

Um simples contrato em ink!

ink! é realmente apenas Rust, esse é o nosso objetivo principal. Nosso objetivo é ser minimamente invasivo, permitindo que os desenvolvedores usem tudo o que eles também podem usar para Rust "normal" - IDEs,cargo fmt, cargo clipy, trechos de código, o ecossistema crates.io etc.

Na imagem a seguir você pode ver um contrato simples em ink!. O contrato aqui contém um valor booleano em seu armazenamento. Depois que o contrato é criado, ele define o valor booleano como true. O contrato expõe duas funções: uma para ler o valor atual do booleano (fn get()) e outra para alternar o valor para seu valor booleano oposto (fn flip()).

As linhas coloridas são anotações específicas de no código ink!, o resto é apenas a sintaxe normal do Rust. Essas anotações abstraem o que precisa acontecer nos bastidores para tornar o programa compatível para ser executado na cadeia.

Para nossa versão atual 3.3.1, testes de unidade e integração também podem ser escritos como estão em Rust “normal”:

#[ink::test]fn default_works() {    let flipper = Flipper::default();    assert_eq!(flipper.get(), false);}

A anotação #[ink::test] aqui tem o efeito de executar este teste em um ambiente de blockchain simulado. Isso permite que os desenvolvedores repliquem, por exemplo, o valor que é transferido para um contrato, o caller executando um contrato, o número do bloco etc. Por exemplo, você pode usar ink_env::test::set_value_transferred dentro de um #[ink::test] para simular o valor (ou seja, tokens ) que são enviados para um contrato. Você pode ver a lista completa de funções ink_env em nossa crate docs.

cargo-contract ‒ o canivete suíço para contrato em ink!

Para contruir contratos em ink! você pode usar o fluxo normal cargo build para criar programas em Rust. Você teria que adicionar vários argumentos para o comando para fazê-lo funcionar na cadeia. Criamos uma ferramenta que já escolhe o conjunto de sinalizadores ideal para você: cargo-contract. É uma ferramenta de linha de comando que espelha a carga. Você pode pensar nisso como um canivete suíço para os contrato em ink!, ele pode fazer muito mais além de apenas construir um contrato, mas falaremos sobre isso mais tarde.

Para desenvolver contratos, você usa cargo contract build.. Observe que o comportamento típico de cargo build de Rust é que você precisa fornecer --release se quiser o menor tamanho binário possível, o mesmo com contract build --release. Se você executar este comando, verá que o cargo-contract executa a cargo build "normal" do seu contrato, mas também executa mais algumas etapas. As três etapas adicionais mais importantes são:

Ele roda um linter para contrato em ink!. Este linter funciona de forma análoga ao clippy de Rust, ele verifica seu contrato para uso idiomático de ink!. Estamos melhorando constantemente essa ferramenta de linting e adicionaremos detecções de armadilhas de segurança comuns no futuro.
Ele pós-processa e compacta o binário do seu contrato. Isso é feito para reduzir os custos para usuários que implantam um contrato, bem como as taxas para usuários que interagem com o contrato. O tamanho do contrato também se correlaciona com o rendimento que uma cadeia pode alcançar e contribui para a pegada da cadeia.
Ele gera metadados para o contrato. Com o termo metadados, nos referimos a qualquer informação necessária para interagir com o binário do contrato. O binário em si será apenas um blob WebAssembly — código de byte do contrato que, sem mais informações, não pode interagir. Para saber, por exemplo, quais funções o contrato expõe e quais argumentos essas funções levam é preciso ter os metadados.

Você também pode conhecer esse conceito sob o termo ABI de outras blockchains. No nosso caso, os metadados contêm um pouco mais do que apenas a ABI, mas também contém informações sobre, por exemplo, como o contrato armazena seus dados, o que é útil para ferramentas fora da cadeia (por exemplo, um explorador de blocos) ou documentação legível por humanos sobre as funções do contrato.

Como resultado da cargo contract build, três arquivos são criados:

my_contract.contract: um arquivo JSON que contém o blob WebAssembly do contrato em codificação hexadecimal mais os metadados do contrato.
metadata.json um arquivo JSON que contém apenas os metadados do contrato, sem o blob WebAssembly.
my_contract.wasm: o blob WebAssembly do contrato.

Cada um desses arquivos tem um caso de uso diferente:

O WebAssembly é o único arquivo que é realmente armazenado na cadeia. O armazenamento de dados na cadeia deve ser feito apenas para dados que precisam estar estritamente na cadeia. Qualquer coisa desnecessária na cadeia ainda incorreria em custos para os usuários e aumentaria a pegada da cadeia. Os metadados não precisam estar on-chain, um dapp ou frontend pode conter os metadados codificados para determinar como interagir com o contrato.

O pacote *.contract é necessário apenas se você estiver desenvolvendo um contrato inteligente, então você pode usar esse arquivo com uma IU do desenvolvedor. As interfaces de usuário do desenvolvedor oferecem a capacidade de implantar contratos, interagir com eles e depurá-los.

Ambientes de Desenvolvimento

Várias parachains desenvolveram ferramentas personalizadas que fornecem um ângulo mais específico do contexto no contexto em que utilizam o palete de Contratos e o ink!. Mencionamos algumas dessas equipes no início deste post. Para mais informações, consulte nosso awesome-ink repositório.

Nós, como a equipe de desenvolvimento de ink! e o palete de Contratos, também fornecem algumas ferramentas úteis:

substrate-contracts-node Este repositório contém o node-template do Substrate configurado para incluir pallet-contracts. Este nó está rastreando a ramificação master do Substrate e foi modificado para torná-lo uma ótima opção para desenvolvimento e teste. Por exemplo, não tem nenhum tempo de bloqueio fixo, tudo é processado imediatamente. Isso tem o custo de tornar o nó inadequado para uso em produção, mas ótimo para scripts, testes ou um ambiente de Integração Contínua (CI). Se você estiver procurando por modelos de produção, dê uma olhada no nó do Substrate ou no guia de instruções na documentação do Substrate sobre como adicionar os paletes de Contrato (link aqui).
Mantemos uma rede de teste chamada Contratos no Rococo. Rococo é uma rede de teste para qualquer coisa em Polkadot e Kusama. Muitas parachains estão conectadas à Rococó com suas próprias redes de teste. Você pode ler mais sobre como implantar em nossa rede de teste em nossa documentação.

Há também várias redes de teste da comunidade, você pode encontrar algumas em nosso repositório awesome-ink .

Para UIs do desenvolvedor, existem atualmente três opções:

Contracts UI: Ideal para iniciantes, fornece dicas úteis e auxilia os desenvolvedores.
polkadot.js: Interface avançada que oferece flexibilidade aos desenvolvedores, ao custo de facilidade de uso.
ink! playground: Um playground para experimentar o ink! no navegador ou compartilhar links permanentes para trechos de código. Um uso muito útil é se você estiver fazendo perguntas no Substrate StackExchange: você pode compartilhar código com, por exemplo, um problema que você está enfrentando.
cargo-contract: Se você deseja implantar contratos a partir da linha de comando, chamá-los, decodificar sua saída, etc., esta ferramenta oferece uma opção útil para fazer tudo isso a partir de uma interface de linha de comando. A ferramenta também é perfeita para scripts ou integrações de CI.

Por que escolher essa rota em vez de uma camada de compatibilidade Substrate Ethereum?

Além do palete de Contratos, duas outras opções populares para contratos inteligentes no Substrate são pallet-evm e Frontier. Ambas são camadas de compatibilidade Ethereum para Substrate.

Há uma série de vantagens para escolher a rota de ink! e o palete de Contratos sobre o EVM. Para resumir alguns que foram detalhados neste artigo:

ink! é Rust - você pode usar todas as ferramentas normais de Rust: clippy, crates.io, IDEs etc.
Rust é uma linguagem que incorpora anos de pesquisa linguística, é segura e rápida. Além disso, pegamos grandes aprendizados de linguagens de contrato inteligente mais antigas (como Solidity) e as incorporamos projeto de linguagem ink!. Escolhemos um comportamento padrão mais sensato, como desabilitar a reentrada por padrão ou tornar as funções privadas por padrão.
Rust é uma linguagem incrível para se trabalhar, foi coroada a linguagem de programação mais amada por sete anos consecutivos no StackOverflow (fonte).
Se você é uma empresa e deseja contratar desenvolvedores de contratos inteligentes, pode contratar do ecossistema Rust, que é muito maior do que o nicho de, por exemplo, Desenvolvedores de solidity.
ink! é nativo do Substrate, usamos primitivas semelhantes, como o mesmo sistema de tipos.
Existe um caminho de migração claro para passar de um contrato para uma parachain. Desde ink! ao Substrate são ambos Rust, os desenvolvedores podem reutilizar grandes partes de seu código, seus testes, bem como código frontend e client.
WebAssembly é um padrão da indústria, não é usado apenas no mundo blockchain. Ele é continuamente aprimorado por grandes empresas como Google, Apple, Microsoft, Mozilla e Facebook. No futuro, vamos lucrar com todas as melhorias no padrão e suas implementações. Isso é uma grande coisa. O WebAssembly é usado principalmente para a web, que possui requisitos semelhantes aos blockchains – seguro e rápido.
O WebAssembly expande a família de linguagens disponíveis para desenvolvedores de contratos inteligentes para incluir Rust, C/C++, C#, Typescript, Haxe, Kotlin etc. Isso significa que você pode escrever contratos inteligentes em qualquer linguagem com o qual esteja familiarizado. Achamos que esse design é mais à prova de futuro do que um acoplamento estreito de linguagem e arquitetura de execução.

Oferecemos suporte à interoperabilidade com bases do legado do código Solidity: o projeto HyperLedger Solang compila Solidity para o palete de contratos.

Onde aprender mais?

Nosso portal de documentação pode ser encontrado em ink.substrate.io, ele contém as informações mais abrangentes sobre ink!.
Como ink! é apenas Rust, você também pode conferir os crate docs. Vinculamos crate docs relevantes em nosso readme aqui, por exemplo a crate docs para estruturas de dados está vinculada lá.
Temos vários exemplos de contrato em nosso repositório aqui. Eles cobrem um grande número de casos de uso típicos: ERC-20, contratos atualizáveis, etc.
Se você estiver procurando por um guia de início rápido, oink!'s Guided Tutorial for Beginners é um ótimo ponto de partida.
Caso você esteja interessado no funcionamento interno do ink!, explicamos isso em nosso arquivo ARCHITECTURE.md.
Para o palete de Contratos, o README.md fornece um ponto de partida.

Indo além…

Nossa intenção com este artigo foi fornecer uma visão completa sobre o que é ink!. O próximo grande passo para a ink! é a v4.0.0— nossa próxima grande iteração para a qual já lançamos uma versão alfa. Esta versão trará grandes melhorias nos tamanhos dos contratos, na experiência do desenvolvedor e nos testes nativos de ponta a ponta. Além disso, várias equipes de parachain estão prestes a lançar o palete de Contractos e ink! para Kusama ou Polkadot. As coisas continuam animadas e estamos muito ansiosos pelas próximas mil estrelas.

Caso você fique com alguma dúvida, não hesite em entrar em contato. A melhor maneira de fazer isso é perguntar no Substrate StackExchange ou via https://info.polkadot.network/contact. Se você já estiver compilando, abra uma issue no repositório relevante.

Interessado em construir em Polkadot? Entre em contato