16.11.2024

Lição: 048: Implementando Sistemas Oracle na Solana

Sistemas Oracle são elementos cruciais em aplicações de finanças descentralizadas (DeFi), pois fazem a ponte entre dados on-chain e off-chain. Nesta aula, vamos explorar como implementar um sistema Oracle na blockchain Solana. Vamos focar em um design simples que busca e armazena dados de uma API externa.

Visão Geral

Um Oracle é um serviço externo que recupera dados de fora da blockchain e os fornece para contratos inteligentes. No nosso exemplo, criaremos um Oracle básico que busca o preço atual de uma criptomoeda de uma API pública e armazena esse dado na blockchain Solana.

Ferramentas e Bibliotecas

Para implementar nosso sistema Oracle, vamos utilizar as seguintes ferramentas:

• Linguagem de programação Rust
• SDK da Solana
• Uma API pública de preços (por exemplo, CoinGecko)

Etapa 1: Configurando o Ambiente

Certifique-se de que você tenha os seguintes itens instalados e configurados:

• Rust: Instale o Rust usando rustup.
• Solana CLI: Siga as instruções de instalação no site da Solana.

Crie um novo programa Solana:

solana program create oracle_program
cd oracle_program

Etapa 2: Configurando Dependências

Adicione as dependências necessárias ao seu arquivo Cargo.toml:

[dependencies]
solana-program = "1.10.33"
reqwest = { version = "0.11", features = ["blocking", "json"] }
tokio = { version = "1", features = ["full"] }

Etapa 3: Criando o Programa Oracle

No seu arquivo src/lib.rs, implemente a lógica principal do seu programa Oracle:

use solana_program::{
    account_info::AccountInfo,
    entrypoint::ProgramResult,
    pubkey::Pubkey,
    msg,
};

pub struct OracleData {
    pub price: f64,
}

/// O ponto de entrada do programa
#[no_mangle]
pub extern "C" fn process_instruction(
    _program_id: &Pubkey,
    accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    let account = &accounts[0];

    // Em um verdadeiro oracle, buscaríamos dados de uma fonte externa.
    // Para simplicidade, estamos definindo um preço estático.
    let price = 123.45;

    // Armazena o preço nos dados da conta
    let oracle_data = OracleData { price };
    let data = bincode::serialize(&oracle_data).map_err(|e| {
        msg!("Falha ao serializar os dados do oracle: {:?}", e);
        ProgramError::AccountDataTooSmall
    })?;

    if data.len() > account.data_len() {
        msg!("Dados da conta insuficientes.");
        return Err(ProgramError::AccountDataTooSmall);
    }

    account.try_borrow_mut_data()?[..data.len()].copy_from_slice(&data);

    msg!("Preço do oracle atualizado para: {}", price);
    Ok(())
}

Etapa 4: Compilando e Desdobrando o Programa

Agora, compile e desdobre o programa em um cluster local:

cargo build-bpf
solana program deploy target/deploy/oracle_program.so

Etapa 5: Buscando Dados da API

Para buscar dados de uma API externa, podemos criar um binário Rust separado que será executado fora da cadeia. Para isso, crie um novo diretório em seu projeto:

mkdir oracle_client
cd oracle_client

Neste diretório, crie um novo arquivo Cargo.toml:

[package]
name = "oracle_client"
version = "0.1.0"
edition = "2021"

[dependencies]
reqwest = { version = "0.11", features = ["blocking", "json"] }
tokio = { version = "1", features = ["full"] }

Agora, crie um novo arquivo main.rs na pasta src:

use reqwest::blocking::get;
use serde_json::Value;

fn fetch_price_from_api() -> f64 {
    let url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd";
    let response: Value = get(url).unwrap().json().unwrap();
    response["bitcoin"]["usd"].as_f64().unwrap_or(0.0)
}

fn main() {
    let price = fetch_price_from_api();
    println!("Preço atual do Bitcoin: ${}", price);
}

Etapa 6: Executando o Cliente Oracle

Para executar o cliente, utilize os seguintes comandos:

cargo build
cargo run

Isso buscará o preço atual do Bitcoin na CoinGecko.

Etapa 7: Atualizando os Dados On-Chain

Depois de obter o preço da API, você precisará atualizar o oracle on-chain invocando o método que você definiu no contrato inteligente. Você pode usar o Solana CLI ou criar uma função Rust adicional para alcançar isso.

Conclusão

Nesta aula, implementamos um sistema Oracle simples na blockchain Solana. Embora este exemplo seja básico, ele fornece uma base para sistemas Oracle mais complexos. Você pode aprimorar essa arquitetura adicionando recursos como busca de dados de múltiplas fontes, validação de dados e manejo avançado de erros.

Próximos Passos

Explore conceitos mais avançados, como:

• Uso de múltiplas fontes de dados para redundância
• Validação de dados recebidos
• Emprego de provas criptográficas para entrega segura de dados

Boas programações!

Navigation