feat(solana): implement mpc-spending-limit Anchor program

Add on-chain spending limits enforcement for Solana MPC wallets using
Anchor framework 0.32.1.

Features:
- PDA-based SpendingConfig with per-tx, daily, weekly, monthly limits
- Slot-based period tracking with automatic resets
- WhitelistEntry PDAs for allowed/blocked addresses
- Guardian support for emergency pause functionality
- Cooldown periods for limit updates
- Atomic validate_and_record instruction

Instructions:
- initialize/initialize_for: Create spending config
- update_limits: Modify limits with optional cooldown
- toggle_pause: Pause/unpause by authority or guardian
- set_guardian: Set emergency guardian
- add_to_whitelist/remove_from_whitelist: Manage whitelist
- validate_transfer: Check if transfer is allowed
- record_spending: Update counters after transfer
- validate_and_record: Atomic validation + recording

Dependencies:
- anchor-lang: 0.32.1
- anchor-spl: 0.32.1
- solana-sdk: 2.3 (workspace)

Author: Kazopl

Cargo.lock

@@ -5,6 +5,7 @@ members = [
     "crates/mpc-wallet-wasm",
     "crates/mpc-wallet-relay",
     "crates/mpc-wallet-cli",
+    "programs/mpc-spending-limit",
 ]
 
 [workspace.package]
@@ -104,10 +105,10 @@ alloy-consensus = "0.6"
 alloy-eips = "0.6"
 alloy-rpc-types = "0.6"
 
-# Solana (use v2.2 for zeroize compatibility with curve25519-dalek 4.x)
-solana-sdk = "2.2"
-spl-token = { version = "7.0", features = ["no-entrypoint"] }
-spl-associated-token-account = { version = "7.0", features = ["no-entrypoint"] }
+# Solana (use v2.3 for Anchor 0.32.x compatibility)
+solana-sdk = "2.3"
+spl-token = { version = "8.0", features = ["no-entrypoint"] }
+spl-associated-token-account = { version = "8.0", features = ["no-entrypoint"] }
 
 [profile.release]
 lto = "thin"

Cargo.toml

@@ -0,0 +1,29 @@
+[features]
+seeds = true
+skip-lint = false
+
+[programs.localnet]
+mpc_spending_limit = "MpcSLim1t1111111111111111111111111111111111"
+
+[programs.devnet]
+mpc_spending_limit = "MpcSLim1t1111111111111111111111111111111111"
+
+[programs.mainnet]
+mpc_spending_limit = "MpcSLim1t1111111111111111111111111111111111"
+
+[registry]
+url = "https://api.apr.dev"
+
+[provider]
+cluster = "Localnet"
+wallet = "~/.config/solana/id.json"
+
+[scripts]
+test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"
+
+[test]
+startup_wait = 5000
+shutdown_wait = 2000
+
+[test.validator]
+url = "https://api.mainnet-beta.solana.com"

programs/mpc-spending-limit/Anchor.toml

@@ -0,0 +1,28 @@
+[package]
+name = "mpc-spending-limit"
+version = "0.1.0"
+description = "Solana program for MPC wallet spending limits with PDA-based tracking"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/Kazopl/mpc-agent-wallet"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "mpc_spending_limit"
+
+[features]
+default = []
+cpi = ["no-entrypoint"]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]
+
+[dependencies]
+anchor-lang = "0.32.1"
+anchor-spl = "0.32.1"
+
+[dev-dependencies]
+solana-program-test = "2.3"
+solana-sdk = "2.3"
+tokio = { version = "1.0", features = ["full"] }

programs/mpc-spending-limit/Cargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

programs/mpc-spending-limit/Xargo.toml

