WEB3DEV

Cover image for Primeiros passos com Solang
ViniBlack for WEB3DEV Blog

Posted on • Atualizado em • Originalmente publicado em solana.com

Primeiros passos com Solang

Bem-vindo a este guia para iniciantes sobre como começar a usar Solang! Solang é um compilador Solidity que permite escrever programas Solana - chamados em outros blockchains como 'contratos inteligentes' ('smart contracts') - usando a linguagem de programação Solidity.

Se você é um desenvolvedor EVM interessado em aproveitar a alta velocidade e as baixas taxas da rede Solana, então Solang é a ferramenta perfeita para você. Com Solang, você pode aproveitar seu conhecimento existente sobre Solidity para começar a construir na Solana!

Instalação

Nesta seção, ajudaremos você a configurar seu ambiente de desenvolvimento para Solang. Basta seguir as etapas descritas abaixo:

1. Verifique seus pré-requisitos: Antes de começar, certifique-se de ter Rust e Node.js instalados em seu sistema. Os usuários do Windows também precisarão ter o Subsistema Windows para Linux configurado.

2. Instalação do Solana Tool Suite: Comece instalando o Solana Tool Suite, que inclui a Solana Command Line Interface (CLI) [Interface de Linha de Comando (ILC) da Solana] e a versão mais recente do Solang.

3. Instalação do Anchor Framework: Em seguida, instale o Anchor Framework. Anchor é uma estrutura amplamente utilizada no ecossistema da Solana e simplifica o processo de construção de programas Solana. Com a versão 0.28, você pode começar a construir com Solang diretamente através do Anchor.

No momento em que este livro foi escrito, instale o Anchor usando o seguinte comando para compatibilidade com Solang versão 0.3.1:

cargo install --git https://github.com/coral-xyz/anchor anchor-cli --locked --force
Enter fullscreen mode Exit fullscreen mode

4. Extensão Solang para VSCode: Se você for um usuário do Visual Studio Code (VSCode), é recomendável instalar a extensão Solang para ajudar no realce de sintaxe. Lembre-se de desabilitar quaisquer extensões ativas do Solidity para garantir que a extensão Solang funcione corretamente.

Criando um novo projeto

Depois de instalar o Solana CLI e o Anchor, você pode criar um novo projeto com o seguinte comando:

anchor init project_name --solidity
Enter fullscreen mode Exit fullscreen mode

Este comando gera um novo projeto com um programa básico Solang on-chain (equivalente a um contrato inteligente em EVM) e um arquivo de teste que demonstra como interagir com o programa do cliente.

Visão geral do programa on-chain

A seguir, vamos examinar o código inicial, começando com o próprio programa on-chain. No diretório ./solidity do seu projeto, você encontrará o seguinte contrato abaixo, que inclui:

  • Um constructor para inicializar uma variável de estado
  • Uma função print para imprimir mensagens nos logs do programa
  • Uma função flip para atualizar a variável de estado
  • Uma função get para retornar o valor atual da variável de estado
@program_id("F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC")
contract starter {
    bool private value = true;

    @payer(payer)
    constructor(address payer) {
        print("Hello, World!");
    }

    /// A message that can be called on instantiated contracts.
    /// This one flips the value of the stored `bool` from `true`
    /// to `false` and vice versa.
    function flip() public {
            value = !value;
    }

    /// Simply returns the current value of our `bool`.
    function get() public view returns (bool) {
            return value;
    }
}
Enter fullscreen mode Exit fullscreen mode

Diferenças importantes

Comparado a um contrato inteligente EVM, existem duas diferenças importantes que você pode notar:

  • A anotação @program_id: No Solana, os contratos inteligentes são chamados de “programas”. A anotação @program_id é usada para especificar o endereço na cadeia do programa.
@program_id("F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC") // on-chain program address
Enter fullscreen mode Exit fullscreen mode
  • A anotação @payer:

Ao armazenar dados em cadeia, uma certa quantidade de SOL precisa ser alocada para cobrir os custos de armazenamento. A anotação @payer específica o usuário que pagará o SOL necessário para criar a conta para armazenamento da variável de estado.

@payer(payer) // payer for the "data account"
constructor(address payer) {
    print("Hello, World!");
}
Enter fullscreen mode Exit fullscreen mode

Armazenamento de dados de estado

Uma distinção importante entre contratos inteligentes EVM e programas Solana é como cada um armazena variáveis/dados de "estado":

  • Os contratos inteligentes EVM podem armazenar diretamente variáveis ​​de estado.
  • Os programas on-chain da Solana, por outro lado, criam contas separadas para armazenar dados do estado. Muitas vezes são chamadas de “contas de dados” e são “de propriedade” de um programa.

Neste exemplo, quando o contrato é implantado, ele é implantado no endereço especificado em @program_id. Quando o constructor é chamado após a implantação do programa, uma conta separada com seu próprio endereço é criada para armazenar a variável de estado, em vez de ser armazenada dentro do próprio contrato.

Isso pode parecer um pouco diferente do que você está acostumado, mas não se preocupe! Vamos examinar o arquivo de teste para esclarecer melhor esse conceito.

Visão Geral do Arquivo de Teste

O arquivo de teste inicial pode ser encontrado no diretório ./tests. Este arquivo fornece um exemplo de como interagir com o programa do cliente.

