KeyPass

// KeyPass Token Minting with Anchor
use anchor_lang::prelude::*;
use anchor_spl::token_2022::{Token2022, TokenAccount, Mint};

#[program]
pub mod keypass {
    use super::*;
    
    pub fn mint_keypass(
        ctx: Context<MintKeyPass>,
        property_id: String,
        access_start: i64,
        access_end: i64,
        guest_pubkey: Pubkey,
    ) -> Result<()> {
        let keypass = &mut ctx.accounts.keypass;
        
        keypass.property_id = property_id;
        keypass.access_start = access_start;
        keypass.access_end = access_end;
        keypass.guest = guest_pubkey;
        keypass.is_active = true;
        
        // Mint token with transfer hook
        token_2022::mint_to(
            CpiContext::new(
                ctx.accounts.token_program.to_account_info(),
                token_2022::MintTo {
                    mint: ctx.accounts.mint.to_account_info(),
                    to: ctx.accounts.token_account.to_account_info(),
                    authority: ctx.accounts.authority.to_account_info(),
                },
            ),
            1, // Amount: 1 NFT
        )?;
        
        Ok(())
    }
    
    pub fn verify_access(
        ctx: Context<VerifyAccess>,
        property_id: String,
    ) -> Result<bool> {
        let keypass = &ctx.accounts.keypass;
        let clock = Clock::get()?;
        
        // Verify time window
        if clock.unix_timestamp < keypass.access_start 
            || clock.unix_timestamp > keypass.access_end {
            return Ok(false);
        }
        
        // Verify property match
        if keypass.property_id != property_id {
            return Ok(false);
        }
        
        // Verify token is active
        Ok(keypass.is_active)
    }
}

#[derive(Accounts)]
pub struct MintKeyPass<'info> {
    #[account(init, payer = authority, space = 8 + 200)]
    pub keypass: Account<'info, KeyPassData>,
    #[account(mut)]
    pub mint: Account<'info, Mint>,
    #[account(mut)]
    pub token_account: Account<'info, TokenAccount>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub token_program: Program<'info, Token2022>,
    pub system_program: Program<'info, System>,
}

#[account]
pub struct KeyPassData {
    pub property_id: String,
    pub access_start: i64,
    pub access_end: i64,
    pub guest: Pubkey,
    pub is_active: bool,
}