Em 2009 surgia o Bitcoin, a primeira grande aplicação de sucesso da tecnologia blockchain. No entanto, seu algoritmo interno extremamente focado em transações financeiras P2P não era apropriado para o desenvolvimento de scripts mais complexos ou até mesmo programas de computador inteiros, o que motivou anos mais tarde, em 2014, a criação da blockchain Ethereum, a primeira de segunda geração e que permitia o desenvolvimento de aplicações muito mais robustas que seu antecessor, chamadas de smart contracts. Mais alguns anos se passaram e ficou evidente problemas crônicos na rede Ethereum, frutos da sua própria popularidade e de escolhas à época como manter o Proof of Work do Bitcoin como modelo de consenso: baixa performance e custos altos de transação. Para tentar endereçar esses problemas, a Ethereum seguiu evoluindo, mas as blockchains de terceira geração surgiram para aproveitar esta oportunidade, sendo que em 2017 Anatoly Yakovenko junto de seus dois amigos, Greg Fitzgerald e Eric Williams, viriam a criar a rede Solana, lançada em 2020.

Com tempo de bloco inferior a 1 segundo e taxas inferiores a 1 centavo de dólar por transação, a Solana já em 2021 era vista como a principal concorrente à Ethereum no campo da web3 e da programação para blockchain. Ainda longe da líder de mercado mas crescendo rapidamente e se mostrando muito promissora, é natural que muitos devs interessem-se por aprender a criar aplicações para ela.

A linguagem Rust foi a escolhida para escrever os programas para esta blockchain é ela que você deve estudar se quiser criar aplicações que rodam na Solana, principalmente Dex, Defi, DAOs e é claro, dapps Web3. Uma linguagem veloz, semelhante a C++ e outras linguagens de programação mais rígidas, compiladas e com tipagem estática.

A minha ideia com este tutorial é lhe dar uma introdução no desenvolvimento de programas para Solana, lhe despertando então interesse (e capacidade) por conhecer mais sobre este universo que não pára de crescer. Acredito estar desta forma colaborando com o desenvolvimento de novos profissionais neste meio, principalmente aqueles sem grandes conhecimentos do idioma Inglês, onde você encontra muito material acerca de programação blockchain.

Então vamos lá!

#1 – Ambiente

Primeiro é importante entender que não tem uma única forma de criar os seus programas Solana com Rust. Faremos isso de uma maneira amadora, porém didática, neste tutorial usando uma ferramenta online chamada Solana Playground. Se estiver buscando uma abordagem mais profissional, recomendo o framework Anchor, que já abordei aqui no site neste tutorial.

O Playground é uma IDE online e gratuita para desenvolvimento de programas para Solana. Com ele, não precisaremos configurar absolutamente nada na nossa máquina e os processos de compilação e deploy se tornam extremamente abstraídos. Para usar o Playground basta acessar o site da ferramenta neste link e você poderá criar um novo projeto no botão que vai aparecer na sidebar esquerda.

Voce será questionado do tipo de projeto que deseja criar, além do nome do mesmo. Neste tutorial usaremos o tipo mais recomendado, com Rust + Anchor, um framework que entrarei em mais detalhes em outra oportunidade.

Na pasta src você encontrará o arquivo lib.rs que contém o código do seu programa em Rust (por isso a extensão “.rs”).

O Playground é uma excelente opção para começar com desenvolvimento Solana, embora mais tarde você irá querer trabalhar com algo mais profissional. Nele, você escreverá os programas, os testes e fará deploy, tudo sem sair do seu navegador e eu vou te mostrar isso tudo neste tutorial.

Antes de avançar, é importante você notar no canto inferior esquerdo que diz “not connected”. Isso se refere à carteira cripto, algo necessário para realizar transações na rede Solana, incluindo o deploy que faremos mais à frente. Para resolver essa falta de carteira é simples: clique na mensagem.

Uma janela vai se abrir perguntando se você quer salvar um novo keypair ou importar um já existente. Um keypair é um par de chaves, ou seja, uma chave pública, que é o endereço da sua carteira + uma chave privada, que é o segredo/senha da sua carteira. Caso você já possua uma carteira, você pode importá-la usando a opção correspondente também.

Importante frisar que essa carteira fica salva no seu browser e que se limpar o cache perderá ela. Por isso é importante salvar as informações recebidas caso queira manter o controle da sua carteira em sessões subsequentes.

Após criar ou importar sua carteira, será exibida na status bar a rede que você está conectado (devnet por padrão), o endereço público da sua carteira (que se você clicar abre no explorador de blocos) e o saldo dela. Caso o seu saldo esteja zerado, você pode obter moedas SOL de teste usando o recurso de airdrop nativo da Solana via terminal ou então via faucet oficial.

O comando via terminal pode ser feito no próprio Playground como abaixo, onde solicito 5 SOL.