A Anchor configura o provider e o program para nos ajudar a conectar-nos ao contrato do cliente. Isso é feito usando um arquivo IDL que apresenta a interface pública do programa, semelhante aos arquivos ABI usados ​​em contratos inteligentes EVM. Se você executar a anchor build, o arquivo IDL será gerado e poderá ser encontrado em ./target/idl.

import * as anchor from "@coral-xyz/anchor"
import { Program } from "@coral-xyz/anchor"
import { Starter } from "../target/types/starter"

describe("starter", () => {
  // Configure the client to use the local cluster.
  const provider = anchor.AnchorProvider.env()
  anchor.setProvider(provider)

  const dataAccount = anchor.web3.Keypair.generate()
  const wallet = provider.wallet

  const program = anchor.workspace.Starter as Program<Starter>

  it("Is initialized!", async () => {
    // Add your test here.
    const tx = await program.methods
      .new(wallet.publicKey)
      .accounts({ dataAccount: dataAccount.publicKey })
      .signers([dataAccount])
      .rpc()
    console.log("Your transaction signature", tx)

    const val1 = await program.methods
      .get()
      .accounts({ dataAccount: dataAccount.publicKey })
      .view()

    console.log("state", val1)

    await program.methods
      .flip()
      .accounts({ dataAccount: dataAccount.publicKey })
      .rpc()

    const val2 = await program.methods
      .get()
      .accounts({ dataAccount: dataAccount.publicKey })
      .view()

    console.log("state", val2)
  })
})
Enter fullscreen mode Exit fullscreen mode

No arquivo de teste, primeiro geramos um novo par de chaves que será utilizado para criar a “data account” [conta de dados] que armazena o estado do contrato.

const dataAccount = anchor.web3.Keypair.generate();
Enter fullscreen mode Exit fullscreen mode

A seguir, usamos a new [nova] instrução para criar uma nova conta de dados. Esta instrução corresponde ao constructor do contrato. A conta de dados recém-criada será inicializada para armazenar a variável de estado definida no contrato.

Aqui, o pagador é especificado como wallet.publicKey e o endereço da dataAccount que planejamos criar é fornecido. O par de chaves dataAccount gerado é incluído como um assinante adicional na transação, pois está sendo usado para criar uma nova conta. Essencialmente, isso verifica se possuímos a chave secreta correspondente ao endereço da nova conta que estamos criando.

// Client
const tx = await program.methods
  .new(wallet.publicKey)
  .accounts({ dataAccount: dataAccount.publicKey })
  .signers([dataAccount])
  .rpc()

// on-chain program
@payer(payer)
constructor(address payer) {
    print("Hello, World!");
}
Enter fullscreen mode Exit fullscreen mode

A função get do contrato é então invocada para buscar o valor armazenado no dataAccount especificado.

// Client
const val1 = await program.methods
  .get()
  .accounts({ dataAccount: dataAccount.publicKey })
  .view()

// on-chain program
function get() public view returns (bool) {
        return value;
}

Enter fullscreen mode Exit fullscreen mode

Em seguida, a função flip do contrato é usada para modificar o estado da dataAccount especificada.

// Client
await program.methods
  .flip()
  .accounts({ dataAccount: dataAccount.publicKey })
  .rpc()

// on-chain program
function flip() public {
        value = !value;
}
Enter fullscreen mode Exit fullscreen mode

Se for a primeira vez que estiver mexendo com a solana, é provável que você precise criar um novo par de chaves criptográfica antes de executar os testes.

solana-keygen new
Enter fullscreen mode Exit fullscreen mode

Para executar o teste, use o comando anchor test no terminal.

O comando anchor test executa as seguintes tarefas:

  • Inicie um validador Solana local
  • Crie e implante seu programa on-chain no validador local
  • Execute o arquivo de teste

A seguinte saída deve então ser exibida no console:

Your transaction signature 2x7jh3yka9LU6ZeJLUZNNDJSzq6vdUAXk3mUKuP1MYwr6ArYMHDGw6i15jJnMtnC7BP7zKactStHhTekjq2vh6hP
state true
state false
    ✔ Is initialized! (782ms)
Enter fullscreen mode Exit fullscreen mode

Você pode então inspecionar os logs do programa em ./.anchor/program-logs, onde encontrará a mensagem "Hello, World!" mensagem:

Program F1ipperKF9EfD821ZbbYjS319LXYiBmjhzkkf5a26rC invoke [1]
Program 11111111111111111111111111111111 invoke [2]
Program 11111111111111111111111111111111 success
Program log: Hello, World!
Enter fullscreen mode Exit fullscreen mode

Parabéns! Você construiu com sucesso seu primeiro programa Solana com Solang! Embora possa haver diferenças em comparação com o que você está acostumado com os contratos inteligentes padrão do Solidity, Solang fornece uma excelente ponte para ajudar a aproveitar suas habilidades e experiência existentes em Solidity para desenvolver Solana.

Próximos Passos

Interessado em mergulhar mais fundo? Confira o repositório solana-developers/program-examples. Você encontrará implementações de Solang para casos de uso comuns de Solana nas seções basics e tokens.

Se você tiver dúvidas, sinta-se à vontade para publicá-las no Solana Stack Exchange. Se você tiver dúvidas diretamente para os mantenedores do Solang, entre em contato com eles diretamente na discórdia da Hyperledger Foundation.

Divirta-se construindo!

Fonte:

https://solana.com/developers/guides/solang/getting-started#storing-of-state-data

Top comments (0)