Create smart_contracts/diamond_rewards.rs

smart_contracts/diamond_rewards.rs

@@ -0,0 +1,139 @@
+// Diamante AI Rewards Program - Solana Smart Contract
+use solana_program::{
+    account_info::{next_account_info, AccountInfo},
+    entrypoint,
+    entrypoint::ProgramResult,
+    msg,
+    program_error::ProgramError,
+    pubkey::Pubkey,
+    system_instruction,
+    sysvar::{rent::Rent, Sysvar},
+    program_pack::Pack,
+};
+use spl_token::state::Account as TokenAccount;
+use std::convert::TryInto;
+
+// Declare program ID
+solana_program::declare_id!("5VqjB57PnrTUSQRoN8skwKtstqPrMFJiZaDGz6BF5FuKhSGSYhbcwPdgKPVNbgtWhi9AkJ8z8HvgaBDzccNHjzE3");
+
+// Instruction types
+#[repr(C)]
+#[derive(Clone, Debug, PartialEq)]
+pub enum DiamondInstruction {
+    /// Reward user with DIAMOND tokens for AI contributions
+    /// Accounts expected:
+    /// 0. [signer] Platform authority
+    /// 1. [writable] User token account
+    /// 2. [writable] Platform token account
+    /// 3. [] Token mint (DIAMANTE)
+    /// 4. [] System program
+    /// 5. [] Token program
+    RewardUser {
+        amount: u64,
+        contribution_type: u8, // 0: inference, 1: training, 2: data, 3: validation
+    },
+    
+    /// Stake DIAMANTE tokens to earn yield
+    StakeTokens {
+        amount: u64,
+        duration: u64, // in seconds
+    },
+    
+    /// Unstake tokens and claim rewards
+    UnstakeTokens {
+        stake_account_bump: u8,
+    },
+    
+    /// Register AI model contribution
+    RegisterModel {
+        model_hash: [u8; 32],
+        performance_score: u8,
+    },
+}
+
+entrypoint!(process_instruction);
+
+pub fn process_instruction(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    instruction_data: &[u8],
+) -> ProgramResult {
+    let instruction = DiamondInstruction::unpack(instruction_data)?;
+    
+    match instruction {
+        DiamondInstruction::RewardUser { amount, contribution_type } => {
+            process_reward_user(program_id, accounts, amount, contribution_type)
+        }
+        DiamondInstruction::StakeTokens { amount, duration } => {
+            process_stake_tokens(program_id, accounts, amount, duration)
+        }
+        DiamondInstruction::UnstakeTokens { stake_account_bump } => {
+            process_unstake_tokens(program_id, accounts, stake_account_bump)
+        }
+        DiamondInstruction::RegisterModel { model_hash, performance_score } => {
+            process_register_model(program_id, accounts, model_hash, performance_score)
+        }
+    }
+}
+
+fn process_reward_user(
+    program_id: &Pubkey,
+    accounts: &[AccountInfo],
+    amount: u64,
+    contribution_type: u8,
+) -> ProgramResult {
+    let accounts_iter = &mut accounts.iter();
+    
+    let authority = next_account_info(accounts_iter)?;
+    let user_token_account = next_account_info(accounts_iter)?;
+    let platform_token_account = next_account_info(accounts_iter)?;
+    let token_mint = next_account_info(accounts_iter)?;
+    let system_program = next_account_info(accounts_iter)?;
+    let token_program = next_account_info(accounts_iter)?;
+    
+    // Verify authority is signer
+    if !authority.is_signer {
+        msg!("Authority must be signer");
+        return Err(ProgramError::MissingRequiredSignature);
+    }
+    
+    // Calculate reward based on contribution type
+    let adjusted_amount = match contribution_type {
+        0 => amount,                    // Inference
+        1 => amount * 2,                // Training (2x reward)
+        2 => amount * 3 / 2,            // Data contribution (1.5x)
+        3 => amount * 5 / 4,            // Validation (1.25x)
+        _ => amount,
+    };
+    
+    // Transfer tokens from platform to user
+    let transfer_instruction = spl_token::instruction::transfer(
+        token_program.key,
+        platform_token_account.key,
+        user_token_account.key,
+        authority.key,
+        &[],
+        adjusted_amount,
+    )?;
+    
+    solana_program::program::invoke(
+        &transfer_instruction,
+        &[
+            platform_token_account.clone(),
+            user_token_account.clone(),
+            authority.clone(),
+            token_program.clone(),
+        ],
+    )?;
+    
+    msg!(
+        "Rewarded user {} with {} DIAMOND tokens for contribution type {}",
+        user_token_account.key,
+        adjusted_amount,
+        contribution_type
+    );
+    
+    Ok(())
+}
+
+// Implementación de stake/unstake y registro de modelos...