Theresa NFT Technical Specification

#[program]
pub mod theresa_nft {
    use anchor_lang::prelude::*;
    use mpl_token_metadata::state::{Metadata, TokenMetadata};
    
    pub struct TheresaNFT {
        pub authority: Pubkey,
        pub total_supply: u64,
        pub minted: u64,
        pub price: u64,  // In lamports
        pub is_active: bool,
        pub treasury: Pubkey,
    }

    pub struct PlotMetadata {
        pub plot_id: u16,
        pub coordinates: (f64, f64),  // Latitude, Longitude
        pub plot_size: f64,           // In acres (0.1)
        pub terrain_type: String,
        pub features: Vec<String>,
        pub rarity_score: u8,
    }
}

#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(init, payer = authority, space = 8 + 32 + 8 + 8 + 8 + 1 + 32)]
    pub nft_state: Account<'info, TheresaNFT>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

pub fn initialize(
    ctx: Context<Initialize>,
    total_supply: u64,
    price: u64,
    treasury: Pubkey,
) -> Result<()> {
    let nft_state = &mut ctx.accounts.nft_state;
    nft_state.authority = ctx.accounts.authority.key();
    nft_state.total_supply = total_supply;
    nft_state.minted = 0;
    nft_state.price = price;
    nft_state.is_active = true;
    nft_state.treasury = treasury;
    Ok(())
}

#[derive(Accounts)]
pub struct MintNFT<'info> {
    #[account(mut)]
    pub nft_state: Account<'info, TheresaNFT>,
    #[account(mut)]
    pub minter: Signer<'info>,
    #[account(mut)]
    pub treasury: Account<'info, TokenAccount>,
    pub token_program: Program<'info, Token>,
    pub system_program: Program<'info, System>,
}

pub fn mint_nft(ctx: Context<MintNFT>, metadata: PlotMetadata) -> Result<()> {
    let nft_state = &mut ctx.accounts.nft_state;
    
    // Verify mint conditions
    require!(nft_state.is_active, ErrorCode::MintingPaused);
    require!(nft_state.minted < nft_state.total_supply, ErrorCode::SoldOut);
    
    // Process payment
    let payment = ctx.accounts.minter.try_borrow_mut_lamports()?;
    **payment = payment
        .checked_sub(nft_state.price)
        .ok_or(ErrorCode::InsufficientFunds)?;
    
    // Create NFT
    // ... Metaplex NFT creation logic
    
    nft_state.minted += 1;
    Ok(())
}

#[derive(Accounts)]
pub struct BurnForOwnership<'info> {
    #[account(mut)]
    pub nft_state: Account<'info, TheresaNFT>,
    #[account(mut)]
    pub nft_holder: Signer<'info>,
    #[account(mut)]
    pub nft_token_account: Account<'info, TokenAccount>,
    pub token_program: Program<'info, Token>,
}

pub fn burn_for_ownership(ctx: Context<BurnForOwnership>) -> Result<()> {
    // Verify NFT authenticity
    // Burn NFT
    // Register ownership claim
    // Emit ownership event
    Ok(())
}

{
    "name": "Theresa Plot #[ID]",
    "symbol": "THERESA",
    "description": "1/10th acre plot in Theresa, NY",
    "seller_fee_basis_points": 500,
    "image": "https://arweave.net/[hash]",
    "attributes": [
        {
            "trait_type": "Plot ID",
            "value": "[ID]"
        },
        {
            "trait_type": "Coordinates",
            "value": "[LAT,LONG]"
        },
        {
            "trait_type": "Terrain",
            "value": "[TERRAIN_TYPE]"
        },
        {
            "trait_type": "Features",
            "value": "[FEATURES]"
        },
        {
            "trait_type": "Rarity Score",
            "value": "[SCORE]"
        }
    ],
    "properties": {
        "files": [
            {
                "uri": "https://arweave.net/[hash]",
                "type": "image/png"
            }
        ],
        "category": "image",
        "creators": [
            {
                "address": "[CREATOR_ADDRESS]",
                "share": 100
            }
        ]
    }
}

pub fn verify_authority(ctx: &Context<T>) -> Result<()> {
    require!(
        ctx.accounts.authority.key() == ctx.accounts.nft_state.authority,
        ErrorCode::UnauthorizedAccess
    );
    Ok(())
}

pub fn check_rate_limit(last_mint: i64, current_time: i64) -> Result<()> {
    require!(
        current_time - last_mint >= MINT_COOLDOWN,
        ErrorCode::RateLimitExceeded
    );
    Ok(())
}

#[error_code]
pub enum ErrorCode {
    #[msg("Minting is currently paused")]
    MintingPaused,
    #[msg("All NFTs have been minted")]
    SoldOut,
    #[msg("Insufficient funds for purchase")]
    InsufficientFunds,
    #[msg("Unauthorized access")]
    UnauthorizedAccess,
    #[msg("Rate limit exceeded")]
    RateLimitExceeded,
    #[msg("Invalid metadata")]
    InvalidMetadata,
    #[msg("NFT already burned")]
    AlreadyBurned,
}

#[event]
pub struct NFTMinted {
    pub mint: Pubkey,
    pub owner: Pubkey,
    pub plot_id: u16,
    pub timestamp: i64,
}

#[event]
pub struct NFTBurned {
    pub mint: Pubkey,
    pub owner: Pubkey,
    pub plot_id: u16,
    pub ownership_id: String,
    pub timestamp: i64,
}

#[cfg(test)]
mod tests {
    use super::*;
    use solana_program_test::*;
    
    #[tokio::test]
    async fn test_mint_nft() {
        // Test initialization
        // Test minting
        // Test burning
        // Test ownership conversion
    }
}