Já o faucet oficial está disponível neste link, autentique-se no botão do GitHub na página antes de tentar usar ele.

Agora com o projeto, a carteira e o saldo, vamos em frente!

#2 – Criando o Hello World

A parte mais importante pra gente neste primeiro momento fica dentro da pasta src na raiz do projeto. Dentro dela um arquivo lib.rs com um programa de exemplo escrito em Rust, a linguagem oficial para programação na rede Solana, substitua o código inteiro pelo exemplo abaixo, mais simples, que explicarei na sequência.

use anchor_lang::prelude::*;
 
declare_id!("11111111111111111111111111111111");
 
#[program]
pub mod hello_anchor {
    use super::*;
 
    pub fn hello(_ctx: Context<Hello>) -> Result<()> {
        msg!("Hello World from Anchor!");
        Ok(())
    }
}
 
#[derive(Accounts)]
pub struct Hello {}

Na primeira linha temos o carregamento da biblioteca do Anchor, o que vai permitir que todo o código restante funcione corretamente.

Depois na segunda linha temos a declaração do System Program Id ou identificador único deste programa na blockchain Solana. Por padrão ele vem com um placeholder e se você apertar o botão “Build” na sidebar esquerda, vai ver que depois que o build terminar ele vai ser alterado para um valor alfanumérico gerado exclusivamente para seu programa e que jamais poderá ser alterado depois de terminado o desenvolvimento do mesmo.

Uma coisa que você vai notar também nesta segunda linha e em algumas outras chamadas de função do Rust é o uso de exclamação após o nome da função. Bem, na verdade isso é usado justamente quando NÃO temos uma função, mas sim uma macro. A diferença básica entre macro e função é que macros rodam em tempo de compilação, muitas vezes modificando o código final antes da compilação acontecer. Sendo assim, o sinal de exclamação após a chamada indica que ela é uma macro ao invés de função, ok?

Após essa declaração do id, temos o início do módulo público (pub mod) do nosso programa hello_anchor, que é precedida pela macro de atributo “program”. As macros de atributo, como todas as macros, executam logo antes da compilação em si e esta em específico, a program, é um macro exclusiva do framework Anchor. Resumidamente, ela inclui o código do módulo a seguir em um programa Solana “raiz”, inclusive procurando suas funções internas públicas e anexando-as através de identificadores no programa, para que possam ser chamadas corretamente mais tarde, quando estiver na blockchain. Pense que as chamadas chegam na blockchain com id de um programa e de uma função, quem faz essa “cola” entre os dois é essa macro, em tempo de pré-compilação.

Já a linha “use super” é um recurso de herança em Rust, onde estamos dizendo para nosso módulo importar tudo que herdamos de um módulo-base definido pelo Anchor, algo muito comum em linguagens orientadas a objetos. Um módulo em Rust tem a mesma função de uma classe em outras linguagens de programação.

Por fim chegamos na única função do nosso módulo, a hello. Ela é uma public function (pub fn) o que garante que ela poderá ser chamada externamente ao módulo, o que inclui usuários da blockchain mas também outros programas. Toda função Rust em Solana possui a seguinte assinatura:

O conceito de visibility é comum a muitas linguagens de programação e diz respeito ao escopo de visibilidade desta função (quem pode vê-la pode chamá-la). pub torna a declaração a seguir pública, enquanto que a ausência do “pub” diz que a mesma é privada. A keyword fn, de function, precede o nome da função mas é nos parâmetros da função que entram alguns aspectos específicos dos programas Solana.

Toda função vai ter pelo menos um parâmetro, que é o Context. Isso porque em Solana os programas são stateless, ou seja, sem estado, sem contexto. Eles simplesmente não possuem dados, nem para ler, nem para escrever. Qualquer dado que você precise deve ser passado como contexto, aí que entra esse primeiro parâmetro obrigatório. Nele você receberá o contexto da chamada, respeitando um tipo específico que você vai definir mais adiante através de uma struct. Hello neste caso, falaremos dela. Após o contexto, outros parâmetros da função poderiam ser definidos.

Finalizados os parâmetros, terminamos a assinatura da função com o retorno da mesma após “->”, sendo que em função onchain NUNCA temos um tipo sendo retornado, apenas um Result que pode conter sucesso ou erro. Somente funções auxiliares podem retornar dados, como um Result<u64> (retorno de uint 64-bit). Qualquer dado resultante da execução da função deve ser armazenado no context caso deseje persisti-lo para uso posterior.

No interior da função temos uma macro msg!, que serve para enviar mensagens para o terminal, e o retorno da função com sucesso, usando Ok(()).

Fora da função temos a declaração de uma struct. Diferente dos modulos (mod) que servem para definir comportamentos/funções, structs servem para definir estruturas ou tipos de dados. Só que em programas Solana com Anchor e Rust o uso de structs tem alguns esteróides. O primeiro deles você nota pelo uso da macro de atributo “derive” que serve para fazer a desserialização dos dados recebidos no contexto da chamada de uma função do programa. Esses dados ficam em estruturas que chamamos de Accounts, mas que neste exemplo didático não nos importam pois é apenas um Hello World. Por isso que nossa struct Hello, que serve para tipar o contexto, está vazia.

