Carreira em Blockchain e Web3 com Rust

use anchor_lang::prelude::*;

declare_id!("Fg6PaFpoGXkYsidMpWTK6W2BeZ7FEfcYkg476zPFsLnS");

#[program]
pub mod meu_programa {
    use super::*;

    /// Inicializa um novo contador
    pub fn inicializar(ctx: Context<Inicializar>) -> Result<()> {
        let contador = &mut ctx.accounts.contador;
        contador.valor = 0;
        contador.autoridade = ctx.accounts.autoridade.key();
        msg!("Contador inicializado com valor: {}", contador.valor);
        Ok(())
    }

    /// Incrementa o contador
    pub fn incrementar(ctx: Context<Incrementar>) -> Result<()> {
        let contador = &mut ctx.accounts.contador;
        contador.valor = contador.valor.checked_add(1)
            .ok_or(ErrorCode::Overflow)?;
        msg!("Contador incrementado para: {}", contador.valor);
        Ok(())
    }

    /// Decrementa o contador
    pub fn decrementar(ctx: Context<Decrementar>) -> Result<()> {
        let contador = &mut ctx.accounts.contador;
        require!(contador.valor > 0, ErrorCode::Underflow);
        contador.valor -= 1;
        msg!("Contador decrementado para: {}", contador.valor);
        Ok(())
    }

    /// Reseta o contador (somente autoridade)
    pub fn resetar(ctx: Context<Resetar>) -> Result<()> {
        let contador = &mut ctx.accounts.contador;
        require_keys_eq!(
            contador.autoridade,
            ctx.accounts.autoridade.key(),
            ErrorCode::NaoAutorizado
        );
        contador.valor = 0;
        msg!("Contador resetado");
        Ok(())
    }
}

#[derive(Accounts)]
pub struct Inicializar<'info> {
    #[account(
        init,
        payer = autoridade,
        space = 8 + Contador::INIT_SPACE
    )]
    pub contador: Account<'info, Contador>,
    #[account(mut)]
    pub autoridade: Signer<'info>,
    pub system_program: Program<'info, System>,
}

#[derive(Accounts)]
pub struct Incrementar<'info> {
    #[account(mut)]
    pub contador: Account<'info, Contador>,
}

#[derive(Accounts)]
pub struct Decrementar<'info> {
    #[account(mut)]
    pub contador: Account<'info, Contador>,
}

#[derive(Accounts)]
pub struct Resetar<'info> {
    #[account(mut)]
    pub contador: Account<'info, Contador>,
    pub autoridade: Signer<'info>,
}

#[account]
#[derive(InitSpace)]
pub struct Contador {
    pub valor: u64,
    pub autoridade: Pubkey,
}

#[error_code]
pub enum ErrorCode {
    #[msg("Valor excedeu o limite máximo")]
    Overflow,
    #[msg("Valor não pode ser menor que zero")]
    Underflow,
    #[msg("Somente a autoridade pode executar esta ação")]
    NaoAutorizado,
}

use near_sdk::borsh::{BorshDeserialize, BorshSerialize};
use near_sdk::collections::LookupMap;
use near_sdk::{env, near_bindgen, AccountId, Balance, Promise};

#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct Marketplace {
    pub itens: LookupMap<u64, Item>,
    pub proximo_id: u64,
    pub dono: AccountId,
}

#[derive(BorshDeserialize, BorshSerialize, Clone)]
pub struct Item {
    pub id: u64,
    pub titulo: String,
    pub descricao: String,
    pub preco: Balance,
    pub vendedor: AccountId,
    pub vendido: bool,
}

impl Default for Marketplace {
    fn default() -> Self {
        Self {
            itens: LookupMap::new(b"i"),
            proximo_id: 0,
            dono: env::predecessor_account_id(),
        }
    }
}

#[near_bindgen]
impl Marketplace {
    /// Lista um novo item para venda
    pub fn listar_item(
        &mut self,
        titulo: String,
        descricao: String,
        preco: Balance,
    ) -> u64 {
        let id = self.proximo_id;
        let item = Item {
            id,
            titulo,
            descricao,
            preco,
            vendedor: env::predecessor_account_id(),
            vendido: false,
        };

        self.itens.insert(&id, &item);
        self.proximo_id += 1;

        env::log_str(&format!("Item {} listado com sucesso", id));
        id
    }

