19.11.2024

Lição: 070: Construindo Oráculos e Fluxos de Dados em Rust/Solana

No mundo de blockchains e aplicações descentralizadas, oráculos desempenham um papel crucial em trazer dados do mundo real para contratos inteligentes. Esta aula irá guiá-lo pelo processo de construção de um oráculo simples na blockchain Solana usando Rust. Vamos criar um fluxo de dados básico que busca dados externos e os torna disponíveis para contratos inteligentes.

O que é um Oráculo?

Um oráculo é um serviço que fornece dados externos para uma blockchain. Ele atua como uma ponte entre os mundos on-chain e off-chain, permitindo que contratos inteligentes acessem informações do mundo real, como feeds de preço, dados climáticos, ou qualquer outro dado que não esteja inherentemente disponível na blockchain.

Configurando Seu Ambiente

Antes de começarmos a codificar, certifique-se de ter o seguinte instalado:

• Rust (com rustup)
• Solana CLI
• Anchor (para desenvolvimento de contratos inteligentes na Solana)

Você pode criar um novo projeto na Solana usando Anchor com o seguinte comando:

anchor init exemplo_oracle
cd exemplo_oracle

Etapa 1: Definindo Seu Programa de Oráculo

Abra o arquivo Cargo.toml e adicione a biblioteca reqwest para fazer requisições HTTP. Suas dependências podem parecer com isso:

[dependencies]
anchor-lang = "0.16.0"
reqwest = { version = "0.11", features = ["tokio"] }
tokio = { version = "1.0", features = ["full"] }

A seguir, vamos definir a estrutura básica do nosso programa de oráculo. Abra o arquivo lib.rs no diretório programs/exemplo_oracle/src/ e configure o programa:

use anchor_lang::prelude::*;
use reqwest;

declare_id!("SeuIDDoProgramaAqui");

#[program]
mod exemplo_oracle {
    use super::*;

    pub fn buscar_preco(ctx: Context<BuscarPreco>) -> Result<()> {
        let mut conta_oracle = &mut ctx.accounts.conta_oracle;

        // Busca o preço de uma API externa
        let preco = buscar_preco_externo()?;

        // Armazena o preço buscado na conta do oráculo
        conta_oracle.preco = preco;

        Ok(())
    }
}

#[derive(Accounts)]
pub struct BuscarPreco<'info> {
    #[account(mut)]
    pub conta_oracle: Account<'info, ContaOracle>,
}

#[account]
pub struct ContaOracle {
    pub preco: f64,
}

// Não se esqueça de adicionar a função buscar_preco_externo abaixo

Etapa 2: Implementando buscar_preco_externo

Agora vamos implementar a função buscar_preco_externo que realizará a requisição HTTP para buscar dados de uma fonte externa (por exemplo, uma API de feed de preços).

async fn buscar_preco_externo() -> Result<f64, Box<dyn std::error::Error>> {
    let resposta = reqwest::get("https://api.coindesk.com/v1/bpi/currentprice/BTC.json")
        .await?
        .json::<serde_json::Value>()
        .await?;

    // Extraindo o preço do Bitcoin em USD
    let preco = resposta["bpi"]["USD"]["rate_float"]
        .as_f64()
        .ok_or("Falha ao obter preço")?;

    Ok(preco)
}

Certifique-se de incluir tokio::main em sua aplicação Rust para executar as funções assíncronas corretamente.

Etapa 3: Implantando e Interagindo com Seu Oráculo

Uma vez que você tenha definido seu programa, compile-o com:

anchor build

Para implantar o programa na blockchain Solana, execute:

anchor deploy

Interagindo com o Oráculo

Você pode interagir com o oráculo utilizando os recursos de Cliente do Anchor. Abaixo está como você estruturaria o código do cliente. Crie um novo arquivo chamado cliente.rs na raiz do seu projeto:

use anchor_client::solana_sdk::signature::Keypair;
use anchor_client::Client;
use anchor_client::Provider;
use anchor_client::Program;
use anchor_client::Context;

fn main() {
    let provider = Provider::local();
    let client = Client::new_with_options(provider, Keypair::new(), CommitmentConfig::processed());

    let program = client.program("SeuIDDoProgramaAqui");

    let conta_oracle = program
        .request()
        .accounts(conta_oracle)
        .signer(user_keypair)
        .send()
        .unwrap();

    println!("Preço buscado: {:?}", conta_oracle.preco);
}

Conclusão

Nesta aula, construímos um oráculo simples para a Solana usando Rust. Definimos um programa para buscar dados de uma API externa e armazenamos esses dados na blockchain. Este é apenas um exemplo básico; oráculos podem ser mais complexos e suportar múltiplos fluxos de dados, melhores mecanismos de retorno em caso de falha e recursos de segurança.

À medida que você continua a trabalhar com oráculos, considere explorar como gerenciar com segurança a integridade dos dados e a autenticação para manter a confiança nos dados que estão sendo alimentados em suas aplicações descentralizadas.

Feliz codificação e que os dados fluam!

Navigation