E com isso passamos por todas as linhas do nosso exemplo, se ainda não fez, clique em “Build” para ver se está compilando com sucesso e na sequência vamos fazer o teste do programa.

#3 – Testando o Hello World

Testes são uma parte crucial do desenvolvimento de qualquer software mas programação para blockchain coloca isso em outro patamar. Isso porque como seu programa ficará visível na blockchain e na maioria das vezes ele envolverá dinheiro, é crucial que ele esteja em pleno funcionamento e que seja seguro.

Dito isso, vá até a sua pasta de tests e verá um arquivo anchor.test.ts, ou seja, um arquivo TypeScript para unit testing usando o framework Anchor.

Dentro deste arquivo vamos escrever os testes unitários do nosso programa Rust, para isso o Anchor vai nos fornecer uma série de ferramentas úteis para essa finalidade. Caso esteja familiarizado com suítes de teste como Jest, Tape, Chai ou Jasmine, se sentirá em casa.

Vamos começar excluindo tudo que veio por padrão e colocando o código a seguir. Nenhum import é necessário pois usaremos apenas objetos globalmente disponíveis no Playground.

describe("Test", () => {
  it("Hello World", async () => {
    const txHash = await pg.program.methods.hello().rpc();
    console.log("Transaction signature:", txHash);
  });
});
 

O describe serve para dar uma nome à bateria de testes, enquanto que cada chamada à função it é um cenário de teste diferente. Como é apenas um olá mundo, precisaremos de apenas um teste. O objeto global pg é do Playground, enquanto que a propriedade program referencia o programa que estamos escrevendo. Dentro de program temos os methods, que listam todas as funções públicas que criamos no módulo do lib.rs. Por fim, o comando rpc() envia a chamada para o nó blockchain conectado no canto inferior esquerdo do Playground.

Para que este código funcione, primeiro você tem de clicar em “Build” para garantir que seu programa esteja compilado. Depois, tem de clicar em “Deploy” para que ele fique disponível na devnet. Por último, pode clicar em “Test” para rodar os seus testes e ve se tudo passou com sucesso.

Você vai notar neste primeiro deploy um consumo relativamente alto de SOL na sua carteira de testes. Isso pode soar como “taxas caras” mas é bem diferente desse conceito que trazemos da Ethereum. Na prática, não há taxas para guardar um programa na rede Solana, mas há taxas para manter os dados (bytes) dele lá para sempre. Basicamente o que acontece é um cálculo do tamanho do programa versus uma taxa de “rent” (aluguel) multiplicada por aproximadamente 2 anos, como se fosse um aluguel adiantado, entende? Esse valor fica de “caução” junto à Program Account criada no endereço do programa e garante que ele esteja “rent-exempt” pro resto de sua vida útil. Futuramente, se você vier a encerrar esse programa, você inclusive recebe esse dinheiro de volta usando o comando abaixo (não faça isso agora, vai inutilizar seu programa).

Mas porque estou falando disso junto aos testes?

Como no Solana Playground você deve fazer o build antes de rodar os testes você pode ficar com receio de que saia muito caro testar, mas é aí que você se engana, ao menos no que tange esses múltiplos deploys de teste. Como em Solana os contratos são upgradeables por padrão, quando você re-envia um contrato já existente não é gerado um novo endereço/programId pra ele, mas sim apenas substituímos os bytes antigos pelos novos. Inicialmente é cobrada um novo rent por esse deploy, mas como nosso programa é rent-exempt, ou seja, já tinha pago “aluguel vitalício”, ele não deveria ser cobrado de novo, certo? O rent-exempt foi calculado sobre os bytes antigos, logo um novo cálculo é realizado e uma de três situações acontece:

• se o programa não mudou de tamanho, você recebe de volta as novas taxas que haviam sido cobradas;

• se o programa diminuiu de tamanho, você recebe as taxas + a diferença do depósito original;

• se o programa aumentou de tamanho, você recebe apenas parte das taxas novas, já que precisa pagar o rent da diferença;

Sendo assim, durante os testes, você pagará apenas um deploy cheio, mesmo que faça vários deploys, e ao fim dos testes, pode fechar a Program Account e pegar sua grana de volta.

Apenas atenção: todas chamadas ao programa custam taxas de execução, mesmo as simples como esse nosso hello world. São taxas muito baratas, mas existem, diferentes da Ethereum onde calls/leituras são gratuitas.

E com isso finalizamos o nosso primeiro tutorial de Solana com Rust e Playground aqui do blog. E se estiver preparado para algo ainda mais avançado, bora de Anchor.

Espero que tenha gostado e até o próximo!