@@ -0,0 +1,83 @@
+//! Custom error types for the MPC Spending Limit program
+
+use anchor_lang::prelude::*;
+
+/// Errors that can occur in the MPC Spending Limit program
+#[error_code]
+pub enum SpendingLimitError {
+    /// Transfer amount exceeds per-transaction limit
+    #[msg("Transfer amount exceeds per-transaction limit")]
+    PerTxLimitExceeded,
+
+    /// Transfer would exceed daily spending limit
+    #[msg("Transfer would exceed daily spending limit")]
+    DailyLimitExceeded,
+
+    /// Transfer would exceed weekly spending limit
+    #[msg("Transfer would exceed weekly spending limit")]
+    WeeklyLimitExceeded,
+
+    /// Transfer would exceed monthly spending limit
+    #[msg("Transfer would exceed monthly spending limit")]
+    MonthlyLimitExceeded,
+
+    /// Target address is not in the whitelist
+    #[msg("Target address is not in the whitelist")]
+    NotWhitelisted,
+
+    /// Whitelist mode requires target to be whitelisted
+    #[msg("Whitelist mode is enabled and target is not whitelisted")]
+    WhitelistRequired,
+
+    /// Target address is blacklisted
+    #[msg("Target address is blacklisted")]
+    TargetBlacklisted,
+
+    /// Unauthorized - caller is not the authority
+    #[msg("Unauthorized - caller is not the authority")]
+    Unauthorized,
+
+    /// Invalid limit configuration
+    #[msg("Invalid limit configuration - limits must be non-zero and consistent")]
+    InvalidLimitConfig,
+
+    /// Config is paused
+    #[msg("Spending config is currently paused")]
+    ConfigPaused,
+
+    /// Math overflow occurred
+    #[msg("Math overflow occurred during calculation")]
+    MathOverflow,
+
+    /// Invalid slot window
+    #[msg("Invalid slot window for period reset")]
+    InvalidSlotWindow,
+
+    /// Whitelist is full
+    #[msg("Whitelist has reached maximum capacity")]
+    WhitelistFull,
+
+    /// Entry already exists
+    #[msg("Whitelist entry already exists")]
+    EntryAlreadyExists,
+
+    /// Entry not found
+    #[msg("Whitelist entry not found")]
+    EntryNotFound,
+
+    /// Invalid authority transfer
+    #[msg("Invalid authority transfer - new authority cannot be zero")]
+    InvalidAuthorityTransfer,
+
+    /// Guardian already set
+    #[msg("Guardian is already set")]
+    GuardianAlreadySet,
+
+    /// Guardian not set
+    #[msg("Guardian is not set for this config")]
+    GuardianNotSet,
+
+    /// Cooldown period has not elapsed
+    #[msg("Cooldown period has not elapsed for limit update")]
+    CooldownNotElapsed,
+}

programs/mpc-spending-limit/src/error.rs