    /// Compra um item do marketplace
    #[payable]
    pub fn comprar_item(&mut self, item_id: u64) -> Promise {
        let mut item = self.itens.get(&item_id)
            .expect("Item não encontrado");

        assert!(!item.vendido, "Item já foi vendido");
        assert!(
            env::attached_deposit() >= item.preco,
            "Depósito insuficiente"
        );
        assert_ne!(
            env::predecessor_account_id(),
            item.vendedor,
            "Vendedor não pode comprar próprio item"
        );

        item.vendido = true;
        self.itens.insert(&item_id, &item);

        env::log_str(&format!(
            "Item {} vendido para {}",
            item_id,
            env::predecessor_account_id()
        ));

        // Transferir pagamento ao vendedor
        Promise::new(item.vendedor).transfer(item.preco)
    }

    /// Consulta um item pelo ID
    pub fn ver_item(&self, item_id: u64) -> Option<Item> {
        self.itens.get(&item_id)
    }

    /// Retorna o total de itens listados
    pub fn total_itens(&self) -> u64 {
        self.proximo_id
    }
}

#![cfg_attr(not(feature = "std"), no_std, no_main)]

#[ink::contract]
mod token_simples {
    use ink::storage::Mapping;

    #[ink(storage)]
    pub struct TokenSimples {
        total_supply: Balance,
        balances: Mapping<AccountId, Balance>,
        allowances: Mapping<(AccountId, AccountId), Balance>,
        nome: String,
        simbolo: String,
    }

    #[ink(event)]
    pub struct Transfer {
        #[ink(topic)]
        from: Option<AccountId>,
        #[ink(topic)]
        to: Option<AccountId>,
        value: Balance,
    }

    #[ink(event)]
    pub struct Approval {
        #[ink(topic)]
        owner: AccountId,
        #[ink(topic)]
        spender: AccountId,
        value: Balance,
    }

    #[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
    #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
    pub enum Error {
        SaldoInsuficiente,
        AllowanceInsuficiente,
        TransferenciaParaSiMesmo,
    }

    pub type Result<T> = core::result::Result<T, Error>;

    impl TokenSimples {
        #[ink(constructor)]
        pub fn new(
            supply_inicial: Balance,
            nome: String,
            simbolo: String,
        ) -> Self {
            let caller = Self::env().caller();
            let mut balances = Mapping::default();
            balances.insert(caller, &supply_inicial);

            Self::env().emit_event(Transfer {
                from: None,
                to: Some(caller),
                value: supply_inicial,
            });

            Self {
                total_supply: supply_inicial,
                balances,
                allowances: Default::default(),
                nome,
                simbolo,
            }
        }

        #[ink(message)]
        pub fn nome(&self) -> String {
            self.nome.clone()
        }

        #[ink(message)]
        pub fn simbolo(&self) -> String {
            self.simbolo.clone()
        }

        #[ink(message)]
        pub fn total_supply(&self) -> Balance {
            self.total_supply
        }

        #[ink(message)]
        pub fn saldo_de(&self, owner: AccountId) -> Balance {
            self.balances.get(owner).unwrap_or(0)
        }

        #[ink(message)]
        pub fn transferir(
            &mut self,
            to: AccountId,
            value: Balance,
        ) -> Result<()> {
            let from = self.env().caller();
            self.transferir_de_para(from, to, value)
        }

        fn transferir_de_para(
            &mut self,
            from: AccountId,
            to: AccountId,
            value: Balance,
        ) -> Result<()> {
            if from == to {
                return Err(Error::TransferenciaParaSiMesmo);
            }

            let saldo_from = self.saldo_de(from);
            if saldo_from < value {
                return Err(Error::SaldoInsuficiente);
            }

            self.balances.insert(from, &(saldo_from - value));
            let saldo_to = self.saldo_de(to);
            self.balances.insert(to, &(saldo_to + value));

            self.env().emit_event(Transfer {
                from: Some(from),
                to: Some(to),
                value,
            });

            Ok(())
        }
    }
}

use std::collections::HashMap;
use sha2::{Sha256, Digest};

/// Bloco simplificado de uma blockchain
#[derive(Debug, Clone)]
struct Bloco {
    indice: u64,
    timestamp: u64,
    transacoes: Vec<Transacao>,
    hash_anterior: String,
    hash: String,
    nonce: u64,
}

#[derive(Debug, Clone)]
struct Transacao {
    remetente: String,
    destinatario: String,
    valor: f64,
}

