Identifica Cualquier Planta
o Flor al Instante

// BOTANICA Plant NFT — Solana / Anchor
use anchor_lang::prelude::*;
use anchor_spl::token::{self, Token, MintTo};
use mpl_token_metadata::instruction as mpl_ix;

declare_id!("BotaNFT1111111111111111111111111111111111111");

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

  pub fn mint_plant_nft(
    ctx: Context<MintPlantNFT>,
    plant_name: String,
    latin_name: String,
    confidence: u8,
    uri: String,
  ) -> Result<()> {
    // Mint 1 NFT to user wallet
    let cpi_ctx = CpiContext::new(
      ctx.accounts.token_program.to_account_info(),
      MintTo {
        mint: ctx.accounts.mint.to_account_info(),
        to: ctx.accounts.token_account.to_account_info(),
        authority: ctx.accounts.payer.to_account_info(),
      },
    );
    token::mint_to(cpi_ctx, 1)?;

    // Store plant metadata on-chain
    let plant = &mut ctx.accounts.plant_data;
    plant.owner = ctx.accounts.payer.key();
    plant.plant_name = plant_name;
    plant.latin_name = latin_name;
    plant.confidence = confidence;
    plant.mint_time = Clock::get()?.unix_timestamp;
    plant.nft_mint = ctx.accounts.mint.key();
    Ok(())
  }
}

#[account]
pub struct PlantData {
  pub owner: Pubkey,
  pub plant_name: String,
  pub latin_name: String,
  pub confidence: u8,
  pub nft_mint: Pubkey,
  pub mint_time: i64,
}

// $FLORA SPL Token — Botanica Utility Token
use anchor_lang::prelude::*;
use anchor_spl::token::{self, Token, MintTo, Burn};

declare_id!("FLORA111111111111111111111111111111111111111");

pub const TOTAL_SUPPLY: u64 = 1_000_000_000 * 10u64.pow(9); // 1B FLORA
pub const DECIMALS: u8 = 9;

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

  /// Initialize $FLORA mint with fixed supply
  pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
    let cpi_ctx = CpiContext::new(
      ctx.accounts.token_program.to_account_info(),
      MintTo {
        mint: ctx.accounts.mint.to_account_info(),
        to: ctx.accounts.treasury.to_account_info(),
        authority: ctx.accounts.authority.to_account_info(),
      },
    );
    token::mint_to(cpi_ctx, TOTAL_SUPPLY)?;
    Ok(())
  }

  /// Reward user with FLORA on plant scan
  pub fn reward_scan(
    ctx: Context<RewardScan>,
    amount: u64,
  ) -> Result<()> {
    require!(amount <= 100 * 10u64.pow(9), FloraError::ExceedsRewardCap);
    token::mint_to(
      CpiContext::new_with_signer(/* ... */),
      amount
    )?;
    Ok(())
  }

  /// Burn FLORA for premium upgrade
  pub fn burn_for_premium(ctx: Context<BurnPremium>) -> Result<()> {
    let burn_amount = 500 * 10u64.pow(9); // 500 FLORA
    token::burn(
      CpiContext::new(/* ... */),
      burn_amount
    )?;
    ctx.accounts.user_state.is_premium = true;
    Ok(())
  }
}

#[error_code]
pub enum FloraError {
  #[msg("Reward exceeds daily cap")]
  ExceedsRewardCap,
}

// Agent Subscription — Botanica AI Agent Access
use anchor_lang::prelude::*;

declare_id!("AgentSub1111111111111111111111111111111111");

pub const MONTHLY_PRICE: u64 = 50  * 10u64.pow(9); // 50 FLORA/mo
pub const YEARLY_PRICE:  u64 = 500 * 10u64.pow(9); // 500 FLORA/yr
pub const MONTH_SECS:    i64 = 30 * 24 * 3600;

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

  pub fn subscribe(
    ctx: Context<Subscribe>,
    plan: SubscriptionPlan,
  ) -> Result<()> {
    let (price, duration) = match plan {
      SubscriptionPlan::Monthly => (MONTHLY_PRICE, MONTH_SECS),
      SubscriptionPlan::Yearly  => (YEARLY_PRICE,  MONTH_SECS * 12),
    };
    // Transfer FLORA to protocol treasury
    anchor_spl::token::transfer(
      CpiContext::new(/* ... */), price
    )?;
    // Write subscription state on-chain
    let sub = &mut ctx.accounts.subscription;
    sub.subscriber  = ctx.accounts.user.key();
    sub.plan        = plan;
    sub.expires_at  = Clock::get()?.unix_timestamp + duration;
    sub.agent_calls = 0;
    Ok(())
  }

  pub fn verify_active(ctx: Context<VerifySub>) -> Result<bool> {
    let now = Clock::get()?.unix_timestamp;
    Ok(ctx.accounts.subscription.expires_at > now)
  }
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone, PartialEq)]
pub enum SubscriptionPlan { Monthly, Yearly }

#[account]
pub struct Subscription {
  pub subscriber:  Pubkey,
  pub plan:        SubscriptionPlan,
  pub expires_at:  i64,
  pub agent_calls: u32,
}

// BotanicaDAO — On-chain Governance (Solana)
use anchor_lang::prelude::*;

declare_id!("BotaDAO1111111111111111111111111111111111111");

pub const VOTING_PERIOD: i64 = 3 * 24 * 3600; // 3 days
pub const TIMELOCK:      i64 = 2 * 24 * 3600; // 48h execution delay
pub const QUORUM_BPS:    u64 = 500;           // 5% of total supply

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

  pub fn create_proposal(
    ctx: Context<CreateProposal>,
    title: String,
    description: String,
    action: ProposalAction,
  ) -> Result<()> {
    // Require 10,000 FLORA to propose
    require!(ctx.accounts.proposer_balance.amount >= 10_000 * 10u64.pow(9),
             DaoError::InsufficientFloraToPropose);
    let proposal = &mut ctx.accounts.proposal;
    proposal.proposer    = ctx.accounts.proposer.key();
    proposal.title       = title;
    proposal.description = description;
    proposal.action      = action;
    proposal.yes_votes   = 0;
    proposal.no_votes    = 0;
    proposal.end_time    = Clock::get()?.unix_timestamp + VOTING_PERIOD;
    proposal.executed    = false;
    Ok(())
  }

  pub fn cast_vote(
    ctx: Context<CastVote>,
    support: bool,
  ) -> Result<()> {
    let now = Clock::get()?.unix_timestamp;
    require!(now < ctx.accounts.proposal.end_time, DaoError::VotingEnded);
    let weight = ctx.accounts.voter_token.amount;
    if support { ctx.accounts.proposal.yes_votes += weight; }
    else        { ctx.accounts.proposal.no_votes  += weight; }
    Ok(())
  }

  pub fn execute_proposal(ctx: Context<ExecuteProposal>) -> Result<()> {
    let p = &mut ctx.accounts.proposal;
    let now = Clock::get()?.unix_timestamp;
    require!(now >= p.end_time + TIMELOCK, DaoError::TimelockActive);
    require!(p.yes_votes > p.no_votes,     DaoError::ProposalRejected);
    require!(!p.executed,                  DaoError::AlreadyExecuted);
    p.executed = true;
    Ok(())
  }
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub enum ProposalAction {
  UpdateAgentParams { max_calls: u32 },
  AllocateTreasury  { recipient: Pubkey, amount: u64 },
  UpgradeProgram    { new_program_id: Pubkey },
}