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
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
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
constructorpara inicializar uma variável de estado - Uma função
printpara imprimir mensagens nos logs do programa - Uma função
flippara atualizar a variável de estado - Uma função
getpara 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;
}
}
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
- 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!");
}
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)
})
})
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();
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!");
}
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;
}
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;
}
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
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)
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!
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
Oldest comments (0)