struct Blockchain {
    cadeia: Vec<Bloco>,
    dificuldade: usize,
    transacoes_pendentes: Vec<Transacao>,
    recompensa_mineracao: f64,
}

impl Blockchain {
    fn new(dificuldade: usize) -> Self {
        let mut bc = Blockchain {
            cadeia: Vec::new(),
            dificuldade,
            transacoes_pendentes: Vec::new(),
            recompensa_mineracao: 10.0,
        };
        bc.criar_bloco_genesis();
        bc
    }

    fn criar_bloco_genesis(&mut self) {
        let bloco = Bloco {
            indice: 0,
            timestamp: 0,
            transacoes: Vec::new(),
            hash_anterior: String::from("0"),
            hash: String::from("genesis"),
            nonce: 0,
        };
        self.cadeia.push(bloco);
    }

    fn calcular_hash(
        indice: u64,
        timestamp: u64,
        transacoes: &[Transacao],
        hash_anterior: &str,
        nonce: u64,
    ) -> String {
        let dados = format!(
            "{}{}{:?}{}{}",
            indice, timestamp, transacoes, hash_anterior, nonce
        );
        let mut hasher = Sha256::new();
        hasher.update(dados.as_bytes());
        format!("{:x}", hasher.finalize())
    }

    fn minerar_bloco(&mut self, minerador: &str) -> Bloco {
        self.transacoes_pendentes.push(Transacao {
            remetente: "rede".to_string(),
            destinatario: minerador.to_string(),
            valor: self.recompensa_mineracao,
        });

        let ultimo_bloco = self.cadeia.last().unwrap();
        let indice = ultimo_bloco.indice + 1;
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();
        let hash_anterior = ultimo_bloco.hash.clone();
        let transacoes = self.transacoes_pendentes.clone();

        let prefixo = "0".repeat(self.dificuldade);
        let mut nonce = 0u64;

        let hash = loop {
            let h = Self::calcular_hash(
                indice, timestamp, &transacoes, &hash_anterior, nonce,
            );
            if h.starts_with(&prefixo) {
                break h;
            }
            nonce += 1;
        };

        let bloco = Bloco {
            indice,
            timestamp,
            transacoes,
            hash_anterior,
            hash,
            nonce,
        };

        self.cadeia.push(bloco.clone());
        self.transacoes_pendentes.clear();

        bloco
    }

    fn adicionar_transacao(
        &mut self,
        remetente: &str,
        destinatario: &str,
        valor: f64,
    ) {
        self.transacoes_pendentes.push(Transacao {
            remetente: remetente.to_string(),
            destinatario: destinatario.to_string(),
            valor,
        });
    }

    fn saldo_de(&self, endereco: &str) -> f64 {
        let mut saldo = 0.0;
        for bloco in &self.cadeia {
            for tx in &bloco.transacoes {
                if tx.destinatario == endereco {
                    saldo += tx.valor;
                }
                if tx.remetente == endereco {
                    saldo -= tx.valor;
                }
            }
        }
        saldo
    }
}

fn main() {
    let mut bc = Blockchain::new(2);

    bc.adicionar_transacao("Alice", "Bob", 5.0);
    bc.adicionar_transacao("Bob", "Carol", 2.0);

    println!("Minerando bloco 1...");
    let bloco = bc.minerar_bloco("Minerador1");
    println!("Bloco minerado: #{} hash={}", bloco.indice, bloco.hash);

    println!("\nSaldos:");
    println!("  Alice: {}", bc.saldo_de("Alice"));
    println!("  Bob: {}", bc.saldo_de("Bob"));
    println!("  Carol: {}", bc.saldo_de("Carol"));
    println!("  Minerador1: {}", bc.saldo_de("Minerador1"));
}

// SEMPRE: Verificar autoridade antes de operações críticas
require_keys_eq!(
    ctx.accounts.autoridade.key(),
    cofre.autoridade,
    ErrorCode::NaoAutorizado
);

// SEMPRE: Usar checked_math para operações aritméticas
let novo_saldo = saldo.checked_add(valor)
    .ok_or(ErrorCode::Overflow)?;

// SEMPRE: Atualizar estado ANTES de transferências externas
cofre.saldo -= valor; // Atualiza estado primeiro
transferir_tokens(cofre, destino, valor)?; // Depois transfere

// SEMPRE: Validar inputs
require!(valor > 0, ErrorCode::ValorInvalido);
require!(destino != Pubkey::default(), ErrorCode::EnderecoInvalido);