@@ -0,0 +1,171 @@
+//! Initialize instruction for creating a new spending config
+
+use anchor_lang::prelude::*;
+
+use crate::error::SpendingLimitError;
+use crate::state::*;
+
+/// Accounts for the initialize instruction
+#[derive(Accounts)]
+pub struct Initialize<'info> {
+    /// The authority that will control this spending config
+    #[account(mut)]
+    pub authority: Signer<'info>,
+
+    /// The spending config PDA to initialize
+    #[account(
+        init,
+        payer = authority,
+        space = SpendingConfig::SIZE,
+        seeds = [SPENDING_CONFIG_SEED, authority.key().as_ref()],
+        bump
+    )]
+    pub spending_config: Account<'info, SpendingConfig>,
+
+    /// System program for account creation
+    pub system_program: Program<'info, System>,
+}
+
+/// Initialize a new spending configuration
+///
+/// Creates a PDA that stores spending limits for an MPC wallet.
+/// The authority (usually the MPC wallet address) controls all config updates.
+///
+/// # Arguments
+/// * `ctx` - The instruction context
+/// * `config_input` - Initial configuration parameters
+///
+/// # Errors
+/// * `InvalidLimitConfig` - If the limit configuration is invalid
+pub fn handler(ctx: Context<Initialize>, config_input: SpendingConfigInput) -> Result<()> {
+    // Validate input
+    require!(config_input.validate(), SpendingLimitError::InvalidLimitConfig);
+
+    let config_key = ctx.accounts.spending_config.key();
+    let spending_config = &mut ctx.accounts.spending_config;
+    let clock = Clock::get()?;
+    let current_slot = clock.slot;
+
+    // Initialize the spending config
+    spending_config.authority = ctx.accounts.authority.key();
+    spending_config.guardian = None;
+    spending_config.per_tx_limit = config_input.per_tx_limit;
+    spending_config.daily_limit = config_input.daily_limit;
+    spending_config.weekly_limit = config_input.weekly_limit;
+    spending_config.monthly_limit = config_input.monthly_limit;
+    spending_config.daily_spent = 0;
+    spending_config.weekly_spent = 0;
+    spending_config.monthly_spent = 0;
+    spending_config.daily_reset_slot = current_slot + SLOTS_PER_DAY;
+    spending_config.weekly_reset_slot = current_slot + SLOTS_PER_WEEK;
+    spending_config.monthly_reset_slot = current_slot + SLOTS_PER_MONTH;
+    spending_config.whitelist_only = config_input.whitelist_only;
+    spending_config.is_paused = false;
+    spending_config.whitelist_count = 0;
+    spending_config.update_cooldown_slots = config_input.update_cooldown_slots;
+    spending_config.pending_update_slot = 0;
+    spending_config.bump = ctx.bumps.spending_config;
+    spending_config._reserved = [0u8; 64];
+
+    // Emit event
+    emit!(ConfigInitialized {
+        config: config_key,
+        authority: spending_config.authority,
+        per_tx_limit: spending_config.per_tx_limit,
+        daily_limit: spending_config.daily_limit,
+        weekly_limit: spending_config.weekly_limit,
+        monthly_limit: spending_config.monthly_limit,
+    });
+
+    msg!(
+        "Initialized spending config for authority {} with limits: per_tx={}, daily={}, weekly={}, monthly={}",
+        spending_config.authority,
+        spending_config.per_tx_limit,
+        spending_config.daily_limit,
+        spending_config.weekly_limit,
+        spending_config.monthly_limit
+    );
+
+    Ok(())
+}
+
+/// Accounts for initializing with a custom authority
+#[derive(Accounts)]
+#[instruction(authority: Pubkey)]
+pub struct InitializeFor<'info> {
+    /// The payer for account creation
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    /// The spending config PDA to initialize
+    #[account(
+        init,
+        payer = payer,
+        space = SpendingConfig::SIZE,
+        seeds = [SPENDING_CONFIG_SEED, authority.as_ref()],
+        bump
+    )]
+    pub spending_config: Account<'info, SpendingConfig>,
+
+    /// System program for account creation
+    pub system_program: Program<'info, System>,
+}
+
+/// Initialize a spending config for a specific authority
+///
+/// Allows creating a config for an authority that may not be present as a signer.
+/// This is useful when the MPC wallet address is known but not yet operational.
+///
+/// # Arguments
+/// * `ctx` - The instruction context
+/// * `authority` - The authority pubkey to set
+/// * `config_input` - Initial configuration parameters
+pub fn handler_for(
+    ctx: Context<InitializeFor>,
+    authority: Pubkey,
+    config_input: SpendingConfigInput,
+) -> Result<()> {
+    require!(config_input.validate(), SpendingLimitError::InvalidLimitConfig);
+
+    let config_key = ctx.accounts.spending_config.key();
+    let spending_config = &mut ctx.accounts.spending_config;
+    let clock = Clock::get()?;
+    let current_slot = clock.slot;
+
+    spending_config.authority = authority;
+    spending_config.guardian = None;
+    spending_config.per_tx_limit = config_input.per_tx_limit;
+    spending_config.daily_limit = config_input.daily_limit;
+    spending_config.weekly_limit = config_input.weekly_limit;
+    spending_config.monthly_limit = config_input.monthly_limit;
+    spending_config.daily_spent = 0;
+    spending_config.weekly_spent = 0;
+    spending_config.monthly_spent = 0;
+    spending_config.daily_reset_slot = current_slot + SLOTS_PER_DAY;
+    spending_config.weekly_reset_slot = current_slot + SLOTS_PER_WEEK;
+    spending_config.monthly_reset_slot = current_slot + SLOTS_PER_MONTH;
+    spending_config.whitelist_only = config_input.whitelist_only;
+    spending_config.is_paused = false;
+    spending_config.whitelist_count = 0;
+    spending_config.update_cooldown_slots = config_input.update_cooldown_slots;
+    spending_config.pending_update_slot = 0;
+    spending_config.bump = ctx.bumps.spending_config;
+    spending_config._reserved = [0u8; 64];
+
+    emit!(ConfigInitialized {
+        config: config_key,
+        authority: spending_config.authority,
+        per_tx_limit: spending_config.per_tx_limit,
+        daily_limit: spending_config.daily_limit,
+        weekly_limit: spending_config.weekly_limit,
+        monthly_limit: spending_config.monthly_limit,
+    });
+
+    msg!(
+        "Initialized spending config for authority {} (paid by {})",
+        authority,
+        ctx.accounts.payer.key()
+    );
+
+    Ok(())
+}

programs/mpc-spending-limit/src/instructions/initialize.rs

@@ -0,0 +1,13 @@
+//! Instructions for the MPC Spending Limit program
+
+pub mod initialize;
+pub mod record_spending;
+pub mod update_limits;
+pub mod validate_transfer;
+pub mod whitelist;
+
+pub use initialize::*;
+pub use record_spending::*;
+pub use update_limits::*;
+pub use validate_transfer::*;
+pub use whitelist::*;