Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Implantar um Contrato Inteligente de Armazenamento Simples na StarkNet
Panegali
Panegali

Posted on

Implantar um Contrato Inteligente de Armazenamento Simples na StarkNet

#starknet #contratointeligente #cairo

A StarkNet e os rollups de conhecimento zero estão ganhando popularidade ultimamente devido à sua eficiência, então é hora de aprender como desenvolver na StarkNet. Este tutorial mostrará como criar um contrato inteligente simples em Cairo para salvar e recuperar uma variável e, em seguida, implantá-la na rede de teste StarkNet usando a framework (estrutura) ProtoStar.

Você pode encontrar o projeto com o contrato inteligente e os arquivos compilados na pasta protostar-project do repositório GitHub.

Se você quiser aprender alguns fundamentos da StarkNet, recomendo a leitura deste artigo sobre a arquitetura e o ambiente da StarkNet.

Um contrato inteligente do Cairo

O Cairo é uma linguagem relativamente nova que capacita contratos inteligentes na StarkNet; vale a pena aprender mais sobre isso! O contrato inteligente que você implantará hoje é muito semelhante a um contrato de armazenamento simples com o qual você provavelmente está familiarizado no Solidity.

Neste tutorial, escreveremos um contrato inteligente direto, mas ele ensinará como declarar uma variável, escrever uma função getter e escrever uma função para definir a variável.

O contrato inteligente principal

A primeira coisa que precisamos é declará-lo como um contrato StarkNet e importar o pacote 'HashBuiltin'.

%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
Enter fullscreen mode Exit fullscreen mode

Como você pode notar, estamos importando um pacote, o HashBuiltin é uma struct especificando a estrutura hash da memória interna. Você pode aprender mais sobre este pacote na StarkNet e no Cairo Docs.

Neste ponto, podemos continuar declarando a variável.

Declare uma variável

Assim como o Solidity, precisamos declarar uma variável para usá-la. Neste exemplo, a variável é um 'felt', chamado 'my_value_storage', onde basicamente podemos armazenar um número.

@storage_var
func my_value_storage() -> (my_value_storage: felt) {
}
Enter fullscreen mode Exit fullscreen mode

As variáveis ​​de armazenamento, por padrão, não são visíveis na ABI. Elas são semelhantes às variáveis ​​“private” no Solidity.

Uma variável de armazenamento pode ser lida com 'var_name.read()' ou gravada com 'var_name.write()'.

Função getter

Quando usamos variáveis, é uma boa prática declarar uma função 'getter'. Então, podemos adicionar isso também!

Uma getter é uma função view que podemos chamar para ver a variável armazenada.

@view
func get_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
    my_stored_value: felt
) {
    let (my_stored_value) = my_value_storage.read();
    return (my_stored_value,);
}
Enter fullscreen mode Exit fullscreen mode

Por exemplo, esta função pode ser chamada do explorador StarkNet e exibir o valor armazenado.

Função para definir a variável

Agora que temos a variável declarada, como a modificamos? \
Poderíamos configurá-la automaticamente quando o contrato for implantado com um 'construtor', mas para este tutorial, quero criar uma função para ela.

Esta é uma função 'external', que pode ser chamada por outro contrato inteligente (ou carteira), nos permitindo modificar aquela variável!

@external
func set_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
my_value: felt,
) {
    my_value_storage.write(my_value);
    return ();
}
Enter fullscreen mode Exit fullscreen mode

Como você notou, na função para definir um valor armazenado, usamos my_value_storage.write(my_value), onde my_value é o argumento passado pela função.

Contrato inteligente completo

Agora que temos todas as partes separadas, podemos juntá-las. Aqui você encontrará todo o contrato inteligente, com alguns comentários.

%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin
// Armazenar uma variável
// Por padrão, as variáveis de armazenamento não são visíveis por meio da ABI. Elas são semelhantes às variáveis "privadas" do Solidity.
// Essa variável é um felt e é chamado my_value_storage
// Em um contrato inteligente, ele pode ser lido com my_value_storage.read() ou gravado com my_value_storage.write()
@storage_var
func my_value_storage() -> (my_value_storage: felt) {
}
// Declarando getters
// As variáveis públicas devem ser declaradas explicitamente com um getter
// Função para retornar o valor da variável.
@view
func get_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}() -> (
    my_stored_value: felt
) {
    let (my_stored_value) = my_value_storage.read();
    return (my_stored_value,);
}
// Definir o valor da variável.
@external
func set_my_stored_value{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_check_ptr}(
my_value: felt,
) {
    my_value_storage.write(my_value);
    return ();
}
Enter fullscreen mode Exit fullscreen mode

