documentation.

use anchor_lang::prelude::*;
use mpp_vault::program::MppVault;
use mpp_vault::state::Vault;

pub fn create_vault(
    ctx: Context<CreateVault>,
    name: String,
    initial_deposit: u64,
) -> Result<()> {
    let vault = &mut ctx.accounts.vault;
    vault.authority = ctx.accounts.authority.key();
    vault.name = name;
    vault.balance = initial_deposit;
    vault.created_at = Clock::get()?.unix_timestamp;
    vault.bump = ctx.bumps.vault;

    // Transfer SOL from authority to vault PDA
    anchor_lang::system_program::transfer(
        CpiContext::new(
            ctx.accounts.system_program.to_account_info(),
            anchor_lang::system_program::Transfer {
                from: ctx.accounts.authority.to_account_info(),
                to: ctx.accounts.vault.to_account_info(),
            },
        ),
        initial_deposit,
    )?;

    msg!("Vault '{}' created with {} lamports", vault.name, initial_deposit);
    Ok(())
}

#[derive(Accounts)]
#[instruction(name: String)]
pub struct CreateVault<'info> {
    #[account(
        init,
        payer = authority,
        space = Vault::LEN,
        seeds = [b"vault", authority.key().as_ref()],
        bump
    )]
    pub vault: Account<'info, Vault>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

import { MppVault } from "@mpp/vault-sdk";
import { Connection, Keypair } from "@solana/web3.js";

const connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet = Keypair.fromSecretKey(/* ... */);

const vault = await MppVault.create(connection, {
  authority: wallet.publicKey,
  name: "production-vault",
  initialDeposit: 10_000_000_000, // 10 SOL in lamports
});

console.log("Vault PDA:", vault.address.toBase58());
// => Vault PDA: 7xKm...f9mP

pub fn create_sub_account(
    ctx: Context<CreateSubAccount>,
    agent_id: String,
    budget: u64,
) -> Result<()> {
    let sub = &mut ctx.accounts.sub_account;
    sub.vault = ctx.accounts.vault.key();
    sub.agent_id = agent_id;
    sub.budget = budget;
    sub.spent = 0;
    sub.active = true;
    sub.bump = ctx.bumps.sub_account;

    msg!("Sub-account '{}' created with budget {}", sub.agent_id, budget);
    Ok(())
}

#[derive(Accounts)]
#[instruction(agent_id: String)]
pub struct CreateSubAccount<'info> {
    #[account(
        init,
        payer = authority,
        space = SubAccount::LEN,
        seeds = [b"sub", vault.key().as_ref(), agent_id.as_bytes()],
        bump
    )]
    pub sub_account: Account<'info, SubAccount>,
    #[account(mut, has_one = authority)]
    pub vault: Account<'info, Vault>,
    #[account(mut)]
    pub authority: Signer<'info>,
    pub system_program: Program<'info, System>,
}

const subAccount = await vault.createSubAccount({
  agentId: "research_agent",
  budget: 2_000_000_000, // 2 SOL
});

// List all sub-accounts
const accounts = await vault.listSubAccounts();
accounts.forEach((a) => {
  console.log(`${a.agentId}: ${a.budget / 1e9} SOL (spent: ${a.spent / 1e9})`);
});

pub fn set_spending_rules(
    ctx: Context<SetSpendingRules>,
    max_per_tx: u64,
    max_per_day: u64,
) -> Result<()> {
    let rules = &mut ctx.accounts.spending_rules;
    rules.sub_account = ctx.accounts.sub_account.key();
    rules.max_per_tx = max_per_tx;
    rules.max_per_day = max_per_day;
    rules.spent_today = 0;
    rules.day_start = Clock::get()?.unix_timestamp;

    msg!(
        "Rules set: max/tx={}, max/day={}",
        max_per_tx,
        max_per_day
    );
    Ok(())
}

// Enforcement during payment
pub fn execute_payment(ctx: Context<ExecutePayment>, amount: u64) -> Result<()> {
    let rules = &ctx.accounts.spending_rules;
    let clock = Clock::get()?;

    require!(amount <= rules.max_per_tx, VaultError::ExceedsMaxPerTx);

    let elapsed = clock.unix_timestamp - rules.day_start;
    let spent = if elapsed >= 86_400 { 0 } else { rules.spent_today };
    require!(spent + amount <= rules.max_per_day, VaultError::ExceedsMaxPerDay);

    // ... transfer logic
    Ok(())
}

await subAccount.setSpendingRules({
  maxPerTx: 500_000_000,     // 0.5 SOL per transaction
  maxPerDay: 2_000_000_000,  // 2 SOL per day
});

// Check current usage
const rules = await subAccount.getSpendingRules();
console.log(`Spent today: ${rules.spentToday / 1e9} SOL`);
console.log(`Remaining:   ${(rules.maxPerDay - rules.spentToday) / 1e9} SOL`);

pub fn add_to_whitelist(
    ctx: Context<ModifyWhitelist>,
    address: Pubkey,
    label: String,
) -> Result<()> {
    let whitelist = &mut ctx.accounts.whitelist;
    require!(
        !whitelist.entries.iter().any(|e| e.address == address),
        VaultError::AlreadyWhitelisted
    );
    whitelist.entries.push(WhitelistEntry {
        address,
        label,
        added_at: Clock::get()?.unix_timestamp,
    });

    msg!("Address {} added to whitelist", address);
    Ok(())
}

