Como Criar Contratos Inteligentes em Solana e Anchor

Implant__e seu contrato na Anchor

O Que é Solana?

Solana é uma plataforma de blockchain descentralizada criada por Anatoly Yakavenko. A Solana tem um tempo de bloco de 400 ms, o que é assustadoramente rápido.

Isto se deve ao seu mecanismo de consenso de prova de história (proof of history, PoH), que na verdade é uma prova de participação, mas com o acréscimo extra de uma variável tempo. A PoH é usada para codificar a passagem de tempo sem necessidade mínima de confiança em um livro-razão (ledger) em uma estrutura de dados apenas anexada.

As blockchains têm que coincidir no tempo antes da submissão de um bloco. Os nós têm que conversar para frente e para trás para determinar o tempo até que cheguem a um acordo sobre isso e isso pode levar muito tempo. A Solana chegou a uma solução com a prova de história para salvar timestamps (carimbos de tempo) para que os nós não tenham que esperar para chegar a um acordo sobre o tempo e eles também tenham uma prova criptográfica para isso.

Para mais informações sobre a prova de história, recomendo que você passe pelo whitepaper da Solana.

O que é Anchor?

A Anchor é uma estrutura para o desenvolvimento de contratos inteligentes Solana que contém várias ferramentas para desenvolvedores. Portanto, basicamente, a Anchor é um salva-vidas e torna realmente fácil o desenvolvimento de contratos inteligentes.

Visão geral do projeto

Neste guia, vamos nos concentrar na configuração do projeto, no funcionamento básico e nos testes.

Criaremos um aplicativo counter que incrementa o contador em um cada vez que chamamos o RPC.

Pré-requisito

Rust — Rust é uma linguagem de programação muito poderosa para fins gerais. Vamos usá-la para o desenvolvimento de contratos inteligentes. Há um ótimo livro disponível para estudar Rust.

Solana Tool Suit — Isto inclui a CLI Solana.

O código para esse projeto pode ser encontrado aqui.

Iniciando

Para começar, crie um novo projeto anchor:

anchor init counterapp

Na estrutura do projeto, você verá os seguintes arquivos e pastas.

program — Este é o diretório de programas da Solana (Contratos inteligentes)

test — Aqui é onde fica o código de teste javascript

migrations — Este é o script de implantação

app — É aqui que o frontend será construído

Vamos olhar nosso arquivo lib.rs no diretório do programa.

use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

#[program]
pub mod counterapp {
   use super::*;
   pub fn initialize(ctx: Context<Initialize>) -> ProgramResult {      
       Ok(())
   }
}
#[derive(Accounts)]
pub struct Initialize {}

Este é o programa mais básico escrito com a CLI. Existe uma função initialize (inicializar) que quando invocada não faz nada além de executar com sucesso. A struct initialize define o contexto da função initialize.

Agora que montamos nosso projeto, vamos construir nosso aplicativo counter.

Para fazer isso, precisamos criar uma conta para armazenar nossos dados. Você deve estar pensando em que diabos é essa conta. As contas são apenas a maneira de armazenar e acessar os dados no Sealevel da Solana. Para maiores informações, recomendo a leitura deste artigo.

No código acima, definimos duas structs, uma chamada CounterAccount que é nossa Account que contém a variável count que vai armazenar nossa contagem.

#[derive(Accounts)]
pub struct Create<'info> {


   #[account(init, payer=user, space = 16+16)]
   pub counter_account: Account<'info, CounterAccount>,


   #[account(mut)]
   pub user: Signer<'info>,


   pub system_program: Program<'info, System>,
}
#[account]
pub struct CounterAccount {
   pub count: u64,
}

A Create é nossa struct de instrução que define nosso contexto para criar uma conta, ou seja, "Ei, eu quero criar uma conta counter_account com 32 bytes de espaço".

Os atributos #[account(...)] definem restrições e instruções no pré-processamento feito pela Anchor para criar contexto. Agora vamos criar nossa função.

pub fn create(ctx: Context<Create>) -> ProgramResult {
   let counter_account = &mut ctx.accounts.counter_account;
   counter_account.count = 0;
   Ok(())
}

A função create é nosso manipulador para solicitações rpc que leva o contexto criado com a struct Create.

Legal. Terminamos com este incrível programa. Agora vamos criar a função de teste e implantar nossa obra-prima.

import * as anchor from '@project-serum/anchor';
import { Program } from '@project-serum/anchor';
import { Counterapp } from '../target/types/counterapp';
describe('counterapp', () => {
   const provider = anchor.Provider.env()
   anchor.setProvider(provider);
   const program = anchor.workspace.Counterapp as Program<Counterapp>;
   const counterAccount = anchor.web3.Keypair.generate();
   it('Is initialized!', async () => {
       await program.rpc.create({
           accounts: {
               counterAccount: counterAccount.publicKey,
               user: provider.wallet.publicKey,
               systemProgram: anchor.web3.SystemProgram.programId,
           },
           signers: [counterAccount]
       } as any)
   });
   it("Increment counter", async () => {
       await program.rpc.increment({
           accounts: {
               counterAccount: counterAccount.publicKey
           }
       } as any)
   })
   it("Fetch account", async () => {
       const account: any = await
       program.account.counterAccount.fetch(counterAccount.publicKey)
       console.log(account.count)
   })
});

Agora, execute o teste.

anchor test

Após a aprovação do teste, podemos agora implantar o programa. Certifique-se de que solana-test-validator está sendo executado.

anchor deploy

Obrigado por ler.

Este artigo foi escrito por Anmol Dhiman e traduzido por Fátima Lima. O original pode ser lido aqui.

Aumente a eficiência e segurança de suas transações na Solana com transações versionadas. Aprenda a utilizá-las em seus projetos!