Um projeto Protostar

Para este exemplo, usaremos a Protostar, uma das frameworks Starknet.

Primeira coisa, instale a Protostar.

Observe que a Protostar é compatível apenas com Linux e macOS.

Inicializar um projeto Protostar

Após instalar a Protostar, criaremos um projeto usando o seguinte comando.

protostar init store-variable
Enter fullscreen mode Exit fullscreen mode

Onde store-variable é o nome do projeto.

O resultado da execução da protostar init é um arquivo de configuração protostar.toml, arquivos de exemplo e os 3 diretórios a seguir:

  • src — Um diretório para o seu código.
  • lib — Um diretório padrão para dependências externas.
  • testes — Um diretório que armazena testes.

O arquivo protostar.toml é o arquivo de configuração onde especificamos o caminho para nossos contratos; neste caso, você já terá um arquivo cairo.main de exemplo.

Neste caso, geraremos um contrato nomeado main a partir de nossa pasta src.

["protostar.contracts"]
main = [
    "src/main.cairo",
]
Enter fullscreen mode Exit fullscreen mode

Simplesmente exclua o código de exemplo e cole o código do nosso contrato inteligente.

Compile o contrato inteligente do Cairo

Inicializamos um projeto Protostar e há um contrato inteligente do Cairo na pasta src; estamos prontos para compilar.

No diretório principal do projeto, execute o seguinte comando para compilar.

protostar build
Enter fullscreen mode Exit fullscreen mode

Você receberá uma mensagem de sucesso se o contrato for compilado corretamente.

16:23:13 [INFO] Built the project successfully                                                                                                             
16:23:14 [INFO] Execution time: 2.96 s
Enter fullscreen mode Exit fullscreen mode

Após a compilação do contrato, você notará um diretório build no projeto, onde poderá encontrar a ABI do contrato e o contrato compilado como main.json.

Implante o contrato inteligente na rede de testes da StarkNet

Depois que o contrato inteligente foi compilado, podemos finalmente usar a Protostar para implantá-lo na rede de testes da StarkNet.

Use o seguinte comando para implantar o contrato compilado.

protostar deploy ./build/main.json --network testnet
Enter fullscreen mode Exit fullscreen mode

O resultado mostrará o hash da transação e o endereço do contrato e fornecerá um link para o contrato inteligente no explorador Voyager.

[INFO] Deploy transaction was sent.
Contract address: 0x06a5ea9e42c921bd58e24b8da9d1fc91a488df0700b173f1c6bb0e453f68afec
Transaction hash: 0x1cbba90ba0d1fbfba09b1f7a0f987134dd9a02a845ca89244b3272374d37ede
https://goerli.voyager.online/contract/0x06a5ea9e42c921bd58e24b8da9d1fc91a488df0700b173f1c6bb0e453f68afec
Enter fullscreen mode Exit fullscreen mode

Interagir com o contrato implantado

Agora que o contrato inteligente foi implantado na rede de testes da StarkNet, você pode usar o explorador Voyager para interagir com ele.

Você pode usar o contrato inteligente que implantamos se ainda precisar implantar o seu.

Use a guia Read Contract para chamar a função view e ver o valor armazenado.

Em seguida, você pode usar a guia Write Contract para chamar à função external e modificar o valor.

Ao escrever um contrato, altere o estado da rede; você precisará autorizar a transação, então lembre-se de conectar sua carteira ao explorador Voyager e ter algumas ETH de teste.

Você pode obter algum Goerli ETH na L2 da tornera da StarkNet.

Conclusão

Parabéns por concluir este tutorial. Hoje você aprendeu a escrever e implantar um contrato inteligente simples no Cairo!

Confira nossa série StarkNet Odyssey para saber mais sobre o Cairo e mais ferramentas de desenvolvedor disponíveis.

Você já explorou o que pode conseguir com o Chainstack? Comece gratuitamente hoje.

Artigo escrito por Davide Zambiasi. Traduzido por Marcelo Panegali.

Top comments (0)


Leia o próximo

diogojorg3 profile image

Abstração de Conta nativa: abrindo a Blockchain para novas possibilidades

Diogo Jorge -

devaraujo profile image

Uma Introdução Completa ao Desenvolvimento de Contratos Inteligentes na Scroll zkEVM

Adriano P. Araujo -

paulogio profile image

Série Raio X Solidity: Dominando o Armazenamento — Parte 2

Paulo Gio -

paulogio profile image

Construa um DApp Simples usando o Padrão de Token ERC-4671

Paulo Gio -