// Checked during payment execution
pub fn verify_whitelist(
    whitelist: &Whitelist,
    destination: &Pubkey,
) -> Result<()> {
    require!(
        whitelist.entries.iter().any(|e| e.address == *destination),
        VaultError::NotWhitelisted
    );
    Ok(())
}

// Add addresses to the whitelist
await subAccount.addToWhitelist([
  { address: "4zMMC9...openai", label: "OpenAI API" },
  { address: "7xKm3...claude", label: "Claude API" },
  { address: "9pRt7...market", label: "Market Data" },
]);

// Remove an address
await subAccount.removeFromWhitelist("4zMMC9...openai");

// List all whitelisted addresses
const entries = await subAccount.getWhitelist();
entries.forEach((e) => console.log(`${e.label}: ${e.address}`));

#[account]
pub struct TimeRule {
    pub sub_account: Pubkey,
    pub windows: Vec<TimeWindow>,
    pub bump: u8,
}

#[derive(AnchorSerialize, AnchorDeserialize, Clone)]
pub struct TimeWindow {
    pub start_hour: u8,   // 0-23 UTC
    pub end_hour: u8,     // 0-23 UTC
    pub days: Vec<u8>,    // 0=Sun, 1=Mon, ..., 6=Sat
}

pub fn check_time_rules(time_rule: &TimeRule) -> Result<()> {
    let clock = Clock::get()?;
    let ts = clock.unix_timestamp;

    let hour = ((ts % 86_400) / 3_600) as u8;
    let day = ((ts / 86_400 + 4) % 7) as u8; // Unix epoch was Thursday

    let allowed = time_rule.windows.iter().any(|w| {
        w.days.contains(&day) && hour >= w.start_hour && hour < w.end_hour
    });

    require!(allowed, VaultError::OutsideTimeWindow);
    Ok(())
}

await subAccount.setTimeRules({
  windows: [
    {
      startHour: 9,
      endHour: 17,
      days: [1, 2, 3, 4, 5], // Mon–Fri
    },
  ],
});

// Check if the agent can transact right now
const canSpend = await subAccount.isWithinTimeWindow();
console.log("Can spend:", canSpend); // => true or false

#[account]
pub struct AutoTopUp {
    pub sub_account: Pubkey,
    pub min_balance: u64,     // trigger threshold
    pub target_balance: u64,  // refill to this amount
    pub enabled: bool,
    pub last_topup: i64,
    pub bump: u8,
}

pub fn execute_topup(ctx: Context<ExecuteTopUp>) -> Result<()> {
    let config = &ctx.accounts.auto_topup;
    let sub = &mut ctx.accounts.sub_account;
    let vault = &mut ctx.accounts.vault;

    require!(config.enabled, VaultError::TopUpDisabled);
    require!(sub.balance() < config.min_balance, VaultError::AboveThreshold);

    let refill = config.target_balance - sub.balance();
    require!(vault.balance >= refill, VaultError::InsufficientVaultFunds);

    vault.balance -= refill;
    sub.credit(refill);

    msg!("Top-up: {} lamports → {}", refill, sub.agent_id);
    Ok(())
}

await subAccount.configureAutoTopUp({
  minBalance: 500_000_000,    // trigger when below 0.5 SOL
  targetBalance: 2_000_000_000, // refill to 2 SOL
  enabled: true,
});

// Run the crank (permissionless — anyone can call this)
await vault.crankAutoTopUp(subAccount.address);

#[account]
pub struct MultisigConfig {
    pub vault: Pubkey,
    pub signers: Vec<Pubkey>,
    pub threshold: u8,         // e.g. 2 for 2-of-3
    pub amount_threshold: u64, // multi-sig required above this amount
    pub proposal_ttl: i64,     // seconds until proposal expires
    pub bump: u8,
}

#[account]
pub struct Proposal {
    pub vault: Pubkey,
    pub destination: Pubkey,
    pub amount: u64,
    pub approvals: Vec<Pubkey>,
    pub created_at: i64,
    pub executed: bool,
    pub bump: u8,
}

pub fn approve_proposal(ctx: Context<ApproveProposal>) -> Result<()> {
    let proposal = &mut ctx.accounts.proposal;
    let config = &ctx.accounts.multisig_config;
    let signer = ctx.accounts.signer.key();

    require!(
        config.signers.contains(&signer),
        VaultError::NotAuthorizedSigner
    );
    require!(
        !proposal.approvals.contains(&signer),
        VaultError::AlreadyApproved
    );

    proposal.approvals.push(signer);

    if proposal.approvals.len() >= config.threshold as usize {
        msg!("Threshold met — proposal ready for execution");
    }
    Ok(())
}

// Configure multi-sig
await vault.configureMultisig({
  signers: [wallet1.publicKey, wallet2.publicKey, wallet3.publicKey],
  threshold: 2,                    // 2-of-3
  amountThreshold: 5_000_000_000,  // require multi-sig above 5 SOL
  proposalTtl: 86_400,             // 24 hour expiry
});

// Create a proposal
const proposal = await vault.createProposal({
  destination: "9pRt7...vendor",
  amount: 10_000_000_000, // 10 SOL
});

// Each signer approves
await proposal.approve(wallet1);
await proposal.approve(wallet2); // threshold met

// Execute
await proposal.execute();

npm install @mpp/vault-sdk @solana/web3.js

# or
yarn add @mpp/vault-sdk @solana/web3.js