From cb13db55d99516a39bcd485d2910427e6ac3c341 Mon Sep 17 00:00:00 2001 From: tilo-14 Date: Thu, 12 Feb 2026 23:37:53 +0000 Subject: [PATCH 1/3] feat: add pinocchio counter example with compressible PDA Minimal Pinocchio + Light Protocol counter program demonstrating rent-free compressible accounts without Anchor dependency. Two instructions: create_counter (PDA init + Light CPI registration) and increment (pure on-chain owner-gated mutation). Full lifecycle test covers create, increment, auto-compress, decompress, and post-decompression increment. --- pinocchio/counter/Cargo.toml | 49 ++++ pinocchio/counter/src/constants.rs | 13 + .../counter/src/create_counter/accounts.rs | 120 ++++++++ pinocchio/counter/src/create_counter/mod.rs | 6 + .../counter/src/create_counter/processor.rs | 102 +++++++ pinocchio/counter/src/error.rs | 27 ++ pinocchio/counter/src/increment/accounts.rs | 55 ++++ pinocchio/counter/src/increment/mod.rs | 4 + pinocchio/counter/src/increment/processor.rs | 43 +++ pinocchio/counter/src/lib.rs | 105 +++++++ pinocchio/counter/src/state.rs | 34 +++ pinocchio/counter/tests/sdk.rs | 187 +++++++++++++ pinocchio/counter/tests/shared/mod.rs | 105 +++++++ pinocchio/counter/tests/test_lifecycle.rs | 260 ++++++++++++++++++ 14 files changed, 1110 insertions(+) create mode 100644 pinocchio/counter/Cargo.toml create mode 100644 pinocchio/counter/src/constants.rs create mode 100644 pinocchio/counter/src/create_counter/accounts.rs create mode 100644 pinocchio/counter/src/create_counter/mod.rs create mode 100644 pinocchio/counter/src/create_counter/processor.rs create mode 100644 pinocchio/counter/src/error.rs create mode 100644 pinocchio/counter/src/increment/accounts.rs create mode 100644 pinocchio/counter/src/increment/mod.rs create mode 100644 pinocchio/counter/src/increment/processor.rs create mode 100644 pinocchio/counter/src/lib.rs create mode 100644 pinocchio/counter/src/state.rs create mode 100644 pinocchio/counter/tests/sdk.rs create mode 100644 pinocchio/counter/tests/shared/mod.rs create mode 100644 pinocchio/counter/tests/test_lifecycle.rs diff --git a/pinocchio/counter/Cargo.toml b/pinocchio/counter/Cargo.toml new file mode 100644 index 0000000..662be09 --- /dev/null +++ b/pinocchio/counter/Cargo.toml @@ -0,0 +1,49 @@ +[package] +name = "pinocchio-counter" +version = "0.1.0" +description = "Pinocchio-based counter program using Light Protocol rent-free accounts" +edition = "2021" + +[lib] +crate-type = ["cdylib", "lib"] +name = "pinocchio_counter" + +[features] +no-entrypoint = [] +default = [] +test-sbf = [] + +[dependencies] +# Main Light Protocol dependencies +light-account-pinocchio = { version = "0.20", features = ["std"] } +light-hasher = { version = "5.0.0", features = ["solana"] } + +# Serialization and utilities +borsh = { version = "0.10.4", default-features = false } +bytemuck = { version = "1.21", features = ["derive"] } + +# Pinocchio and Solana +pinocchio = "0.9" +pinocchio-pubkey = { version = "0.3", features = ["const"] } +pinocchio-system = "0.3" +solana-pubkey = "2.2" +solana-msg = "2.2" +solana-program-error = "2.2" + +[dev-dependencies] +light-program-test = "0.20" +light-client = { version = "0.20", features = ["v2", "anchor", "program-test"] } +light-account = "0.20" +tokio = { version = "1", features = ["full"] } +solana-sdk = "2.2" +solana-keypair = "2.2" +solana-signer = "2.2" +solana-instruction = "2.2" +blake3 = "=1.8.2" + +[lints.rust.unexpected_cfgs] +level = "allow" +check-cfg = [ + 'cfg(target_os, values("solana"))', + 'cfg(feature, values("frozen-abi", "no-entrypoint"))', +] diff --git a/pinocchio/counter/src/constants.rs b/pinocchio/counter/src/constants.rs new file mode 100644 index 0000000..20c9434 --- /dev/null +++ b/pinocchio/counter/src/constants.rs @@ -0,0 +1,13 @@ +//! Constants for the counter program including seeds and discriminators. + +/// Seed for counter state PDA. +pub const COUNTER_SEED: &[u8] = b"counter"; + +/// Instruction discriminators (Anchor-compatible: sha256("global:{name}")[..8]). +pub mod discriminators { + /// Create counter instruction. + pub const CREATE_COUNTER: [u8; 8] = [174, 255, 78, 222, 78, 250, 200, 80]; + + /// Increment counter instruction. + pub const INCREMENT: [u8; 8] = [11, 18, 104, 9, 104, 174, 59, 33]; +} diff --git a/pinocchio/counter/src/create_counter/accounts.rs b/pinocchio/counter/src/create_counter/accounts.rs new file mode 100644 index 0000000..e7ae7bd --- /dev/null +++ b/pinocchio/counter/src/create_counter/accounts.rs @@ -0,0 +1,120 @@ +//! Create counter instruction account parsing. + +use borsh::{BorshDeserialize, BorshSerialize}; +use light_account_pinocchio::{CreateAccountsProof, LightAccount, LightDiscriminator}; +use pinocchio::{ + account_info::AccountInfo, + instruction::{Seed, Signer}, + program_error::ProgramError, + sysvars::Sysvar, +}; + +use crate::constants::*; +use crate::state::CounterState; + +/// Parameters for the create_counter instruction. +#[derive(Debug, Clone, BorshSerialize, BorshDeserialize)] +pub struct CreateCounterParams { + /// Proof data for creating compressed accounts. + pub create_accounts_proof: CreateAccountsProof, + /// Counter PDA bump. + pub counter_bump: u8, +} + +/// Accounts for the create_counter instruction. +/// +/// Layout: +/// [0] payer (signer, writable) +/// [1] owner (read-only) +/// [2] counter (writable) — PDA: [COUNTER_SEED, owner] +/// [3] compressible_config (read-only) +/// [4] system_program (read-only) +/// ... remaining_accounts (Light Protocol system accounts) +pub struct CreateCounterAccounts<'a> { + /// Payer/creator (signer, writable). + pub payer: &'a AccountInfo, + /// Counter owner (read-only). + pub owner: &'a AccountInfo, + /// Counter PDA (writable). + pub counter: &'a AccountInfo, + /// Compressible config account (read-only). + pub compressible_config: &'a AccountInfo, + /// System program (read-only). + pub system_program: &'a AccountInfo, +} + +impl<'a> CreateCounterAccounts<'a> { + /// Number of fixed accounts for this instruction. + pub const FIXED_LEN: usize = 5; + + /// Parse accounts from the account info slice. + pub fn parse( + accounts: &'a [AccountInfo], + params: &CreateCounterParams, + ) -> Result { + if accounts.len() < Self::FIXED_LEN { + return Err(ProgramError::NotEnoughAccountKeys); + } + + let payer = &accounts[0]; + let owner = &accounts[1]; + let counter = &accounts[2]; + let compressible_config = &accounts[3]; + let system_program = &accounts[4]; + + // Validate payer is signer + if !payer.is_signer() { + return Err(ProgramError::MissingRequiredSignature); + } + + // Validate and create counter PDA + { + let owner_key = owner.key(); + let seeds: &[&[u8]] = &[COUNTER_SEED, owner_key.as_ref()]; + let (expected_pda, bump) = + pinocchio::pubkey::find_program_address(seeds, &crate::ID); + if counter.key() != &expected_pda { + return Err(ProgramError::InvalidSeeds); + } + if bump != params.counter_bump { + return Err(ProgramError::InvalidSeeds); + } + + // Create counter account + let space = 8 + CounterState::INIT_SPACE; + let rent = pinocchio::sysvars::rent::Rent::get() + .map_err(|_| ProgramError::UnsupportedSysvar)?; + let lamports = rent.minimum_balance(space); + + let bump_bytes = [bump]; + let seed_array = [ + Seed::from(COUNTER_SEED), + Seed::from(owner_key.as_ref()), + Seed::from(bump_bytes.as_ref()), + ]; + let signer = Signer::from(&seed_array); + pinocchio_system::instructions::CreateAccount { + from: payer, + to: counter, + lamports, + space: space as u64, + owner: &crate::ID, + } + .invoke_signed(&[signer])?; + + // Write discriminator to first 8 bytes + let mut data = counter + .try_borrow_mut_data() + .map_err(|_| ProgramError::AccountBorrowFailed)?; + data[..8].copy_from_slice(&CounterState::LIGHT_DISCRIMINATOR); + } + + Ok(Self { + payer, + owner, + counter, + compressible_config, + system_program, + }) + } +} diff --git a/pinocchio/counter/src/create_counter/mod.rs b/pinocchio/counter/src/create_counter/mod.rs new file mode 100644 index 0000000..2df7849 --- /dev/null +++ b/pinocchio/counter/src/create_counter/mod.rs @@ -0,0 +1,6 @@ +//! Create counter instruction module. + +pub mod accounts; +pub mod processor; + +pub use accounts::CreateCounterParams; diff --git a/pinocchio/counter/src/create_counter/processor.rs b/pinocchio/counter/src/create_counter/processor.rs new file mode 100644 index 0000000..6471a4d --- /dev/null +++ b/pinocchio/counter/src/create_counter/processor.rs @@ -0,0 +1,102 @@ +//! Create counter instruction processor. +//! +//! Creates a counter PDA and registers it with Light Protocol for compression. + +use light_account_pinocchio::{ + prepare_compressed_account_on_init, CpiAccounts, CpiAccountsConfig, + InstructionDataInvokeCpiWithAccountInfo, InvokeLightSystemProgram, LightAccount, LightConfig, + LightSdkTypesError, PackedAddressTreeInfoExt, +}; +use pinocchio::{ + account_info::AccountInfo, + sysvars::{clock::Clock, Sysvar}, +}; + +use super::accounts::{CreateCounterAccounts, CreateCounterParams}; + +/// Process the create_counter instruction. +pub fn process( + ctx: &CreateCounterAccounts<'_>, + params: &CreateCounterParams, + remaining_accounts: &[AccountInfo], +) -> Result<(), LightSdkTypesError> { + // 1. Build CPI accounts (no CPI context — single PDA, no batching) + let system_accounts_offset = params.create_accounts_proof.system_accounts_offset as usize; + if remaining_accounts.len() < system_accounts_offset { + return Err(LightSdkTypesError::FewerAccountsThanSystemAccounts); + } + let config = CpiAccountsConfig::new(crate::LIGHT_CPI_SIGNER); + let cpi_accounts = CpiAccounts::new_with_config( + ctx.payer, + &remaining_accounts[system_accounts_offset..], + config, + ); + + // 2. Address tree info + let address_tree_info = ¶ms.create_accounts_proof.address_tree_info; + let address_tree_pubkey = address_tree_info + .get_tree_pubkey(&cpi_accounts) + .map_err(|_| LightSdkTypesError::InvalidInstructionData)?; + let output_tree_index = params.create_accounts_proof.output_state_tree_index; + + // 3. Load config, get slot + let light_config = LightConfig::load_checked(ctx.compressible_config, &crate::ID) + .map_err(|_| LightSdkTypesError::InvalidInstructionData)?; + let current_slot = Clock::get() + .map_err(|_| LightSdkTypesError::InvalidInstructionData)? + .slot; + + // 4. Prepare compressed account on init + let mut new_address_params = Vec::with_capacity(1); + let mut account_infos = Vec::with_capacity(1); + + let counter_key = *ctx.counter.key(); + prepare_compressed_account_on_init( + &counter_key, + &address_tree_pubkey, + address_tree_info, + output_tree_index, + 0, + &crate::ID, + &mut new_address_params, + &mut account_infos, + )?; + + // 5. Initialize counter state data via zero-copy + { + let mut account_data = ctx + .counter + .try_borrow_mut_data() + .map_err(|_| LightSdkTypesError::Borsh)?; + + let record_bytes = + &mut account_data[8..8 + core::mem::size_of::()]; + let counter_state: &mut crate::state::CounterState = + bytemuck::from_bytes_mut(record_bytes); + + counter_state.set_decompressed(&light_config, current_slot); + counter_state.owner = *ctx.owner.key(); + counter_state.count = 0; + } + + // 6. Invoke Light system program CPI + let instruction_data = InstructionDataInvokeCpiWithAccountInfo { + mode: 1, + bump: crate::LIGHT_CPI_SIGNER.bump, + invoking_program_id: crate::LIGHT_CPI_SIGNER.program_id.into(), + compress_or_decompress_lamports: 0, + is_compress: false, + with_cpi_context: false, + with_transaction_hash: false, + cpi_context: Default::default(), + proof: params.create_accounts_proof.proof.0, + new_address_params, + account_infos, + read_only_addresses: vec![], + read_only_accounts: vec![], + }; + + instruction_data.invoke(cpi_accounts)?; + + Ok(()) +} diff --git a/pinocchio/counter/src/error.rs b/pinocchio/counter/src/error.rs new file mode 100644 index 0000000..b1e67d7 --- /dev/null +++ b/pinocchio/counter/src/error.rs @@ -0,0 +1,27 @@ +//! Custom errors for the counter program. + +use pinocchio::program_error::ProgramError; + +/// Counter program errors. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[repr(u32)] +pub enum CounterError { + /// Invalid counter PDA seeds. + InvalidCounterSeeds = 6000, + /// Counter owner mismatch. + OwnerMismatch = 6001, + /// Math overflow. + MathOverflow = 6002, +} + +impl From for ProgramError { + fn from(e: CounterError) -> Self { + ProgramError::Custom(e as u32) + } +} + +impl From for u32 { + fn from(e: CounterError) -> Self { + e as u32 + } +} diff --git a/pinocchio/counter/src/increment/accounts.rs b/pinocchio/counter/src/increment/accounts.rs new file mode 100644 index 0000000..78bec85 --- /dev/null +++ b/pinocchio/counter/src/increment/accounts.rs @@ -0,0 +1,55 @@ +//! Increment instruction account parsing. + +use pinocchio::{account_info::AccountInfo, program_error::ProgramError}; + +use crate::constants::*; + +/// Accounts for the increment instruction. +/// +/// Layout: +/// [0] owner (signer) +/// [1] counter (writable) — validated PDA + program owner check +pub struct IncrementAccounts<'a> { + /// Counter owner (signer). + pub owner: &'a AccountInfo, + /// Counter PDA (writable). + pub counter: &'a AccountInfo, +} + +impl<'a> IncrementAccounts<'a> { + /// Number of fixed accounts for this instruction. + pub const FIXED_LEN: usize = 2; + + /// Parse accounts from the account info slice. + pub fn parse(accounts: &'a [AccountInfo]) -> Result { + if accounts.len() < Self::FIXED_LEN { + return Err(ProgramError::NotEnoughAccountKeys); + } + + let owner = &accounts[0]; + let counter = &accounts[1]; + + // Validate owner is signer + if !owner.is_signer() { + return Err(ProgramError::MissingRequiredSignature); + } + + // Validate counter PDA + { + let owner_key = owner.key(); + let seeds: &[&[u8]] = &[COUNTER_SEED, owner_key.as_ref()]; + let (expected_pda, _) = + pinocchio::pubkey::find_program_address(seeds, &crate::ID); + if counter.key() != &expected_pda { + return Err(ProgramError::InvalidSeeds); + } + } + + // Validate counter is owned by this program + if counter.owner() != &crate::ID { + return Err(ProgramError::IllegalOwner); + } + + Ok(Self { owner, counter }) + } +} diff --git a/pinocchio/counter/src/increment/mod.rs b/pinocchio/counter/src/increment/mod.rs new file mode 100644 index 0000000..d8c71d5 --- /dev/null +++ b/pinocchio/counter/src/increment/mod.rs @@ -0,0 +1,4 @@ +//! Increment counter instruction module. + +pub mod accounts; +pub mod processor; diff --git a/pinocchio/counter/src/increment/processor.rs b/pinocchio/counter/src/increment/processor.rs new file mode 100644 index 0000000..e919a1e --- /dev/null +++ b/pinocchio/counter/src/increment/processor.rs @@ -0,0 +1,43 @@ +//! Increment instruction processor. +//! +//! Pure on-chain mutation — no Light CPI needed. + +use light_account_pinocchio::LightDiscriminator; + +use super::accounts::IncrementAccounts; +use crate::error::CounterError; +use crate::state::CounterState; + +/// Process the increment instruction. +pub fn process(ctx: &IncrementAccounts<'_>) -> Result<(), CounterError> { + let mut account_data = ctx + .counter + .try_borrow_mut_data() + .map_err(|_| CounterError::OwnerMismatch)?; + + // Validate discriminator + if account_data.len() < 8 + core::mem::size_of::() { + return Err(CounterError::InvalidCounterSeeds); + } + let disc: [u8; 8] = account_data[..8].try_into().unwrap(); + if disc != CounterState::LIGHT_DISCRIMINATOR { + return Err(CounterError::InvalidCounterSeeds); + } + + // Zero-copy mutation + let record_bytes = &mut account_data[8..8 + core::mem::size_of::()]; + let counter_state: &mut CounterState = bytemuck::from_bytes_mut(record_bytes); + + // Validate owner + if counter_state.owner != *ctx.owner.key() { + return Err(CounterError::OwnerMismatch); + } + + // Increment + counter_state.count = counter_state + .count + .checked_add(1) + .ok_or(CounterError::MathOverflow)?; + + Ok(()) +} diff --git a/pinocchio/counter/src/lib.rs b/pinocchio/counter/src/lib.rs new file mode 100644 index 0000000..070bfc4 --- /dev/null +++ b/pinocchio/counter/src/lib.rs @@ -0,0 +1,105 @@ +//! Pinocchio-based counter program using Light Protocol rent-free accounts. +//! +//! Uses #[derive(LightProgramPinocchio)] to generate compress/decompress dispatch, +//! config handlers, and variant types. No Anchor dependency. + +#![allow(deprecated)] + +use light_account_pinocchio::{ + derive_light_cpi_signer, pubkey_array, CpiSigner, LightAccount, LightProgramPinocchio, +}; +use pinocchio::{account_info::AccountInfo, program_error::ProgramError, pubkey::Pubkey}; + +pub mod constants; +pub mod create_counter; +pub mod error; +pub mod increment; +pub mod state; + +pub use constants::*; +pub use state::*; + +pub const ID: Pubkey = pubkey_array!("CntrPino11111111111111111111111111111111111"); + +pub const LIGHT_CPI_SIGNER: CpiSigner = + derive_light_cpi_signer!("CntrPino11111111111111111111111111111111111"); + +/// Program accounts enum for LightProgramPinocchio. +/// Generates: variant enums, compress/decompress dispatch, config handlers, +/// per-variant Seeds/Variant/Packed types, LightAccountVariantTrait impls, +/// size validation, seed providers, and client functions. +#[derive(LightProgramPinocchio)] +pub enum ProgramAccounts { + /// Counter state account storing owner and count. + /// Seeds: [COUNTER_SEED, owner] + #[light_account(pda::seeds = [COUNTER_SEED, ctx.owner], pda::zero_copy)] + CounterState(CounterState), +} + +// ============================================================================ +// Entrypoint +// ============================================================================ + +pinocchio::entrypoint!(process_instruction); + +pub fn process_instruction( + _program_id: &Pubkey, + accounts: &[AccountInfo], + instruction_data: &[u8], +) -> Result<(), ProgramError> { + if instruction_data.len() < 8 { + return Err(ProgramError::InvalidInstructionData); + } + + let (disc, data) = instruction_data.split_at(8); + let disc: [u8; 8] = disc.try_into().unwrap(); + + match disc { + discriminators::CREATE_COUNTER => process_create_counter(accounts, data), + discriminators::INCREMENT => process_increment(accounts, data), + ProgramAccounts::INITIALIZE_COMPRESSION_CONFIG => { + ProgramAccounts::process_initialize_config(accounts, data) + } + ProgramAccounts::UPDATE_COMPRESSION_CONFIG => { + ProgramAccounts::process_update_config(accounts, data) + } + ProgramAccounts::COMPRESS_ACCOUNTS_IDEMPOTENT => { + ProgramAccounts::process_compress(accounts, data) + } + ProgramAccounts::DECOMPRESS_ACCOUNTS_IDEMPOTENT => { + ProgramAccounts::process_decompress(accounts, data) + } + _ => Err(ProgramError::InvalidInstructionData), + } +} + +// ============================================================================ +// Instruction Handlers +// ============================================================================ + +fn process_create_counter(accounts: &[AccountInfo], data: &[u8]) -> Result<(), ProgramError> { + use borsh::BorshDeserialize; + use create_counter::accounts::{CreateCounterAccounts, CreateCounterParams}; + + let params = CreateCounterParams::deserialize(&mut &data[..]) + .map_err(|_| ProgramError::BorshIoError)?; + + let remaining_start = CreateCounterAccounts::FIXED_LEN; + let (fixed_accounts, remaining_accounts) = accounts.split_at(remaining_start); + let ctx = CreateCounterAccounts::parse(fixed_accounts, ¶ms)?; + + create_counter::processor::process(&ctx, ¶ms, remaining_accounts) + .map_err(|e| ProgramError::Custom(u32::from(e)))?; + + Ok(()) +} + +fn process_increment(accounts: &[AccountInfo], _data: &[u8]) -> Result<(), ProgramError> { + use increment::accounts::IncrementAccounts; + + let ctx = IncrementAccounts::parse(accounts)?; + + increment::processor::process(&ctx).map_err(|e| ProgramError::Custom(u32::from(e)))?; + + Ok(()) +} diff --git a/pinocchio/counter/src/state.rs b/pinocchio/counter/src/state.rs new file mode 100644 index 0000000..0054d6f --- /dev/null +++ b/pinocchio/counter/src/state.rs @@ -0,0 +1,34 @@ +//! Counter state for the counter program. + +use borsh::{BorshDeserialize, BorshSerialize}; +use light_account_pinocchio::{CompressionInfo, LightDiscriminator, LightPinocchioAccount}; +use pinocchio::pubkey::Pubkey; + +/// Counter state storing owner and count. +/// +/// LightPinocchioAccount generates: +/// - LightHasherSha (DataHasher + ToByteArray) +/// - LightDiscriminator +/// - LightAccount trait impl with pack/unpack +/// - PackedCounterState struct +#[derive( + Default, + Debug, + Copy, + Clone, + PartialEq, + BorshSerialize, + BorshDeserialize, + LightPinocchioAccount, + bytemuck::Pod, + bytemuck::Zeroable, +)] +#[repr(C)] +pub struct CounterState { + /// Compression metadata for Light Protocol rent-free accounts. + pub compression_info: CompressionInfo, + /// Owner of this counter. + pub owner: Pubkey, + /// Current count value. + pub count: u64, +} diff --git a/pinocchio/counter/tests/sdk.rs b/pinocchio/counter/tests/sdk.rs new file mode 100644 index 0000000..a218cbc --- /dev/null +++ b/pinocchio/counter/tests/sdk.rs @@ -0,0 +1,187 @@ +#![allow(dead_code)] + +//! CounterSdk implementing LightProgramInterface trait. +//! +//! Provides: +//! - Parsing counter accounts from AccountInterface +//! - Tracking account state (hot/cold) +//! - Building AccountSpec for load instructions + +use borsh::BorshDeserialize; +use light_account::LightDiscriminator; +use light_client::interface::{ + AccountInterface, AccountSpec, AccountToFetch, LightProgramInterface, PdaSpec, +}; +use pinocchio_counter::{CounterState, CounterStateSeeds, LightAccountVariant}; +use solana_pubkey::Pubkey; +use std::collections::HashMap; + +pub const PROGRAM_ID: Pubkey = Pubkey::new_from_array(pinocchio_counter::ID); + +/// Instructions supported by the counter program. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CounterInstruction { + CreateCounter, + Increment, +} + +/// Error type for SDK operations. +#[derive(Debug, Clone)] +pub enum CounterSdkError { + ParseError(String), + UnknownDiscriminator([u8; 8]), + MissingField(&'static str), + CounterStateNotParsed, +} + +impl std::fmt::Display for CounterSdkError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::ParseError(msg) => write!(f, "Parse error: {}", msg), + Self::UnknownDiscriminator(disc) => write!(f, "Unknown discriminator: {:?}", disc), + Self::MissingField(field) => write!(f, "Missing field: {}", field), + Self::CounterStateNotParsed => write!(f, "Counter state must be parsed first"), + } + } +} + +impl std::error::Error for CounterSdkError {} + +/// SDK for managing counter accounts and building decompression instructions. +#[derive(Debug, Clone)] +pub struct CounterSdk { + /// Counter state pubkey. + pub counter_pubkey: Option, + /// Counter owner pubkey. + pub owner: Option, + /// Cached PDA specs keyed by pubkey. + pda_specs: HashMap>, +} + +impl Default for CounterSdk { + fn default() -> Self { + Self::new() + } +} + +impl CounterSdk { + /// Create a new empty SDK instance. + pub fn new() -> Self { + Self { + counter_pubkey: None, + owner: None, + pda_specs: HashMap::new(), + } + } + + /// Parse counter state from AccountInterface and populate SDK fields. + fn parse_counter_state( + &mut self, + interface: AccountInterface, + ) -> Result<(), CounterSdkError> { + let data = interface.data(); + if data.len() < 8 { + return Err(CounterSdkError::ParseError( + "Account data too short".to_string(), + )); + } + + // Skip 8-byte discriminator + let counter_state = CounterState::deserialize(&mut &data[8..]) + .map_err(|e| CounterSdkError::ParseError(e.to_string()))?; + + let counter_pubkey = interface.key; + self.counter_pubkey = Some(counter_pubkey); + self.owner = Some(Pubkey::new_from_array(counter_state.owner)); + + // Create PdaSpec with variant + let owner_bytes = counter_state.owner; + let variant = LightAccountVariant::CounterState { + seeds: CounterStateSeeds { + owner: owner_bytes, + }, + data: counter_state, + }; + let spec = PdaSpec::new(interface, variant, PROGRAM_ID); + self.pda_specs.insert(counter_pubkey, spec); + + Ok(()) + } +} + +impl LightProgramInterface for CounterSdk { + type Variant = LightAccountVariant; + type Instruction = CounterInstruction; + type Error = CounterSdkError; + + fn program_id(&self) -> Pubkey { + PROGRAM_ID + } + + fn from_keyed_accounts(accounts: &[AccountInterface]) -> Result { + let mut sdk = Self::new(); + + // Find and parse counter state + for account in accounts { + let data = account.data(); + if data.len() >= 8 { + let discriminator: [u8; 8] = data[..8].try_into().unwrap_or_default(); + if discriminator == CounterState::LIGHT_DISCRIMINATOR { + sdk.parse_counter_state(account.clone())?; + break; + } + } + } + + if sdk.counter_pubkey.is_none() { + return Err(CounterSdkError::MissingField("counter_state")); + } + + Ok(sdk) + } + + fn get_accounts_to_update(&self, _ix: &Self::Instruction) -> Vec { + let mut accounts = Vec::new(); + + if let Some(pubkey) = self.counter_pubkey { + accounts.push(AccountToFetch::pda(pubkey, PROGRAM_ID)); + } + + accounts + } + + fn update(&mut self, accounts: &[AccountInterface]) -> Result<(), Self::Error> { + for account in accounts { + let data = account.data(); + if data.len() >= 8 { + let discriminator: [u8; 8] = data[..8].try_into().unwrap_or_default(); + if discriminator == CounterState::LIGHT_DISCRIMINATOR { + self.parse_counter_state(account.clone())?; + } + } + } + Ok(()) + } + + fn get_all_specs(&self) -> Vec> { + self.pda_specs + .values() + .map(|spec| AccountSpec::Pda(spec.clone())) + .collect() + } + + fn get_specs_for_instruction( + &self, + _ix: &Self::Instruction, + ) -> Vec> { + let mut specs = Vec::new(); + + if let Some(pubkey) = self.counter_pubkey { + if let Some(spec) = self.pda_specs.get(&pubkey) { + specs.push(AccountSpec::Pda(spec.clone())); + } + } + + specs + } +} diff --git a/pinocchio/counter/tests/shared/mod.rs b/pinocchio/counter/tests/shared/mod.rs new file mode 100644 index 0000000..a785587 --- /dev/null +++ b/pinocchio/counter/tests/shared/mod.rs @@ -0,0 +1,105 @@ +#![allow(dead_code)] + +//! Shared test utilities for the pinocchio-counter program. + +use light_account::derive_rent_sponsor_pda; +use light_client::interface::InitializeRentFreeConfig; +use light_program_test::{ + program_test::{setup_mock_program_data, LightProgramTest}, + ProgramTestConfig, Rpc, +}; +use solana_keypair::Keypair; +use solana_pubkey::Pubkey; +use solana_signer::Signer; + +/// Shared test environment with initialized compression config. +pub struct TestEnv { + pub rpc: LightProgramTest, + pub payer: Keypair, + pub program_id: Pubkey, + pub config_pda: Pubkey, + pub rent_sponsor: Pubkey, +} + +/// Sets up a test environment with program, config, and rent sponsor initialized. +pub async fn setup_test_env() -> TestEnv { + let program_id = Pubkey::new_from_array(pinocchio_counter::ID); + let config = + ProgramTestConfig::new_v2(true, Some(vec![("pinocchio_counter", program_id)])) + .with_light_protocol_events(); + + let mut rpc = LightProgramTest::new(config).await.unwrap(); + let payer = rpc.get_payer().insecure_clone(); + + let program_data_pda = setup_mock_program_data(&mut rpc, &payer, &program_id); + + let (rent_sponsor, _) = derive_rent_sponsor_pda(&program_id); + + let (init_config_ix, config_pda) = InitializeRentFreeConfig::new( + &program_id, + &payer.pubkey(), + &program_data_pda, + rent_sponsor, + payer.pubkey(), + ) + .build(); + + rpc.create_and_send_transaction(&[init_config_ix], &payer.pubkey(), &[&payer]) + .await + .expect("Initialize config should succeed"); + + // Fund the rent sponsor so it can pay for rent reimbursements + rpc.airdrop_lamports(&rent_sponsor, 1_000_000_000) + .await + .expect("Airdrop to rent sponsor should succeed"); + + TestEnv { + rpc, + payer, + program_id, + config_pda, + rent_sponsor, + } +} + +/// Derive the counter PDA. +pub fn derive_counter_pda(program_id: &Pubkey, owner: &Pubkey) -> (Pubkey, u8) { + Pubkey::find_program_address( + &[pinocchio_counter::COUNTER_SEED, owner.as_ref()], + program_id, + ) +} + +/// Asserts an account exists on-chain. +pub async fn assert_onchain_exists(rpc: &mut LightProgramTest, pda: &Pubkey, name: &str) { + assert!( + rpc.get_account(*pda).await.unwrap().is_some(), + "{} account ({}) should exist on-chain", + name, + pda + ); +} + +/// Asserts an account is closed on-chain. +pub async fn assert_onchain_closed(rpc: &mut LightProgramTest, pda: &Pubkey, name: &str) { + let acc = rpc.get_account(*pda).await.unwrap(); + assert!( + acc.is_none() || acc.unwrap().lamports == 0, + "{} account ({}) should be closed", + name, + pda + ); +} + +/// Build instruction data: discriminator + borsh-serialized params. +pub fn build_instruction_data(disc: &[u8; 8], params: &T) -> Vec { + let mut data = Vec::new(); + data.extend_from_slice(disc); + borsh::BorshSerialize::serialize(params, &mut data).unwrap(); + data +} + +/// Build instruction data with just a discriminator (no params). +pub fn build_instruction_data_no_params(disc: &[u8; 8]) -> Vec { + disc.to_vec() +} diff --git a/pinocchio/counter/tests/test_lifecycle.rs b/pinocchio/counter/tests/test_lifecycle.rs new file mode 100644 index 0000000..9e351d6 --- /dev/null +++ b/pinocchio/counter/tests/test_lifecycle.rs @@ -0,0 +1,260 @@ +//! Full lifecycle test for pinocchio-counter program. +//! +//! Tests the complete lifecycle: +//! 1. Setup - Initialize compression config +//! 2. Create - Create counter PDA with Light Protocol registration +//! 3. Increment - Mutate counter on-chain +//! 4. Advance Epoch - warp_slot_forward to trigger auto-compression +//! 5. Verify Compressed - Counter should be closed on-chain +//! 6. Decompress - Use CounterSdk + create_load_instructions to decompress +//! 7. Verify Restored - Counter exists again, state preserved +//! 8. Increment Again - Verify counter works after decompression + +mod sdk; +mod shared; + +use light_client::interface::{ + create_load_instructions, get_create_accounts_proof, AccountInterfaceExt, + CreateAccountsProofInput, LightProgramInterface, +}; +use light_program_test::program_test::LightProgramTest; +use light_program_test::{program_test::TestRpc, Rpc}; +use pinocchio_counter::{ + create_counter::CreateCounterParams, discriminators, CounterState, LightAccountVariant, +}; +use sdk::{CounterInstruction, CounterSdk}; +use solana_instruction::{AccountMeta, Instruction}; +use solana_pubkey::Pubkey; +use solana_signer::Signer; + +/// Slots per epoch for compression timing (matches light-compressible). +const SLOTS_PER_EPOCH: u64 = 13500; + +/// Build the create_counter instruction. +fn build_create_counter_instruction( + program_id: Pubkey, + payer: Pubkey, + owner: Pubkey, + counter_pda: Pubkey, + counter_bump: u8, + config_pda: Pubkey, + proof_result: &light_client::interface::CreateAccountsProofResult, +) -> Instruction { + let params = CreateCounterParams { + create_accounts_proof: proof_result.create_accounts_proof.clone(), + counter_bump, + }; + + // Account order per create_counter/accounts.rs: + // [0] payer (signer, writable) + // [1] owner (read-only) + // [2] counter (writable) + // [3] compressible_config (read-only) + // [4] system_program (read-only) + let accounts = vec![ + AccountMeta::new(payer, true), + AccountMeta::new_readonly(owner, false), + AccountMeta::new(counter_pda, false), + AccountMeta::new_readonly(config_pda, false), + AccountMeta::new_readonly(solana_sdk::system_program::ID, false), + ]; + + Instruction { + program_id, + accounts: [accounts, proof_result.remaining_accounts.clone()].concat(), + data: shared::build_instruction_data(&discriminators::CREATE_COUNTER, ¶ms), + } +} + +/// Build the increment instruction. +fn build_increment_instruction( + program_id: Pubkey, + owner: Pubkey, + counter_pda: Pubkey, +) -> Instruction { + // Account order per increment/accounts.rs: + // [0] owner (signer) + // [1] counter (writable) + let accounts = vec![ + AccountMeta::new_readonly(owner, true), + AccountMeta::new(counter_pda, false), + ]; + + Instruction { + program_id, + accounts, + data: shared::build_instruction_data_no_params(&discriminators::INCREMENT), + } +} + +#[tokio::test] +async fn test_full_lifecycle() { + // ==================== PHASE 1: Setup Environment ==================== + let env = shared::setup_test_env().await; + let mut rpc = env.rpc; + let payer = env.payer; + let program_id = env.program_id; + + let owner = payer.pubkey(); + + // ==================== PHASE 2: Derive Counter PDA ==================== + let (counter_pda, counter_bump) = shared::derive_counter_pda(&program_id, &owner); + println!("Counter PDA: {}", counter_pda); + + // ==================== PHASE 3: Get Proof and Create Counter ==================== + let proof_result = get_create_accounts_proof( + &rpc, + &program_id, + vec![CreateAccountsProofInput::pda(counter_pda)], + ) + .await + .expect("get_create_accounts_proof should succeed"); + + let create_ix = build_create_counter_instruction( + program_id, + payer.pubkey(), + owner, + counter_pda, + counter_bump, + env.config_pda, + &proof_result, + ); + + println!("Creating counter..."); + rpc.create_and_send_transaction(&[create_ix], &payer.pubkey(), &[&payer]) + .await + .expect("create_counter should succeed"); + + // ==================== PHASE 4: Verify Counter Exists ==================== + shared::assert_onchain_exists(&mut rpc, &counter_pda, "Counter").await; + + // Verify initial state + let account = rpc + .get_account(counter_pda) + .await + .unwrap() + .expect("Counter should exist"); + let counter: CounterState = + borsh::BorshDeserialize::deserialize(&mut &account.data[8..]).unwrap(); + assert_eq!(counter.count, 0, "Initial count should be 0"); + assert_eq!( + counter.owner, + owner.to_bytes(), + "Owner should match" + ); + println!("Counter created with count=0"); + + // ==================== PHASE 5: Increment Counter ==================== + let inc_ix = build_increment_instruction(program_id, owner, counter_pda); + + rpc.create_and_send_transaction(&[inc_ix], &payer.pubkey(), &[&payer]) + .await + .expect("increment should succeed"); + + // Verify count=1 + let account = rpc + .get_account(counter_pda) + .await + .unwrap() + .expect("Counter should exist"); + let counter: CounterState = + borsh::BorshDeserialize::deserialize(&mut &account.data[8..]).unwrap(); + assert_eq!(counter.count, 1, "Count should be 1 after increment"); + println!("Counter incremented to count=1"); + + // ==================== PHASE 6: Warp to Trigger Compression ==================== + println!("Warping forward to trigger compression..."); + rpc.warp_slot_forward(SLOTS_PER_EPOCH * 30).await.unwrap(); + + // ==================== PHASE 7: Verify Account Is Compressed ==================== + shared::assert_onchain_closed(&mut rpc, &counter_pda, "Counter").await; + println!("Counter compressed successfully!"); + + // ==================== PHASE 8: Create SDK from Compressed State ==================== + let counter_interface = rpc + .get_account_interface(&counter_pda, &program_id) + .await + .expect("counter should be compressed"); + assert!( + counter_interface.is_cold(), + "counter should be cold after warp" + ); + + let mut counter_sdk = CounterSdk::from_keyed_accounts(&[counter_interface]) + .expect("from_keyed_accounts should succeed"); + + // ==================== PHASE 9: Fetch and Update SDK ==================== + let accounts_to_fetch = + counter_sdk.get_accounts_to_update(&CounterInstruction::Increment); + let keyed_accounts = rpc + .get_multiple_account_interfaces(&accounts_to_fetch) + .await + .expect("get_multiple_account_interfaces should succeed"); + + counter_sdk + .update(&keyed_accounts) + .expect("sdk.update should succeed"); + + // ==================== PHASE 10: Build Load Instructions ==================== + let all_specs = + counter_sdk.get_specs_for_instruction(&CounterInstruction::Increment); + + let load_ixs = create_load_instructions::( + &all_specs, + payer.pubkey(), + env.config_pda, + &rpc, + ) + .await + .expect("create_load_instructions should succeed"); + + // ==================== PHASE 11: Execute Decompression ==================== + println!("Decompressing counter..."); + rpc.create_and_send_transaction(&load_ixs, &payer.pubkey(), &[&payer]) + .await + .expect("Decompression should succeed"); + + // ==================== PHASE 12: Verify Counter Is Restored ==================== + shared::assert_onchain_exists(&mut rpc, &counter_pda, "Counter").await; + + // Verify state is preserved + let account = rpc + .get_account(counter_pda) + .await + .unwrap() + .expect("Counter should exist after decompression"); + let counter: CounterState = + borsh::BorshDeserialize::deserialize(&mut &account.data[8..]).unwrap(); + assert_eq!( + counter.count, 1, + "Count should still be 1 after decompression" + ); + assert_eq!( + counter.owner, + owner.to_bytes(), + "Owner should be preserved" + ); + println!("Counter decompressed with count=1 preserved!"); + + // ==================== PHASE 13: Increment After Decompression ==================== + let inc_ix_2 = build_increment_instruction(program_id, owner, counter_pda); + + rpc.create_and_send_transaction(&[inc_ix_2], &payer.pubkey(), &[&payer]) + .await + .expect("increment after decompression should succeed"); + + // Verify count=2 + let account = rpc + .get_account(counter_pda) + .await + .unwrap() + .expect("Counter should exist"); + let counter: CounterState = + borsh::BorshDeserialize::deserialize(&mut &account.data[8..]).unwrap(); + assert_eq!( + counter.count, 2, + "Count should be 2 after second increment" + ); + + println!("Full lifecycle test completed successfully!"); +} From 107c88c1290fea50f556e5eb01d358b7c002aa57 Mon Sep 17 00:00:00 2001 From: tilo-14 Date: Fri, 13 Feb 2026 03:26:20 +0000 Subject: [PATCH 2/3] try refcator --- typescript-client/tests/load-ata/E2E-PLAN.md | 82 ++++++ typescript-client/tests/load-ata/README.md | 147 ++++++++++ typescript-client/tests/load-ata/cold-only.ts | 179 +++++++++++++ .../tests/load-ata/idempotency.ts | 105 ++++++++ .../tests/load-ata/load-and-transfer.ts | 182 +++++++++++++ typescript-client/tests/load-ata/setup.ts | 250 ++++++++++++++++++ .../tests/load-ata/spl-sources.ts | 173 ++++++++++++ .../tests/load-ata/t22-sources.ts | 135 ++++++++++ 8 files changed, 1253 insertions(+) create mode 100644 typescript-client/tests/load-ata/E2E-PLAN.md create mode 100644 typescript-client/tests/load-ata/README.md create mode 100644 typescript-client/tests/load-ata/cold-only.ts create mode 100644 typescript-client/tests/load-ata/idempotency.ts create mode 100644 typescript-client/tests/load-ata/load-and-transfer.ts create mode 100644 typescript-client/tests/load-ata/setup.ts create mode 100644 typescript-client/tests/load-ata/spl-sources.ts create mode 100644 typescript-client/tests/load-ata/t22-sources.ts diff --git a/typescript-client/tests/load-ata/E2E-PLAN.md b/typescript-client/tests/load-ata/E2E-PLAN.md new file mode 100644 index 0000000..3bcdb77 --- /dev/null +++ b/typescript-client/tests/load-ata/E2E-PLAN.md @@ -0,0 +1,82 @@ +# E2E: Verify loadAta multi-account fix + +## Context + +The `sources.find` → `sources.filter` fix for `loadAta` is merged into `light-protocol` main. The examples project (`package.json`) links locally to `../../light-protocol/js/compressed-token` and `../../light-protocol/js/stateless.js`. + +Because `tsx` resolves raw `.ts` source from `file:` links (bypassing rollup's `__BUILD_VERSION__` replacement), all test commands need `LIGHT_PROTOCOL_VERSION=V2`. + +## Steps + +```yaml +tasks: + - id: 1 + name: Rebuild SDK packages with V2 + commands: + - cd ~/Workspace/light-protocol/js/stateless.js && pnpm run build + - cd ~/Workspace/light-protocol/js/compressed-token && LIGHT_PROTOCOL_VERSION=V2 pnpm run build + why: Ensure dist/ reflects latest main + fix + + - id: 2 + name: Install deps in examples project + command: cd ~/Workspace/examples-light-token/typescript-client && npm install + depends_on: [1] + + - id: 3 + name: Run cold-only tests + command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:cold + depends_on: [2] + expect: All 9 scenarios pass (A1-A9) + + - id: 4 + name: Run SPL source tests + command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:spl + depends_on: [2] + expect: All 7 scenarios pass (B1-B7) + + - id: 5 + name: Run T22 source tests + command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:t22 + depends_on: [2] + expect: All 5 scenarios pass (C1-C5) + + - id: 6 + name: Run load+transfer tests + command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:transfer + depends_on: [2] + expect: All 4 scenarios pass (D1-D4) + + - id: 7 + name: Run idempotency tests + command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:idempotency + depends_on: [2] + expect: All 3 scenarios pass (E1-E3) + + - id: 8 + name: Full suite (confirms sequential pass) + command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata + depends_on: [3, 4, 5, 6, 7] + expect: All 28 scenarios pass end-to-end +``` + +## Prerequisites + +- Local test validator running with Light programs loaded +- Solana CLI configured for localnet (`solana config set -ul`) +- Payer keypair at `~/.config/solana/id.json` with SOL balance + +## Permissions needed for auto mode + +| Permission | Commands | Why | +|---|---|---| +| Build SDK | `pnpm run build` in light-protocol/js/* | Rebuild dist from source | +| Install deps | `npm install` in examples project | Link local packages | +| Run tests | `npm run test:load-ata*` with env var | Execute test scripts via tsx | + +All commands are local, read-only on chain (mints + transfers to localnet only), and reversible. + +## If tests fail + +- **V2 error persists**: tsx still hitting raw source. Try `rm -rf node_modules && npm install` +- **Indexer timeout**: Validator may need restart — `light test-validator` in separate terminal +- **Balance mismatch**: Check `coldBalance` computation in load-ata.ts line ~414 diff --git a/typescript-client/tests/load-ata/README.md b/typescript-client/tests/load-ata/README.md new file mode 100644 index 0000000..9efb6c3 --- /dev/null +++ b/typescript-client/tests/load-ata/README.md @@ -0,0 +1,147 @@ +# loadAta edge case tests + +28 scenarios testing `loadAta` across all combinations of cold (compressed) accounts, Light ATA state, and SPL/T22 ATAs. + +## Imports: standard vs unified + +The SDK exports `loadAta` from two entry points: + +| Entry point | Import path | Wraps SPL/T22 ATA | +|---|---|---| +| Standard | `@lightprotocol/compressed-token` | No — cold accounts only | +| Unified | `@lightprotocol/compressed-token/unified` | Yes — wraps SPL/T22 ATA balance into Light ATA | + +Tests that involve SPL or T22 wrapping (`spl-sources.ts`, `t22-sources.ts`, `load-and-transfer.ts`, `idempotency.ts`) import from the **unified** entry point. `cold-only.ts` uses the standard import since no wrapping is needed. + +The unified `loadAta` sets `wrap=true` internally. For cold-only scenarios this is a no-op (no SPL/T22 ATA exists to wrap), so unified works for all cases. The standard version never wraps. + +## Account limit + +Each `loadAta` call decompresses up to **8 compressed accounts** per instruction. If an owner has more than 8 cold accounts, call `loadAta` repeatedly until it returns `null`. + +## Run + +Requires a running local validator: + +```bash +light test-validator +``` + +Run all scenarios: + +```bash +npm run test:load-ata +``` + +Run individually: + +```bash +npm run test:load-ata:cold +npm run test:load-ata:spl +npm run test:load-ata:t22 +npm run test:load-ata:transfer +npm run test:load-ata:idempotency +``` + +## Scenarios + +Each scenario uses a fresh mint and owner keypair for isolation. Cold accounts hold 100 tokens each. + +### Cold only — Light mint (`cold-only.ts`) + +Tests `loadAta` with compressed accounts only (no SPL/T22 involvement). + +| # | Cold | Light ATA | Expected result | +|---|------|-----------|-----------------| +| A1 | 1 | none | Creates ATA, loads 1. Balance = 100 | +| A2 | 2 | none | Creates ATA, loads 2. Balance = 200 | +| A3 | 4 | none | Creates ATA, loads 4. Balance = 400 | +| A4 | 8 | none | Creates ATA, loads 8 (max). Balance = 800 | +| A5 | 1 | exists, empty | Loads 1. Balance = 100 | +| A6 | 4 | exists, 500 | Loads 4. Balance = 900 | +| A7 | 8 | exists, 500 | Loads 8. Balance = 1300 | +| A8 | 0 | none | Returns `null`. No ATA created | +| A9 | 0 | exists, 500 | Returns `null`. Balance unchanged at 500 | + +### SPL sources (`spl-sources.ts`) + +Tests `loadAta` with an SPL mint. `loadAta` wraps SPL ATA balance into the Light ATA automatically. + +| # | Cold | SPL ATA | Light ATA | Expected result | +|---|------|---------|-----------|-----------------| +| B1 | 0 | 1000 | none | Creates ATA, wraps SPL. Balance = 1000 | +| B2 | 1 | 1000 | none | Creates ATA, loads 1 + wraps. Balance = 1100 | +| B3 | 4 | 1000 | none | Creates ATA, loads 4 + wraps. Balance = 1400 | +| B4 | 8 | 1000 | none | Creates ATA, loads 8 + wraps. Balance = 1800 | +| B5 | 4 | 1000 | exists, 500 | Loads 4 + wraps. Balance = 1900 | +| B6 | 4 | 0 | none | Creates ATA, loads cold only. Balance = 400 | +| B7 | 0 | 0 | none | Returns `null` | + +### T22 sources (`t22-sources.ts`) + +Tests `loadAta` with a Token-2022 mint. Same wrapping behavior as SPL. + +| # | Cold | T22 ATA | Light ATA | Expected result | +|---|------|---------|-----------|-----------------| +| C1 | 0 | 1000 | none | Creates ATA, wraps T22. Balance = 1000 | +| C2 | 1 | 1000 | none | Creates ATA, loads 1 + wraps. Balance = 1100 | +| C3 | 4 | 1000 | none | Creates ATA, loads 4 + wraps. Balance = 1400 | +| C4 | 8 | 1000 | exists, 500 | Loads 8 + wraps. Balance = 2300 | +| C5 | 4 | 0 | none | Creates ATA, loads cold only. Balance = 400 | + +### Load + transfer (`load-and-transfer.ts`) + +Tests composing `createLoadAtaInstructions` with `createTransferInterfaceInstruction` in a single transaction. + +| # | Sources | Mint type | Expected result | +|---|---------|-----------|-----------------| +| D1 | 1 cold | Light | Load + transfer 50 in 1 tx | +| D2 | 4 cold | Light | Load + transfer 50 in 1 tx | +| D3 | 2 cold + 1000 SPL ATA | SPL | Load + wrap + transfer 50 in 1 tx | +| D4 | 2 cold + 1000 T22 ATA | T22 | Load + wrap + transfer 50 in 1 tx | + +### Idempotency (`idempotency.ts`) + +Tests repeated `loadAta` calls on the same ATA. + +| # | Scenario | Expected result | +|---|----------|-----------------| +| E1 | Load 2 cold, then load again | Second call returns `null` | +| E2 | Load 2 cold, mint 2 more cold, load again | Second call loads the 2 new ones | +| E3 | Load 1 cold + 1000 SPL, then load again | Second call returns `null` | + +## Setup (`setup.ts`) + +Shared utilities used across all test files. Connects to localnet RPC and reads the payer keypair from `~/.config/solana/id.json`. + +### Mint creators + +| Function | Creates | +|----------|---------| +| `createLightMint()` | Light mint (no token program) | +| `createSplMint()` | SPL mint + Light interface PDA | +| `createT22Mint()` | T22 mint + Light interface PDA | + +### Account creators + +| Function | Does | +|----------|------| +| `createMultipleCompressed(mint, owner, count, amountEach)` | Calls `mintToCompressed` N times to create N cold accounts | +| `createLightAtaWithBalance(mint, owner, amount?)` | Creates Light ATA, optionally mints tokens to it | +| `getSplAtaWithBalance(mint, owner, amount)` | Creates SPL ATA via `@solana/spl-token`, mints tokens to it | +| `getT22AtaWithBalance(mint, owner, amount)` | Creates T22 ATA via `@solana/spl-token`, mints tokens to it | + +### Balance readers + +| Function | Returns | +|----------|---------| +| `getCompressedCount(owner, mint)` | Number of compressed accounts for owner + mint | +| `getLightAtaBalance(ata, owner, mint)` | Light ATA token balance (0 if account doesn't exist) | +| `getSplAtaBalance(ata, programId?)` | SPL/T22 ATA balance (0 if account doesn't exist) | + +### Assertions + +| Function | Does | +|----------|------| +| `assert(condition, msg)` | Throws on failure | +| `logScenario(name, expected, actual)` | Prints `[PASS]` or `[FAIL]` with values, throws on mismatch | diff --git a/typescript-client/tests/load-ata/cold-only.ts b/typescript-client/tests/load-ata/cold-only.ts new file mode 100644 index 0000000..6f01755 --- /dev/null +++ b/typescript-client/tests/load-ata/cold-only.ts @@ -0,0 +1,179 @@ +import "dotenv/config"; +import { Keypair } from "@solana/web3.js"; +import { loadAta } from "@lightprotocol/compressed-token"; +import { + rpc, + payer, + createMultipleCompressed, + createSplMint, + createLightAtaWithBalance, + waitForCompressedCount, + getLightAtaBalance, + getAssociatedTokenAddressInterface, + assert, + logScenario, +} from "./setup.js"; + +const AMOUNT_EACH = 100n; + +(async function () { + console.log("\n=== Cold-Only Scenarios (SPL Mint) ===\n"); + + // ── Setup ────────────────────────────────────────────── + // Create all mints, owners, and compressed accounts upfront. + // By the time setup completes, the indexer has had time to + // reflect all state — matching real-world usage where + // accounts exist well before loadAta is called. + + console.log(" Setting up scenarios...\n"); + + // A1: 1 cold, no ATA + const a1Mint = await createSplMint(); + const a1Owner = Keypair.generate(); + await createMultipleCompressed(a1Mint, a1Owner.publicKey, 1, AMOUNT_EACH); + + // A2: 2 cold, no ATA + const a2Mint = await createSplMint(); + const a2Owner = Keypair.generate(); + await createMultipleCompressed(a2Mint, a2Owner.publicKey, 2, AMOUNT_EACH); + + // A3: 4 cold, no ATA + const a3Mint = await createSplMint(); + const a3Owner = Keypair.generate(); + await createMultipleCompressed(a3Mint, a3Owner.publicKey, 4, AMOUNT_EACH); + + // A4: 8 cold, no ATA + const a4Mint = await createSplMint(); + const a4Owner = Keypair.generate(); + await createMultipleCompressed(a4Mint, a4Owner.publicKey, 8, AMOUNT_EACH); + + // A5: 1 cold, ATA exists (empty) + const a5Mint = await createSplMint(); + const a5Owner = Keypair.generate(); + await createLightAtaWithBalance(a5Mint, a5Owner); + await createMultipleCompressed(a5Mint, a5Owner.publicKey, 1, AMOUNT_EACH); + + // A6: 4 cold, ATA exists with 500 + const a6Mint = await createSplMint(); + const a6Owner = Keypair.generate(); + await createLightAtaWithBalance(a6Mint, a6Owner, 500n); + await createMultipleCompressed(a6Mint, a6Owner.publicKey, 4, AMOUNT_EACH); + + // A7: 8 cold, ATA exists with 500 + const a7Mint = await createSplMint(); + const a7Owner = Keypair.generate(); + await createLightAtaWithBalance(a7Mint, a7Owner, 500n); + await createMultipleCompressed(a7Mint, a7Owner.publicKey, 8, AMOUNT_EACH); + + // A8: 0 cold, no ATA + const a8Mint = await createSplMint(); + const a8Owner = Keypair.generate(); + + // A9: 0 cold, ATA exists with 500 + const a9Mint = await createSplMint(); + const a9Owner = Keypair.generate(); + await createLightAtaWithBalance(a9Mint, a9Owner, 500n); + + // ── Tests ────────────────────────────────────────────── + + console.log(" Running tests...\n"); + + // A1: 1 cold, no ATA -> creates ATA, loads 1 + { + const ata = getAssociatedTokenAddressInterface(a1Mint, a1Owner.publicKey); + const tx = await loadAta(rpc, ata, a1Owner, a1Mint, payer); + assert(tx !== null, "A1: should return tx signature"); + + await waitForCompressedCount(a1Owner.publicKey, a1Mint, 0); + const balance = await getLightAtaBalance(ata, a1Owner.publicKey, a1Mint); + logScenario("A1: 1 cold, no ATA", 1n * AMOUNT_EACH, balance); + } + + // A2: 2 cold, no ATA -> creates ATA, loads 2 + { + const ata = getAssociatedTokenAddressInterface(a2Mint, a2Owner.publicKey); + const tx = await loadAta(rpc, ata, a2Owner, a2Mint, payer); + assert(tx !== null, "A2: should return tx signature"); + + await waitForCompressedCount(a2Owner.publicKey, a2Mint, 0); + const balance = await getLightAtaBalance(ata, a2Owner.publicKey, a2Mint); + logScenario("A2: 2 cold, no ATA", 2n * AMOUNT_EACH, balance); + } + + // A3: 4 cold, no ATA -> creates ATA, loads 4 + { + const ata = getAssociatedTokenAddressInterface(a3Mint, a3Owner.publicKey); + const tx = await loadAta(rpc, ata, a3Owner, a3Mint, payer); + assert(tx !== null, "A3: should return tx signature"); + + await waitForCompressedCount(a3Owner.publicKey, a3Mint, 0); + const balance = await getLightAtaBalance(ata, a3Owner.publicKey, a3Mint); + logScenario("A3: 4 cold, no ATA", 4n * AMOUNT_EACH, balance); + } + + // A4: 8 cold, no ATA -> creates ATA, loads 8 (max) + { + const ata = getAssociatedTokenAddressInterface(a4Mint, a4Owner.publicKey); + const tx = await loadAta(rpc, ata, a4Owner, a4Mint, payer); + assert(tx !== null, "A4: should return tx signature"); + + await waitForCompressedCount(a4Owner.publicKey, a4Mint, 0); + const balance = await getLightAtaBalance(ata, a4Owner.publicKey, a4Mint); + logScenario("A4: 8 cold, no ATA", 8n * AMOUNT_EACH, balance); + } + + // A5: 1 cold, ATA exists (empty) -> loads 1 + { + const ata = getAssociatedTokenAddressInterface(a5Mint, a5Owner.publicKey); + const tx = await loadAta(rpc, ata, a5Owner, a5Mint, payer); + assert(tx !== null, "A5: should return tx signature"); + + await waitForCompressedCount(a5Owner.publicKey, a5Mint, 0); + const balance = await getLightAtaBalance(ata, a5Owner.publicKey, a5Mint); + logScenario("A5: 1 cold, ATA exists (empty)", 1n * AMOUNT_EACH, balance); + } + + // A6: 4 cold, ATA exists with 500 -> loads 4, total = 500 + 4*100 + { + const ata = getAssociatedTokenAddressInterface(a6Mint, a6Owner.publicKey); + const tx = await loadAta(rpc, ata, a6Owner, a6Mint, payer); + assert(tx !== null, "A6: should return tx signature"); + + await waitForCompressedCount(a6Owner.publicKey, a6Mint, 0); + const balance = await getLightAtaBalance(ata, a6Owner.publicKey, a6Mint); + logScenario("A6: 4 cold, ATA has 500", 500n + 4n * AMOUNT_EACH, balance); + } + + // A7: 8 cold, ATA exists with 500 -> loads 8, total = 500 + 8*100 + { + const ata = getAssociatedTokenAddressInterface(a7Mint, a7Owner.publicKey); + const tx = await loadAta(rpc, ata, a7Owner, a7Mint, payer); + assert(tx !== null, "A7: should return tx signature"); + + await waitForCompressedCount(a7Owner.publicKey, a7Mint, 0); + const balance = await getLightAtaBalance(ata, a7Owner.publicKey, a7Mint); + logScenario("A7: 8 cold, ATA has 500", 500n + 8n * AMOUNT_EACH, balance); + } + + // A8: 0 cold, no ATA -> returns null, no ATA created + { + const ata = getAssociatedTokenAddressInterface(a8Mint, a8Owner.publicKey); + const tx = await loadAta(rpc, ata, a8Owner, a8Mint, payer); + assert(tx === null, "A8: should return null"); + + const balance = await getLightAtaBalance(ata, a8Owner.publicKey, a8Mint); + logScenario("A8: 0 cold, no ATA", 0n, balance); + } + + // A9: 0 cold, ATA exists with 500 -> returns null, balance unchanged + { + const ata = getAssociatedTokenAddressInterface(a9Mint, a9Owner.publicKey); + const tx = await loadAta(rpc, ata, a9Owner, a9Mint, payer); + assert(tx === null, "A9: should return null"); + + const balance = await getLightAtaBalance(ata, a9Owner.publicKey, a9Mint); + logScenario("A9: 0 cold, ATA has 500", 500n, balance); + } + + console.log("\n=== All Cold-Only Scenarios Passed ===\n"); +})(); diff --git a/typescript-client/tests/load-ata/idempotency.ts b/typescript-client/tests/load-ata/idempotency.ts new file mode 100644 index 0000000..43d1f93 --- /dev/null +++ b/typescript-client/tests/load-ata/idempotency.ts @@ -0,0 +1,105 @@ +import "dotenv/config"; +import { Keypair } from "@solana/web3.js"; +import { loadAta } from "@lightprotocol/compressed-token/unified"; +import { + rpc, + payer, + createMultipleCompressed, + createSplMint, + getSplAtaWithBalance, + getCompressedCount, + waitForCompressedCount, + getLightAtaBalance, + getAssociatedTokenAddressInterface, + assert, + logScenario, +} from "./setup.js"; + +const AMOUNT_EACH = 100n; + +(async function () { + console.log("\n=== Idempotency Scenarios ===\n"); + + // ── Setup ────────────────────────────────────────────── + + console.log(" Setting up scenarios...\n"); + + // E1: 2 cold (SPL mint) + const e1Mint = await createSplMint(); + const e1Owner = Keypair.generate(); + await createMultipleCompressed(e1Mint, e1Owner.publicKey, 2, AMOUNT_EACH); + + // E2: 2 cold (SPL mint) — second batch compressed mid-test + const e2Mint = await createSplMint(); + const e2Owner = Keypair.generate(); + await createMultipleCompressed(e2Mint, e2Owner.publicKey, 2, AMOUNT_EACH); + + // E3: 1 cold + 1000 SPL + const e3Mint = await createSplMint(); + const e3Owner = Keypair.generate(); + await createMultipleCompressed(e3Mint, e3Owner.publicKey, 1, AMOUNT_EACH); + await getSplAtaWithBalance(e3Mint, e3Owner.publicKey, 1000n); + + // ── Tests ────────────────────────────────────────────── + + console.log(" Running tests...\n"); + + // E1: Load, then load again immediately -> second returns null + { + const ata = getAssociatedTokenAddressInterface(e1Mint, e1Owner.publicKey); + + const tx1 = await loadAta(rpc, ata, e1Owner, e1Mint, payer); + assert(tx1 !== null, "E1: first load should return tx"); + + await waitForCompressedCount(e1Owner.publicKey, e1Mint, 0); + + const tx2 = await loadAta(rpc, ata, e1Owner, e1Mint, payer); + assert(tx2 === null, "E1: second load should return null"); + + const balance = await getLightAtaBalance(ata, e1Owner.publicKey, e1Mint); + logScenario("E1: load then load again", 2n * AMOUNT_EACH, balance); + } + + // E2: Load, create 2 more cold, load again -> second loads the 2 new ones + { + const ata = getAssociatedTokenAddressInterface(e2Mint, e2Owner.publicKey); + + const tx1 = await loadAta(rpc, ata, e2Owner, e2Mint, payer); + assert(tx1 !== null, "E2: first load should return tx"); + + const balanceAfterFirst = await getLightAtaBalance(ata, e2Owner.publicKey, e2Mint); + assert(balanceAfterFirst === 2n * AMOUNT_EACH, "E2: first load balance check"); + + // Mint 2 more compressed accounts mid-test (inherently sequential) + await createMultipleCompressed(e2Mint, e2Owner.publicKey, 2, AMOUNT_EACH); + + const coldCount = await getCompressedCount(e2Owner.publicKey, e2Mint); + assert(coldCount === 2, "E2: should have 2 new compressed accounts"); + + const tx2 = await loadAta(rpc, ata, e2Owner, e2Mint, payer); + assert(tx2 !== null, "E2: second load should return tx (new cold accounts)"); + + await waitForCompressedCount(e2Owner.publicKey, e2Mint, 0); + + const balance = await getLightAtaBalance(ata, e2Owner.publicKey, e2Mint); + logScenario("E2: load, add 2 more cold, load again", 4n * AMOUNT_EACH, balance); + } + + // E3: Load SPL wrap, then load again -> second returns null + { + const ata = getAssociatedTokenAddressInterface(e3Mint, e3Owner.publicKey); + + const tx1 = await loadAta(rpc, ata, e3Owner, e3Mint, payer); + assert(tx1 !== null, "E3: first load should return tx"); + + await waitForCompressedCount(e3Owner.publicKey, e3Mint, 0); + + const tx2 = await loadAta(rpc, ata, e3Owner, e3Mint, payer); + assert(tx2 === null, "E3: second load should return null"); + + const balance = await getLightAtaBalance(ata, e3Owner.publicKey, e3Mint); + logScenario("E3: load SPL+cold, then load again", 1n * AMOUNT_EACH + 1000n, balance); + } + + console.log("\n=== All Idempotency Scenarios Passed ===\n"); +})(); diff --git a/typescript-client/tests/load-ata/load-and-transfer.ts b/typescript-client/tests/load-ata/load-and-transfer.ts new file mode 100644 index 0000000..6f164f2 --- /dev/null +++ b/typescript-client/tests/load-ata/load-and-transfer.ts @@ -0,0 +1,182 @@ +import "dotenv/config"; +import { Keypair } from "@solana/web3.js"; +import { + createLoadAtaInstructions, + createTransferInterfaceInstruction, +} from "@lightprotocol/compressed-token/unified"; +import { + buildAndSignTx, + sendAndConfirmTx, +} from "@lightprotocol/stateless.js"; +import { + rpc, + payer, + createMultipleCompressed, + createSplMint, + createT22Mint, + TOKEN_2022_PROGRAM_ID, + getSplAtaWithBalance, + getT22AtaWithBalance, + getLightAtaBalance, + getAssociatedTokenAddressInterface, + createAtaInterface, + assert, + logScenario, +} from "./setup.js"; + +const AMOUNT_EACH = 100n; +const TRANSFER_AMOUNT = 50; + +(async function () { + console.log("\n=== Load + Transfer in Single Tx ===\n"); + + // ── Setup ────────────────────────────────────────────── + + console.log(" Setting up scenarios...\n"); + + // D1: 1 cold (SPL mint) + const d1Mint = await createSplMint(); + const d1Sender = Keypair.generate(); + const d1Recipient = Keypair.generate(); + await createMultipleCompressed(d1Mint, d1Sender.publicKey, 1, AMOUNT_EACH); + await createAtaInterface(rpc, payer, d1Mint, d1Recipient.publicKey); + + // D2: 4 cold (SPL mint) + const d2Mint = await createSplMint(); + const d2Sender = Keypair.generate(); + const d2Recipient = Keypair.generate(); + await createMultipleCompressed(d2Mint, d2Sender.publicKey, 4, AMOUNT_EACH); + await createAtaInterface(rpc, payer, d2Mint, d2Recipient.publicKey); + + // D3: 2 cold + 1000 SPL + const d3Mint = await createSplMint(); + const d3Sender = Keypair.generate(); + const d3Recipient = Keypair.generate(); + await createMultipleCompressed(d3Mint, d3Sender.publicKey, 2, AMOUNT_EACH); + await getSplAtaWithBalance(d3Mint, d3Sender.publicKey, 1000n); + await createAtaInterface(rpc, payer, d3Mint, d3Recipient.publicKey); + + // D4: 2 cold + 1000 T22 + const d4Mint = await createT22Mint(); + const d4Sender = Keypair.generate(); + const d4Recipient = Keypair.generate(); + await createMultipleCompressed(d4Mint, d4Sender.publicKey, 2, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); + await getT22AtaWithBalance(d4Mint, d4Sender.publicKey, 1000n); + await createAtaInterface(rpc, payer, d4Mint, d4Recipient.publicKey); + + // ── Tests ────────────────────────────────────────────── + + console.log(" Running tests...\n"); + + // D1: 1 cold (SPL mint) -> load + transfer in 1 tx + { + const senderAta = getAssociatedTokenAddressInterface(d1Mint, d1Sender.publicKey); + const recipientAta = getAssociatedTokenAddressInterface(d1Mint, d1Recipient.publicKey); + + const loadIxs = await createLoadAtaInstructions( + rpc, senderAta, d1Sender.publicKey, d1Mint, payer.publicKey, + ); + assert(loadIxs.length > 0, "D1: should have load instructions"); + + const transferIx = createTransferInterfaceInstruction( + senderAta, recipientAta, d1Sender.publicKey, TRANSFER_AMOUNT, + ); + + const blockhash = await rpc.getLatestBlockhash(); + const tx = buildAndSignTx( + [...loadIxs, transferIx], payer, blockhash.blockhash, [d1Sender], + ); + await sendAndConfirmTx(rpc, tx); + + const senderBalance = await getLightAtaBalance(senderAta, d1Sender.publicKey, d1Mint); + const recipientBalance = await getLightAtaBalance(recipientAta, d1Recipient.publicKey, d1Mint); + + logScenario("D1: sender balance after load+transfer", 1n * AMOUNT_EACH - BigInt(TRANSFER_AMOUNT), senderBalance); + logScenario("D1: recipient balance after load+transfer", BigInt(TRANSFER_AMOUNT), recipientBalance); + } + + // D2: 4 cold (SPL mint) -> load + transfer in 1 tx + { + const senderAta = getAssociatedTokenAddressInterface(d2Mint, d2Sender.publicKey); + const recipientAta = getAssociatedTokenAddressInterface(d2Mint, d2Recipient.publicKey); + + const loadIxs = await createLoadAtaInstructions( + rpc, senderAta, d2Sender.publicKey, d2Mint, payer.publicKey, + ); + assert(loadIxs.length > 0, "D2: should have load instructions"); + + const transferIx = createTransferInterfaceInstruction( + senderAta, recipientAta, d2Sender.publicKey, TRANSFER_AMOUNT, + ); + + const blockhash = await rpc.getLatestBlockhash(); + const tx = buildAndSignTx( + [...loadIxs, transferIx], payer, blockhash.blockhash, [d2Sender], + ); + await sendAndConfirmTx(rpc, tx); + + const senderBalance = await getLightAtaBalance(senderAta, d2Sender.publicKey, d2Mint); + const recipientBalance = await getLightAtaBalance(recipientAta, d2Recipient.publicKey, d2Mint); + + logScenario("D2: sender (4 cold load+transfer)", 4n * AMOUNT_EACH - BigInt(TRANSFER_AMOUNT), senderBalance); + logScenario("D2: recipient (4 cold load+transfer)", BigInt(TRANSFER_AMOUNT), recipientBalance); + } + + // D3: SPL ATA + 2 cold -> load + wrap + transfer in 1 tx + { + const senderAta = getAssociatedTokenAddressInterface(d3Mint, d3Sender.publicKey); + const recipientAta = getAssociatedTokenAddressInterface(d3Mint, d3Recipient.publicKey); + + const loadIxs = await createLoadAtaInstructions( + rpc, senderAta, d3Sender.publicKey, d3Mint, payer.publicKey, + ); + assert(loadIxs.length > 0, "D3: should have load instructions"); + + const transferIx = createTransferInterfaceInstruction( + senderAta, recipientAta, d3Sender.publicKey, TRANSFER_AMOUNT, + ); + + const blockhash = await rpc.getLatestBlockhash(); + const tx = buildAndSignTx( + [...loadIxs, transferIx], payer, blockhash.blockhash, [d3Sender], + ); + await sendAndConfirmTx(rpc, tx); + + const senderBalance = await getLightAtaBalance(senderAta, d3Sender.publicKey, d3Mint); + const recipientBalance = await getLightAtaBalance(recipientAta, d3Recipient.publicKey, d3Mint); + const totalLoaded = 2n * AMOUNT_EACH + 1000n; + + logScenario("D3: sender (SPL+2 cold load+transfer)", totalLoaded - BigInt(TRANSFER_AMOUNT), senderBalance); + logScenario("D3: recipient (SPL+2 cold load+transfer)", BigInt(TRANSFER_AMOUNT), recipientBalance); + } + + // D4: T22 ATA + 2 cold -> load + wrap + transfer in 1 tx + { + const senderAta = getAssociatedTokenAddressInterface(d4Mint, d4Sender.publicKey); + const recipientAta = getAssociatedTokenAddressInterface(d4Mint, d4Recipient.publicKey); + + const loadIxs = await createLoadAtaInstructions( + rpc, senderAta, d4Sender.publicKey, d4Mint, payer.publicKey, + ); + assert(loadIxs.length > 0, "D4: should have load instructions"); + + const transferIx = createTransferInterfaceInstruction( + senderAta, recipientAta, d4Sender.publicKey, TRANSFER_AMOUNT, + ); + + const blockhash = await rpc.getLatestBlockhash(); + const tx = buildAndSignTx( + [...loadIxs, transferIx], payer, blockhash.blockhash, [d4Sender], + ); + await sendAndConfirmTx(rpc, tx); + + const senderBalance = await getLightAtaBalance(senderAta, d4Sender.publicKey, d4Mint); + const recipientBalance = await getLightAtaBalance(recipientAta, d4Recipient.publicKey, d4Mint); + const totalLoaded = 2n * AMOUNT_EACH + 1000n; + + logScenario("D4: sender (T22+2 cold load+transfer)", totalLoaded - BigInt(TRANSFER_AMOUNT), senderBalance); + logScenario("D4: recipient (T22+2 cold load+transfer)", BigInt(TRANSFER_AMOUNT), recipientBalance); + } + + console.log("\n=== All Load+Transfer Scenarios Passed ===\n"); +})(); diff --git a/typescript-client/tests/load-ata/setup.ts b/typescript-client/tests/load-ata/setup.ts new file mode 100644 index 0000000..386e039 --- /dev/null +++ b/typescript-client/tests/load-ata/setup.ts @@ -0,0 +1,250 @@ +import { Keypair, PublicKey } from "@solana/web3.js"; +import { createRpc, Rpc } from "@lightprotocol/stateless.js"; +import { + createMintInterface, + compress, + createAtaInterface, + loadAta, + getAssociatedTokenAddressInterface, + getAtaInterface, +} from "@lightprotocol/compressed-token"; +import { + createAssociatedTokenAccount, + getOrCreateAssociatedTokenAccount, + mintTo, + getAccount, + TOKEN_PROGRAM_ID, + TOKEN_2022_PROGRAM_ID, +} from "@solana/spl-token"; +import { homedir } from "os"; +import { readFileSync } from "fs"; + +// localnet RPC +export const rpc: Rpc = createRpc(); + +export const payer = Keypair.fromSecretKey( + new Uint8Array( + JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8")), + ), +); + +// Create N compressed token accounts for owner, each with `amountEach`. +// Mints tokens to payer's ATA, then compresses into cold accounts owned by `owner`. +// Waits for the indexer to reflect all new accounts before returning. +export async function createMultipleCompressed( + mint: PublicKey, + owner: PublicKey, + count: number, + amountEach: bigint, + tokenProgramId: PublicKey = TOKEN_PROGRAM_ID, +): Promise { + const before = await getCompressedCount(owner, mint); + + // Get or create payer's ATA for this mint + const payerAta = await getOrCreateAssociatedTokenAccount( + rpc, payer, mint, payer.publicKey, undefined, undefined, undefined, tokenProgramId, + ); + + // Mint total amount to payer's ATA + const totalAmount = amountEach * BigInt(count); + await mintTo(rpc, payer, mint, payerAta.address, payer, totalAmount, [], undefined, tokenProgramId); + + // Compress into N cold accounts owned by `owner` + const amounts = Array(count).fill(Number(amountEach)); + const recipients = Array(count).fill(owner); + await compress(rpc, payer, mint, amounts, payer, payerAta.address, recipients); + + const expected = before + count; + const deadline = Date.now() + 30_000; + while (Date.now() < deadline) { + const indexed = await getCompressedCount(owner, mint); + if (indexed >= expected) return; + await new Promise((r) => setTimeout(r, 200)); + } + throw new Error( + `Indexer timeout: expected ${expected} compressed accounts, got ${await getCompressedCount(owner, mint)}`, + ); +} + +// Create SPL ATA and mint tokens into it +export async function getSplAtaWithBalance( + mint: PublicKey, + owner: PublicKey, + amount: bigint, +): Promise { + const ata = await createAssociatedTokenAccount( + rpc, + payer, + mint, + owner, + undefined, + TOKEN_PROGRAM_ID, + ); + if (amount > 0n) { + await mintTo(rpc, payer, mint, ata, payer, amount, [], undefined, TOKEN_PROGRAM_ID); + } + return ata; +} + +// Create T22 ATA and mint tokens into it +export async function getT22AtaWithBalance( + mint: PublicKey, + owner: PublicKey, + amount: bigint, +): Promise { + const ata = await createAssociatedTokenAccount( + rpc, + payer, + mint, + owner, + undefined, + TOKEN_2022_PROGRAM_ID, + ); + if (amount > 0n) { + await mintTo(rpc, payer, mint, ata, payer, amount, [], undefined, TOKEN_2022_PROGRAM_ID); + } + return ata; +} + +// Count compressed token accounts for owner + mint +export async function getCompressedCount( + owner: PublicKey, + mint: PublicKey, +): Promise { + const result = await rpc.getCompressedTokenAccountsByOwner(owner, { + mint, + }); + return result.items.length; +} + +// Poll indexer until compressed count reaches expected value. +// Use after loadAta to wait for consumed accounts to disappear from the index. +export async function waitForCompressedCount( + owner: PublicKey, + mint: PublicKey, + expected: number, + timeoutMs = 30_000, +): Promise { + const deadline = Date.now() + timeoutMs; + while (Date.now() < deadline) { + const count = await getCompressedCount(owner, mint); + if (count === expected) return; + await new Promise((r) => setTimeout(r, 200)); + } + const actual = await getCompressedCount(owner, mint); + throw new Error( + `Indexer timeout: expected ${expected} compressed accounts, got ${actual}`, + ); +} + +// Get Light ATA balance (returns 0n if account doesn't exist) +export async function getLightAtaBalance( + ata: PublicKey, + owner: PublicKey, + mint: PublicKey, +): Promise { + try { + const account = await getAtaInterface(rpc, ata, owner, mint); + return account.parsed.amount; + } catch { + return 0n; + } +} + +// Get SPL/T22 ATA balance +export async function getSplAtaBalance( + ata: PublicKey, + programId: PublicKey = TOKEN_PROGRAM_ID, +): Promise { + try { + const account = await getAccount(rpc, ata, undefined, programId); + return account.amount; + } catch { + return 0n; + } +} + +// Simple assert +export function assert(condition: boolean, msg: string): void { + if (!condition) { + throw new Error(`FAIL: ${msg}`); + } +} + +// Log scenario result +export function logScenario( + name: string, + expected: bigint, + actual: bigint, +): void { + const pass = expected === actual; + const status = pass ? "PASS" : "FAIL"; + console.log( + ` [${status}] ${name}: expected=${expected}, actual=${actual}`, + ); + if (!pass) { + throw new Error( + `${name}: expected=${expected}, actual=${actual}`, + ); + } +} + +// Create a fresh SPL mint with Light interface PDA +export async function createSplMint(): Promise { + const mintKeypair = Keypair.generate(); + const { mint } = await createMintInterface( + rpc, + payer, + payer, + null, + 9, + mintKeypair, + undefined, + TOKEN_PROGRAM_ID, + ); + return mint; +} + +// Create a fresh T22 mint with Light interface PDA +export async function createT22Mint(): Promise { + const mintKeypair = Keypair.generate(); + const { mint } = await createMintInterface( + rpc, + payer, + payer, + null, + 9, + mintKeypair, + undefined, + TOKEN_2022_PROGRAM_ID, + ); + return mint; +} + +// Create Light ATA and optionally pre-fill it with balance. +// When amount is provided: creates a temporary cold account, then loads it into the ATA. +// IMPORTANT: Call this BEFORE creating test cold accounts and SPL/T22 ATAs, +// otherwise loadAta in setup would consume them. +export async function createLightAtaWithBalance( + mint: PublicKey, + owner: Keypair, + amount?: bigint, + tokenProgramId: PublicKey = TOKEN_PROGRAM_ID, +): Promise { + await createAtaInterface(rpc, payer, mint, owner.publicKey); + const ata = getAssociatedTokenAddressInterface(mint, owner.publicKey); + if (amount && amount > 0n) { + await createMultipleCompressed(mint, owner.publicKey, 1, amount, tokenProgramId); + await loadAta(rpc, ata, owner, mint, payer); + await waitForCompressedCount(owner.publicKey, mint, 0); + } + return ata; +} + +// Re-export commonly used functions +export { + getAssociatedTokenAddressInterface, + createAtaInterface, + TOKEN_PROGRAM_ID, + TOKEN_2022_PROGRAM_ID, +}; diff --git a/typescript-client/tests/load-ata/spl-sources.ts b/typescript-client/tests/load-ata/spl-sources.ts new file mode 100644 index 0000000..824f116 --- /dev/null +++ b/typescript-client/tests/load-ata/spl-sources.ts @@ -0,0 +1,173 @@ +import "dotenv/config"; +import { Keypair } from "@solana/web3.js"; +import { loadAta } from "@lightprotocol/compressed-token/unified"; +import { + rpc, + payer, + createMultipleCompressed, + createSplMint, + createLightAtaWithBalance, + getSplAtaWithBalance, + getSplAtaBalance, + waitForCompressedCount, + getLightAtaBalance, + getAssociatedTokenAddressInterface, + assert, + logScenario, + TOKEN_PROGRAM_ID, +} from "./setup.js"; + +const AMOUNT_EACH = 100n; +const SPL_AMOUNT = 1000n; + +(async function () { + console.log("\n=== loadAta: SPL mint sources ===\n"); + + // ── Setup ────────────────────────────────────────────── + + console.log(" Setting up scenarios...\n"); + + // B1: 0 cold, 1000 SPL, no Light ATA + const b1Mint = await createSplMint(); + const b1Owner = Keypair.generate(); + const b1SplAta = await getSplAtaWithBalance(b1Mint, b1Owner.publicKey, SPL_AMOUNT); + + // B2: 1 cold, 1000 SPL, no Light ATA + const b2Mint = await createSplMint(); + const b2Owner = Keypair.generate(); + await createMultipleCompressed(b2Mint, b2Owner.publicKey, 1, AMOUNT_EACH); + const b2SplAta = await getSplAtaWithBalance(b2Mint, b2Owner.publicKey, SPL_AMOUNT); + + // B3: 4 cold, 1000 SPL, no Light ATA + const b3Mint = await createSplMint(); + const b3Owner = Keypair.generate(); + await createMultipleCompressed(b3Mint, b3Owner.publicKey, 4, AMOUNT_EACH); + const b3SplAta = await getSplAtaWithBalance(b3Mint, b3Owner.publicKey, SPL_AMOUNT); + + // B4: 8 cold, 1000 SPL, no Light ATA + const b4Mint = await createSplMint(); + const b4Owner = Keypair.generate(); + await createMultipleCompressed(b4Mint, b4Owner.publicKey, 8, AMOUNT_EACH); + const b4SplAta = await getSplAtaWithBalance(b4Mint, b4Owner.publicKey, SPL_AMOUNT); + + // B5: 4 cold, 1000 SPL, Light ATA has 500 + const b5Mint = await createSplMint(); + const b5Owner = Keypair.generate(); + await createLightAtaWithBalance(b5Mint, b5Owner, 500n); + await createMultipleCompressed(b5Mint, b5Owner.publicKey, 4, AMOUNT_EACH); + const b5SplAta = await getSplAtaWithBalance(b5Mint, b5Owner.publicKey, SPL_AMOUNT); + + // B6: 4 cold, 0 SPL, no Light ATA + const b6Mint = await createSplMint(); + const b6Owner = Keypair.generate(); + await createMultipleCompressed(b6Mint, b6Owner.publicKey, 4, AMOUNT_EACH); + await getSplAtaWithBalance(b6Mint, b6Owner.publicKey, 0n); + + // B7: 0 cold, 0 SPL, no Light ATA + const b7Mint = await createSplMint(); + const b7Owner = Keypair.generate(); + await getSplAtaWithBalance(b7Mint, b7Owner.publicKey, 0n); + + // ── Tests ────────────────────────────────────────────── + + console.log(" Running tests...\n"); + + // B1: 0 cold, 1000 SPL, no Light ATA -> creates ATA, wraps SPL + { + const ata = getAssociatedTokenAddressInterface(b1Mint, b1Owner.publicKey); + const tx = await loadAta(rpc, ata, b1Owner, b1Mint, payer); + assert(tx !== null, "B1: expected transaction signature"); + + await waitForCompressedCount(b1Owner.publicKey, b1Mint, 0); + + const splBalance = await getSplAtaBalance(b1SplAta, TOKEN_PROGRAM_ID); + assert(splBalance === 0n, `B1: expected SPL balance 0, got ${splBalance}`); + + const lightBalance = await getLightAtaBalance(ata, b1Owner.publicKey, b1Mint); + logScenario("B1: 0 cold + 1000 SPL, no ATA", SPL_AMOUNT, lightBalance); + } + + // B2: 1 cold, 1000 SPL, no Light ATA -> creates ATA, loads 1 + wraps + { + const ata = getAssociatedTokenAddressInterface(b2Mint, b2Owner.publicKey); + const tx = await loadAta(rpc, ata, b2Owner, b2Mint, payer); + assert(tx !== null, "B2: expected transaction signature"); + + await waitForCompressedCount(b2Owner.publicKey, b2Mint, 0); + + const splBalance = await getSplAtaBalance(b2SplAta, TOKEN_PROGRAM_ID); + assert(splBalance === 0n, `B2: expected SPL balance 0, got ${splBalance}`); + + const lightBalance = await getLightAtaBalance(ata, b2Owner.publicKey, b2Mint); + logScenario("B2: 1 cold + 1000 SPL, no ATA", 1n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); + } + + // B3: 4 cold, 1000 SPL, no Light ATA -> creates ATA, loads 4 + wraps + { + const ata = getAssociatedTokenAddressInterface(b3Mint, b3Owner.publicKey); + const tx = await loadAta(rpc, ata, b3Owner, b3Mint, payer); + assert(tx !== null, "B3: expected transaction signature"); + + await waitForCompressedCount(b3Owner.publicKey, b3Mint, 0); + + const splBalance = await getSplAtaBalance(b3SplAta, TOKEN_PROGRAM_ID); + assert(splBalance === 0n, `B3: expected SPL balance 0, got ${splBalance}`); + + const lightBalance = await getLightAtaBalance(ata, b3Owner.publicKey, b3Mint); + logScenario("B3: 4 cold + 1000 SPL, no ATA", 4n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); + } + + // B4: 8 cold, 1000 SPL, no Light ATA -> creates ATA, loads 8 + wraps + { + const ata = getAssociatedTokenAddressInterface(b4Mint, b4Owner.publicKey); + const tx = await loadAta(rpc, ata, b4Owner, b4Mint, payer); + assert(tx !== null, "B4: expected transaction signature"); + + await waitForCompressedCount(b4Owner.publicKey, b4Mint, 0); + + const splBalance = await getSplAtaBalance(b4SplAta, TOKEN_PROGRAM_ID); + assert(splBalance === 0n, `B4: expected SPL balance 0, got ${splBalance}`); + + const lightBalance = await getLightAtaBalance(ata, b4Owner.publicKey, b4Mint); + logScenario("B4: 8 cold + 1000 SPL, no ATA", 8n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); + } + + // B5: 4 cold, 1000 SPL, Light ATA has 500 -> loads 4 + wraps, total = 500 + 400 + 1000 + { + const ata = getAssociatedTokenAddressInterface(b5Mint, b5Owner.publicKey); + const tx = await loadAta(rpc, ata, b5Owner, b5Mint, payer); + assert(tx !== null, "B5: expected transaction signature"); + + await waitForCompressedCount(b5Owner.publicKey, b5Mint, 0); + + const splBalance = await getSplAtaBalance(b5SplAta, TOKEN_PROGRAM_ID); + assert(splBalance === 0n, `B5: expected SPL balance 0, got ${splBalance}`); + + const lightBalance = await getLightAtaBalance(ata, b5Owner.publicKey, b5Mint); + logScenario("B5: 4 cold + 1000 SPL, ATA has 500", 500n + 4n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); + } + + // B6: 4 cold, 0 SPL, no Light ATA -> creates ATA, loads 4 cold only + { + const ata = getAssociatedTokenAddressInterface(b6Mint, b6Owner.publicKey); + const tx = await loadAta(rpc, ata, b6Owner, b6Mint, payer); + assert(tx !== null, "B6: expected transaction signature"); + + await waitForCompressedCount(b6Owner.publicKey, b6Mint, 0); + + const lightBalance = await getLightAtaBalance(ata, b6Owner.publicKey, b6Mint); + logScenario("B6: 4 cold + 0 SPL, no ATA", 4n * AMOUNT_EACH, lightBalance); + } + + // B7: 0 cold, 0 SPL, no Light ATA -> returns null + { + const ata = getAssociatedTokenAddressInterface(b7Mint, b7Owner.publicKey); + const tx = await loadAta(rpc, ata, b7Owner, b7Mint, payer); + assert(tx === null, "B7: expected null (nothing to load)"); + + const lightBalance = await getLightAtaBalance(ata, b7Owner.publicKey, b7Mint); + logScenario("B7: 0 cold + 0 SPL, no ATA", 0n, lightBalance); + } + + console.log("\n=== All SPL source scenarios passed ===\n"); +})(); diff --git a/typescript-client/tests/load-ata/t22-sources.ts b/typescript-client/tests/load-ata/t22-sources.ts new file mode 100644 index 0000000..a8f0919 --- /dev/null +++ b/typescript-client/tests/load-ata/t22-sources.ts @@ -0,0 +1,135 @@ +import "dotenv/config"; +import { Keypair } from "@solana/web3.js"; +import { loadAta } from "@lightprotocol/compressed-token/unified"; +import { + rpc, + payer, + createMultipleCompressed, + createT22Mint, + createLightAtaWithBalance, + getT22AtaWithBalance, + getSplAtaBalance, + waitForCompressedCount, + getLightAtaBalance, + getAssociatedTokenAddressInterface, + assert, + logScenario, + TOKEN_2022_PROGRAM_ID, +} from "./setup.js"; + +const AMOUNT_EACH = 100n; +const T22_AMOUNT = 1000n; + +(async function () { + console.log("=== loadAta: Token-2022 mint sources ===\n"); + + // ── Setup ────────────────────────────────────────────── + + console.log(" Setting up scenarios...\n"); + + // C1: T22 ATA only, no cold, no existing Light ATA + const c1Mint = await createT22Mint(); + const c1Owner = Keypair.generate(); + const c1T22Ata = await getT22AtaWithBalance(c1Mint, c1Owner.publicKey, T22_AMOUNT); + + // C2: 1 cold + T22 ATA, no existing Light ATA + const c2Mint = await createT22Mint(); + const c2Owner = Keypair.generate(); + await createMultipleCompressed(c2Mint, c2Owner.publicKey, 1, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); + const c2T22Ata = await getT22AtaWithBalance(c2Mint, c2Owner.publicKey, T22_AMOUNT); + + // C3: 4 cold + T22 ATA, no existing Light ATA + const c3Mint = await createT22Mint(); + const c3Owner = Keypair.generate(); + await createMultipleCompressed(c3Mint, c3Owner.publicKey, 4, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); + const c3T22Ata = await getT22AtaWithBalance(c3Mint, c3Owner.publicKey, T22_AMOUNT); + + // C4: 8 cold + T22 ATA + existing Light ATA with 500 + const c4Mint = await createT22Mint(); + const c4Owner = Keypair.generate(); + await createLightAtaWithBalance(c4Mint, c4Owner, 500n, TOKEN_2022_PROGRAM_ID); + await createMultipleCompressed(c4Mint, c4Owner.publicKey, 8, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); + const c4T22Ata = await getT22AtaWithBalance(c4Mint, c4Owner.publicKey, T22_AMOUNT); + + // C5: 4 cold + empty T22 ATA (0 balance), no existing Light ATA + const c5Mint = await createT22Mint(); + const c5Owner = Keypair.generate(); + await createMultipleCompressed(c5Mint, c5Owner.publicKey, 4, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); + const c5T22Ata = await getT22AtaWithBalance(c5Mint, c5Owner.publicKey, 0n); + + // ── Tests ────────────────────────────────────────────── + + console.log(" Running tests...\n"); + + // C1: T22 ATA only -> creates ATA, wraps T22 + { + const ata = getAssociatedTokenAddressInterface(c1Mint, c1Owner.publicKey); + await loadAta(rpc, ata, c1Owner, c1Mint, payer); + + await waitForCompressedCount(c1Owner.publicKey, c1Mint, 0); + + const t22Balance = await getSplAtaBalance(c1T22Ata, TOKEN_2022_PROGRAM_ID); + assert(t22Balance === 0n, "C1: T22 ATA should be drained"); + + const lightBalance = await getLightAtaBalance(ata, c1Owner.publicKey, c1Mint); + logScenario("C1: T22 ATA only (no cold)", T22_AMOUNT, lightBalance); + } + + // C2: 1 cold + T22 ATA -> creates ATA, loads 1 + wraps + { + const ata = getAssociatedTokenAddressInterface(c2Mint, c2Owner.publicKey); + await loadAta(rpc, ata, c2Owner, c2Mint, payer); + + await waitForCompressedCount(c2Owner.publicKey, c2Mint, 0); + + const t22Balance = await getSplAtaBalance(c2T22Ata, TOKEN_2022_PROGRAM_ID); + assert(t22Balance === 0n, "C2: T22 ATA should be drained"); + + const lightBalance = await getLightAtaBalance(ata, c2Owner.publicKey, c2Mint); + logScenario("C2: 1 cold + T22 ATA", 1n * AMOUNT_EACH + T22_AMOUNT, lightBalance); + } + + // C3: 4 cold + T22 ATA -> creates ATA, loads 4 + wraps + { + const ata = getAssociatedTokenAddressInterface(c3Mint, c3Owner.publicKey); + await loadAta(rpc, ata, c3Owner, c3Mint, payer); + + await waitForCompressedCount(c3Owner.publicKey, c3Mint, 0); + + const t22Balance = await getSplAtaBalance(c3T22Ata, TOKEN_2022_PROGRAM_ID); + assert(t22Balance === 0n, "C3: T22 ATA should be drained"); + + const lightBalance = await getLightAtaBalance(ata, c3Owner.publicKey, c3Mint); + logScenario("C3: 4 cold + T22 ATA", 4n * AMOUNT_EACH + T22_AMOUNT, lightBalance); + } + + // C4: 8 cold + T22 ATA + existing 500 -> loads 8 + wraps + { + const ata = getAssociatedTokenAddressInterface(c4Mint, c4Owner.publicKey); + await loadAta(rpc, ata, c4Owner, c4Mint, payer); + + await waitForCompressedCount(c4Owner.publicKey, c4Mint, 0); + + const t22Balance = await getSplAtaBalance(c4T22Ata, TOKEN_2022_PROGRAM_ID); + assert(t22Balance === 0n, "C4: T22 ATA should be drained"); + + const lightBalance = await getLightAtaBalance(ata, c4Owner.publicKey, c4Mint); + logScenario("C4: 8 cold + T22 ATA + existing 500", 500n + 8n * AMOUNT_EACH + T22_AMOUNT, lightBalance); + } + + // C5: 4 cold + empty T22 ATA -> creates ATA, loads 4 cold only + { + const ata = getAssociatedTokenAddressInterface(c5Mint, c5Owner.publicKey); + await loadAta(rpc, ata, c5Owner, c5Mint, payer); + + await waitForCompressedCount(c5Owner.publicKey, c5Mint, 0); + + const t22Balance = await getSplAtaBalance(c5T22Ata, TOKEN_2022_PROGRAM_ID); + assert(t22Balance === 0n, "C5: T22 ATA should remain 0"); + + const lightBalance = await getLightAtaBalance(ata, c5Owner.publicKey, c5Mint); + logScenario("C5: 4 cold + empty T22 ATA", 4n * AMOUNT_EACH, lightBalance); + } + + console.log("\n=== All T22 source scenarios passed ==="); +})(); From c700bd89a24d6441f2e3197690e37cf686c8b403 Mon Sep 17 00:00:00 2001 From: tilo-14 Date: Sat, 14 Feb 2026 15:43:23 +0000 Subject: [PATCH 3/3] add coutner --- pinocchio/counter/Cargo.lock | 9001 +++++++++++++++++ privy/FIXES.md | 527 + programs/anchor/Cargo.lock | 24 +- typescript-client/package.json | 13 +- typescript-client/tests/load-ata/E2E-PLAN.md | 82 - typescript-client/tests/load-ata/README.md | 147 - typescript-client/tests/load-ata/cold-only.ts | 179 - .../tests/load-ata/idempotency.ts | 105 - .../tests/load-ata/load-and-transfer.ts | 182 - typescript-client/tests/load-ata/setup.ts | 250 - .../tests/load-ata/spl-sources.ts | 173 - .../tests/load-ata/t22-sources.ts | 135 - 12 files changed, 9550 insertions(+), 1268 deletions(-) create mode 100644 pinocchio/counter/Cargo.lock create mode 100644 privy/FIXES.md delete mode 100644 typescript-client/tests/load-ata/E2E-PLAN.md delete mode 100644 typescript-client/tests/load-ata/README.md delete mode 100644 typescript-client/tests/load-ata/cold-only.ts delete mode 100644 typescript-client/tests/load-ata/idempotency.ts delete mode 100644 typescript-client/tests/load-ata/load-and-transfer.ts delete mode 100644 typescript-client/tests/load-ata/setup.ts delete mode 100644 typescript-client/tests/load-ata/spl-sources.ts delete mode 100644 typescript-client/tests/load-ata/t22-sources.ts diff --git a/pinocchio/counter/Cargo.lock b/pinocchio/counter/Cargo.lock new file mode 100644 index 0000000..06edb20 --- /dev/null +++ b/pinocchio/counter/Cargo.lock @@ -0,0 +1,9001 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "Inflector" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3" +dependencies = [ + "lazy_static", + "regex", +] + +[[package]] +name = "adler2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" + +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "aes-gcm-siv" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae0784134ba9375416d469ec31e7c5f9fa94405049cf08c5ce5b4698be673e0d" +dependencies = [ + "aead", + "aes", + "cipher", + "ctr", + "polyval", + "subtle", + "zeroize", +] + +[[package]] +name = "agave-feature-set" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d52a2c365c0245cbb8959de725fc2b44c754b673fdf34c9a7f9d4a25c35a7bf1" +dependencies = [ + "ahash", + "solana-epoch-schedule", + "solana-hash", + "solana-pubkey", + "solana-sha256-hasher", + "solana-svm-feature-set", +] + +[[package]] +name = "agave-precompiles" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d60d73657792af7f2464e9181d13c3979e94bb09841d9ffa014eef4ef0492b77" +dependencies = [ + "agave-feature-set", + "bincode", + "digest 0.10.7", + "ed25519-dalek", + "libsecp256k1", + "openssl", + "sha3", + "solana-ed25519-program", + "solana-message", + "solana-precompile-error", + "solana-pubkey", + "solana-sdk-ids", + "solana-secp256k1-program", + "solana-secp256r1-program", +] + +[[package]] +name = "agave-reserved-account-keys" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8289c8a8a2ef5aa10ce49a070f360f4e035ee3410b8d8f3580fb39d8cf042581" +dependencies = [ + "agave-feature-set", + "solana-pubkey", + "solana-sdk-ids", +] + +[[package]] +name = "ahash" +version = "0.8.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75" +dependencies = [ + "cfg-if", + "getrandom 0.3.4", + "once_cell", + "version_check", + "zerocopy", +] + +[[package]] +name = "aho-corasick" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" +dependencies = [ + "memchr", +] + +[[package]] +name = "aligned-sized" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48a526ec4434d531d488af59fe866f36b310fe8906691c75dffa664450a3800a" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "alloc-no-stdlib" +version = "2.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3" + +[[package]] +name = "alloc-stdlib" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece" +dependencies = [ + "alloc-no-stdlib", +] + +[[package]] +name = "allocator-api2" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" + +[[package]] +name = "anchor-attribute-access-control" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f70fd141a4d18adf11253026b32504f885447048c7494faf5fa83b01af9c0cf" +dependencies = [ + "anchor-syn", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-attribute-account" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "715a261c57c7679581e06f07a74fa2af874ac30f86bd8ea07cca4a7e5388a064" +dependencies = [ + "anchor-syn", + "bs58", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-attribute-constant" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "730d6df8ae120321c5c25e0779e61789e4b70dc8297102248902022f286102e4" +dependencies = [ + "anchor-syn", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-attribute-error" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27e6e449cc3a37b2880b74dcafb8e5a17b954c0e58e376432d7adc646fb333ef" +dependencies = [ + "anchor-syn", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-attribute-event" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7710e4c54adf485affcd9be9adec5ef8846d9c71d7f31e16ba86ff9fc1dd49f" +dependencies = [ + "anchor-syn", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-attribute-program" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05ecfd49b2aeadeb32f35262230db402abed76ce87e27562b34f61318b2ec83c" +dependencies = [ + "anchor-lang-idl", + "anchor-syn", + "anyhow", + "bs58", + "heck 0.3.3", + "proc-macro2", + "quote", + "serde_json", + "syn 1.0.109", +] + +[[package]] +name = "anchor-derive-accounts" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be89d160793a88495af462a7010b3978e48e30a630c91de47ce2c1d3cb7a6149" +dependencies = [ + "anchor-syn", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-derive-serde" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abc6ee78acb7bfe0c2dd2abc677aaa4789c0281a0c0ef01dbf6fe85e0fd9e6e4" +dependencies = [ + "anchor-syn", + "borsh-derive-internal", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-derive-space" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "134a01c0703f6fd355a0e472c033f6f3e41fac1ef6e370b20c50f4c8d022cea7" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "anchor-lang" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6bab117055905e930f762c196e08f861f8dfe7241b92cee46677a3b15561a0a" +dependencies = [ + "anchor-attribute-access-control", + "anchor-attribute-account", + "anchor-attribute-constant", + "anchor-attribute-error", + "anchor-attribute-event", + "anchor-attribute-program", + "anchor-derive-accounts", + "anchor-derive-serde", + "anchor-derive-space", + "base64 0.21.7", + "bincode", + "borsh 0.10.4", + "bytemuck", + "solana-program", + "thiserror 1.0.69", +] + +[[package]] +name = "anchor-lang-idl" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32e8599d21995f68e296265aa5ab0c3cef582fd58afec014d01bd0bce18a4418" +dependencies = [ + "anchor-lang-idl-spec", + "anyhow", + "heck 0.3.3", + "serde", + "serde_json", + "sha2 0.10.9", +] + +[[package]] +name = "anchor-lang-idl-spec" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bdf143115440fe621bdac3a29a1f7472e09f6cd82b2aa569429a0c13f103838" +dependencies = [ + "anyhow", + "serde", +] + +[[package]] +name = "anchor-syn" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dc7a6d90cc643df0ed2744862cdf180587d1e5d28936538c18fc8908489ed67" +dependencies = [ + "anyhow", + "bs58", + "heck 0.3.3", + "proc-macro2", + "quote", + "serde", + "serde_json", + "sha2 0.10.9", + "syn 1.0.109", + "thiserror 1.0.69", +] + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "ansi_term" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2" +dependencies = [ + "winapi", +] + +[[package]] +name = "anyhow" +version = "1.0.101" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea" + +[[package]] +name = "ark-bn254" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a22f4561524cd949590d78d7d4c5df8f592430d221f7f3c9497bbafd8972120f" +dependencies = [ + "ark-ec 0.4.2", + "ark-ff 0.4.2", + "ark-std 0.4.0", +] + +[[package]] +name = "ark-bn254" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d69eab57e8d2663efa5c63135b2af4f396d66424f88954c21104125ab6b3e6bc" +dependencies = [ + "ark-ec 0.5.0", + "ark-ff 0.5.0", + "ark-std 0.5.0", +] + +[[package]] +name = "ark-ec" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "defd9a439d56ac24968cca0571f598a61bc8c55f71d50a89cda591cb750670ba" +dependencies = [ + "ark-ff 0.4.2", + "ark-poly 0.4.2", + "ark-serialize 0.4.2", + "ark-std 0.4.0", + "derivative", + "hashbrown 0.13.2", + "itertools 0.10.5", + "num-traits", + "zeroize", +] + +[[package]] +name = "ark-ec" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43d68f2d516162846c1238e755a7c4d131b892b70cc70c471a8e3ca3ed818fce" +dependencies = [ + "ahash", + "ark-ff 0.5.0", + "ark-poly 0.5.0", + "ark-serialize 0.5.0", + "ark-std 0.5.0", + "educe 0.6.0", + "fnv", + "hashbrown 0.15.2", + "itertools 0.13.0", + "num-bigint 0.4.6", + "num-integer", + "num-traits", + "zeroize", +] + +[[package]] +name = "ark-ff" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba" +dependencies = [ + "ark-ff-asm 0.4.2", + "ark-ff-macros 0.4.2", + "ark-serialize 0.4.2", + "ark-std 0.4.0", + "derivative", + "digest 0.10.7", + "itertools 0.10.5", + "num-bigint 0.4.6", + "num-traits", + "paste", + "rustc_version", + "zeroize", +] + +[[package]] +name = "ark-ff" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a177aba0ed1e0fbb62aa9f6d0502e9b46dad8c2eab04c14258a1212d2557ea70" +dependencies = [ + "ark-ff-asm 0.5.0", + "ark-ff-macros 0.5.0", + "ark-serialize 0.5.0", + "ark-std 0.5.0", + "arrayvec", + "digest 0.10.7", + "educe 0.6.0", + "itertools 0.13.0", + "num-bigint 0.4.6", + "num-traits", + "paste", + "zeroize", +] + +[[package]] +name = "ark-ff-asm" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348" +dependencies = [ + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-asm" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60" +dependencies = [ + "quote", + "syn 2.0.115", +] + +[[package]] +name = "ark-ff-macros" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-ff-macros" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09be120733ee33f7693ceaa202ca41accd5653b779563608f1234f78ae07c4b3" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "ark-poly" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d320bfc44ee185d899ccbadfa8bc31aab923ce1558716e1997a1e74057fe86bf" +dependencies = [ + "ark-ff 0.4.2", + "ark-serialize 0.4.2", + "ark-std 0.4.0", + "derivative", + "hashbrown 0.13.2", +] + +[[package]] +name = "ark-poly" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "579305839da207f02b89cd1679e50e67b4331e2f9294a57693e5051b7703fe27" +dependencies = [ + "ahash", + "ark-ff 0.5.0", + "ark-serialize 0.5.0", + "ark-std 0.5.0", + "educe 0.6.0", + "fnv", + "hashbrown 0.15.2", +] + +[[package]] +name = "ark-serialize" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5" +dependencies = [ + "ark-serialize-derive 0.4.2", + "ark-std 0.4.0", + "digest 0.10.7", + "num-bigint 0.4.6", +] + +[[package]] +name = "ark-serialize" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f4d068aaf107ebcd7dfb52bc748f8030e0fc930ac8e360146ca54c1203088f7" +dependencies = [ + "ark-serialize-derive 0.5.0", + "ark-std 0.5.0", + "arrayvec", + "digest 0.10.7", + "num-bigint 0.4.6", +] + +[[package]] +name = "ark-serialize-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae3281bc6d0fd7e549af32b52511e1302185bd688fd3359fa36423346ff682ea" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "ark-serialize-derive" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "213888f660fddcca0d257e88e54ac05bca01885f258ccdf695bafd77031bb69d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "ark-std" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" +dependencies = [ + "num-traits", + "rand 0.8.5", +] + +[[package]] +name = "ark-std" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "246a225cc6131e9ee4f24619af0f19d67761fff15d7ccc22e42b80846e69449a" +dependencies = [ + "num-traits", + "rand 0.8.5", + "rayon", +] + +[[package]] +name = "arrayref" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "ascii" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eab1c04a571841102f5345a8fc0f6bb3d31c315dec879b5c6e42e40ce7ffa34e" + +[[package]] +name = "async-compression" +version = "0.4.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68650b7df54f0293fd061972a0fb05aaf4fc0879d3b3d21a638a182c5c543b9f" +dependencies = [ + "compression-codecs", + "compression-core", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "async-trait" +version = "0.1.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "atty" +version = "0.2.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" +dependencies = [ + "hermit-abi", + "libc", + "winapi", +] + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "base64" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff" + +[[package]] +name = "base64" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" + +[[package]] +name = "base64" +version = "0.21.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bincode" +version = "1.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +dependencies = [ + "serde", +] + +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + +[[package]] +name = "bitflags" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3" +dependencies = [ + "serde_core", +] + +[[package]] +name = "bitvec" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c" +dependencies = [ + "funty", + "radium", + "tap", + "wyz", +] + +[[package]] +name = "blake3" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3888aaa89e4b2a40fca9848e400f6a658a5a3978de7be858e209cafa8be9a4a0" +dependencies = [ + "arrayref", + "arrayvec", + "cc", + "cfg-if", + "constant_time_eq", + "digest 0.10.7", +] + +[[package]] +name = "block-buffer" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "borsh" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "115e54d64eb62cdebad391c19efc9dce4981c690c85a33a12199d99bb9546fee" +dependencies = [ + "borsh-derive 0.10.4", + "hashbrown 0.13.2", +] + +[[package]] +name = "borsh" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f" +dependencies = [ + "borsh-derive 1.6.0", + "cfg_aliases", +] + +[[package]] +name = "borsh-derive" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "831213f80d9423998dd696e2c5345aba6be7a0bd8cd19e31c5243e13df1cef89" +dependencies = [ + "borsh-derive-internal", + "borsh-schema-derive-internal", + "proc-macro-crate 0.1.5", + "proc-macro2", + "syn 1.0.109", +] + +[[package]] +name = "borsh-derive" +version = "1.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c" +dependencies = [ + "once_cell", + "proc-macro-crate 3.4.0", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "borsh-derive-internal" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65d6ba50644c98714aa2a70d13d7df3cd75cd2b523a2b452bf010443800976b3" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "borsh-schema-derive-internal" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "276691d96f063427be83e6692b86148e488ebba9f48f77788724ca027ba3b6d4" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "brotli" +version = "8.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", + "brotli-decompressor", +] + +[[package]] +name = "brotli-decompressor" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03" +dependencies = [ + "alloc-no-stdlib", + "alloc-stdlib", +] + +[[package]] +name = "bs58" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "bumpalo" +version = "3.19.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" + +[[package]] +name = "bv" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8834bb1d8ee5dc048ee3124f2c7c1afcc6bc9aed03f11e9dfd8c69470a5db340" +dependencies = [ + "feature-probe", + "serde", +] + +[[package]] +name = "bytecount" +version = "0.6.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e" + +[[package]] +name = "bytemuck" +version = "1.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec" +dependencies = [ + "bytemuck_derive", +] + +[[package]] +name = "bytemuck_derive" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "byteorder" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" + +[[package]] +name = "bytes" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" + +[[package]] +name = "cc" +version = "1.2.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b26a0954ae34af09b50f0de26458fa95369a0d478d8236d3f93082b219bd29" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + +[[package]] +name = "cfg_eval" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45565fc9416b9896014f5732ac776f810ee53a66730c17e4020c3ec064a8f88f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "chrono" +version = "0.4.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + +[[package]] +name = "combine" +version = "3.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da3da6baa321ec19e1cc41d31bf599f00c783d0517095cdaf0332e3fe8d20680" +dependencies = [ + "ascii", + "byteorder", + "either", + "memchr", + "unreachable", +] + +[[package]] +name = "compression-codecs" +version = "0.4.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00828ba6fd27b45a448e57dbfe84f1029d4c9f26b368157e9a448a5f49a2ec2a" +dependencies = [ + "brotli", + "compression-core", + "flate2", + "memchr", +] + +[[package]] +name = "compression-core" +version = "0.4.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d" + +[[package]] +name = "console" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" +dependencies = [ + "encode_unicode", + "libc", + "once_cell", + "unicode-width", + "windows-sys 0.59.0", +] + +[[package]] +name = "console_error_panic_hook" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc" +dependencies = [ + "cfg-if", + "wasm-bindgen", +] + +[[package]] +name = "console_log" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e89f72f65e8501878b8a004d5a1afb780987e2ce2b4532c562e367a72c57499f" +dependencies = [ + "log", + "web-sys", +] + +[[package]] +name = "constant_time_eq" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6" + +[[package]] +name = "core-foundation" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crc32fast" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossbeam-channel" +version = "0.5.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-deque" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.9.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e" +dependencies = [ + "crossbeam-utils", +] + +[[package]] +name = "crossbeam-utils" +version = "0.8.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28" + +[[package]] +name = "crunchy" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "typenum", +] + +[[package]] +name = "crypto-mac" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab" +dependencies = [ + "generic-array", + "subtle", +] + +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "curve25519-dalek" +version = "3.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61" +dependencies = [ + "byteorder", + "digest 0.9.0", + "rand_core 0.5.1", + "subtle", + "zeroize", +] + +[[package]] +name = "curve25519-dalek" +version = "4.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" +dependencies = [ + "cfg-if", + "cpufeatures", + "curve25519-dalek-derive", + "digest 0.10.7", + "fiat-crypto", + "rand_core 0.6.4", + "rustc_version", + "serde", + "subtle", + "zeroize", +] + +[[package]] +name = "curve25519-dalek-derive" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "darling" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn 2.0.115", +] + +[[package]] +name = "darling_macro" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81" +dependencies = [ + "darling_core", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "deranged" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc3dc5ad92c2e2d1c193bbbbdf2ea477cb81331de4f3103f267ca18368b988c4" +dependencies = [ + "powerfmt", + "serde_core", +] + +[[package]] +name = "derivation-path" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e5c37193a1db1d8ed868c03ec7b152175f26160a5b740e5e484143877e0adf0" + +[[package]] +name = "derivative" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "digest" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066" +dependencies = [ + "generic-array", +] + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer 0.10.4", + "crypto-common", + "subtle", +] + +[[package]] +name = "displaydoc" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "dyn-clone" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" + +[[package]] +name = "eager" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abe71d579d1812060163dff96056261deb5bf6729b100fa2e36a68b9649ba3d3" + +[[package]] +name = "ed25519" +version = "1.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91cff35c70bba8a626e3185d8cd48cc11b5437e1a5bcd15b9b5fa3c64b6dfee7" +dependencies = [ + "signature", +] + +[[package]] +name = "ed25519-dalek" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d" +dependencies = [ + "curve25519-dalek 3.2.0", + "ed25519", + "rand 0.7.3", + "serde", + "sha2 0.9.9", + "zeroize", +] + +[[package]] +name = "ed25519-dalek-bip32" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d2be62a4061b872c8c0873ee4fc6f101ce7b889d039f019c5fa2af471a59908" +dependencies = [ + "derivation-path", + "ed25519-dalek", + "hmac 0.12.1", + "sha2 0.10.9", +] + +[[package]] +name = "educe" +version = "0.4.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f0042ff8246a363dbe77d2ceedb073339e85a804b9a47636c6e016a9a32c05f" +dependencies = [ + "enum-ordinalize 3.1.15", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "educe" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d7bc049e1bd8cdeb31b68bbd586a9464ecf9f3944af3958a7a9d0f8b9799417" +dependencies = [ + "enum-ordinalize 4.3.2", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + +[[package]] +name = "encoding_rs" +version = "0.8.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "enum-iterator" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fd242f399be1da0a5354aa462d57b4ab2b4ee0683cc552f7c007d2d12d36e94" +dependencies = [ + "enum-iterator-derive", +] + +[[package]] +name = "enum-iterator-derive" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "685adfa4d6f3d765a26bc5dbc936577de9abf756c1feeb3089b01dd395034842" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "enum-ordinalize" +version = "3.1.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1bf1fa3f06bbff1ea5b1a9c7b14aa992a39657db60a2759457328d7e058f49ee" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "enum-ordinalize" +version = "4.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a1091a7bb1f8f2c4b28f1fe2cef4980ca2d410a3d727d67ecc3178c9b0800f0" +dependencies = [ + "enum-ordinalize-derive", +] + +[[package]] +name = "enum-ordinalize-derive" +version = "4.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ca9601fb2d62598ee17836250842873a413586e5d7ed88b356e38ddbb0ec631" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "env_logger" +version = "0.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7" +dependencies = [ + "atty", + "humantime", + "log", + "regex", + "termcolor", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + +[[package]] +name = "feature-probe" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "835a3dc7d1ec9e75e2b5fb4ba75396837112d2060b03f7d43bc1897c7f7211da" + +[[package]] +name = "fiat-crypto" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d" + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "five8" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75b8549488b4715defcb0d8a8a1c1c76a80661b5fa106b4ca0e7fce59d7d875" +dependencies = [ + "five8_core", +] + +[[package]] +name = "five8_const" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26dec3da8bc3ef08f2c04f61eab298c3ab334523e55f076354d6d6f613799a7b" +dependencies = [ + "five8_core", +] + +[[package]] +name = "five8_core" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2551bf44bc5f776c15044b9b94153a00198be06743e262afaaa61f11ac7523a5" + +[[package]] +name = "flate2" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +dependencies = [ + "crc32fast", + "miniz_oxide", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "foreign-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1" +dependencies = [ + "foreign-types-shared", +] + +[[package]] +name = "foreign-types-shared" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "funty" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" + +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "gethostname" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c1ebd34e35c46e00bb73e81363248d627782724609fe1b6396f553f68fe3862e" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "getrandom" +version = "0.1.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi 0.9.0+wasi-snapshot-preview1", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi", + "wasip2", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec" +dependencies = [ + "cfg-if", + "libc", + "r-efi", + "wasip2", + "wasip3", +] + +[[package]] +name = "groth16-solana" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a6d1ffb18dbf5cfc60b11bd7da88474c672870247c1e5b498619bcb6ba3d8f5" +dependencies = [ + "ark-bn254 0.5.0", + "ark-ec 0.5.0", + "ark-ff 0.5.0", + "ark-serialize 0.5.0", + "num-bigint 0.4.6", + "solana-bn254", + "thiserror 1.0.69", +] + +[[package]] +name = "h2" +version = "0.3.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d" +dependencies = [ + "bytes", + "fnv", + "futures-core", + "futures-sink", + "futures-util", + "http 0.2.12", + "indexmap 2.13.0", + "slab", + "tokio", + "tokio-util 0.7.18", + "tracing", +] + +[[package]] +name = "h2" +version = "0.4.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54" +dependencies = [ + "atomic-waker", + "bytes", + "fnv", + "futures-core", + "futures-sink", + "http 1.4.0", + "indexmap 2.13.0", + "slab", + "tokio", + "tokio-util 0.7.18", + "tracing", +] + +[[package]] +name = "hash32" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606" +dependencies = [ + "byteorder", +] + +[[package]] +name = "hashbrown" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" + +[[package]] +name = "hashbrown" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" +dependencies = [ + "ahash", +] + +[[package]] +name = "hashbrown" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" + +[[package]] +name = "heck" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c" +dependencies = [ + "unicode-segmentation", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hermit-abi" +version = "0.1.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" +dependencies = [ + "libc", +] + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hmac" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "126888268dcc288495a26bf004b38c5fdbb31682f992c84ceb046a1f0fe38840" +dependencies = [ + "crypto-mac", + "digest 0.9.0", +] + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest 0.10.7", +] + +[[package]] +name = "hmac-drbg" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "17ea0a1394df5b6574da6e0c1ade9e78868c9fb0a4e5ef4428e32da4676b85b1" +dependencies = [ + "digest 0.9.0", + "generic-array", + "hmac 0.8.1", +] + +[[package]] +name = "http" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + +[[package]] +name = "http" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" +dependencies = [ + "bytes", + "http 0.2.12", + "pin-project-lite", +] + +[[package]] +name = "http-body" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184" +dependencies = [ + "bytes", + "http 1.4.0", +] + +[[package]] +name = "http-body-util" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a" +dependencies = [ + "bytes", + "futures-core", + "http 1.4.0", + "http-body 1.0.1", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "httpdate" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" + +[[package]] +name = "humantime" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424" + +[[package]] +name = "hyper" +version = "0.14.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41dfc780fdec9373c01bae43289ea34c972e40ee3c9f6b3c8801a35f35586ce7" +dependencies = [ + "bytes", + "futures-channel", + "futures-core", + "futures-util", + "h2 0.3.27", + "http 0.2.12", + "http-body 0.4.6", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "socket2 0.5.10", + "tokio", + "tower-service", + "tracing", + "want", +] + +[[package]] +name = "hyper" +version = "1.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "h2 0.4.13", + "http 1.4.0", + "http-body 1.0.1", + "httparse", + "itoa", + "pin-project-lite", + "pin-utils", + "smallvec", + "tokio", + "want", +] + +[[package]] +name = "hyper-rustls" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" +dependencies = [ + "futures-util", + "http 0.2.12", + "hyper 0.14.32", + "rustls 0.21.12", + "tokio", + "tokio-rustls 0.24.1", +] + +[[package]] +name = "hyper-rustls" +version = "0.27.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58" +dependencies = [ + "http 1.4.0", + "hyper 1.8.1", + "hyper-util", + "rustls 0.23.36", + "rustls-pki-types", + "tokio", + "tokio-rustls 0.26.4", + "tower-service", + "webpki-roots 1.0.6", +] + +[[package]] +name = "hyper-tls" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905" +dependencies = [ + "bytes", + "hyper 0.14.32", + "native-tls", + "tokio", + "tokio-native-tls", +] + +[[package]] +name = "hyper-tls" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0" +dependencies = [ + "bytes", + "http-body-util", + "hyper 1.8.1", + "hyper-util", + "native-tls", + "tokio", + "tokio-native-tls", + "tower-service", +] + +[[package]] +name = "hyper-util" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures-channel", + "futures-util", + "http 1.4.0", + "http-body 1.0.1", + "hyper 1.8.1", + "ipnet", + "libc", + "percent-encoding", + "pin-project-lite", + "socket2 0.6.2", + "system-configuration 0.7.0", + "tokio", + "tower-service", + "tracing", + "windows-registry", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "icu_collections" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43" +dependencies = [ + "displaydoc", + "potential_utf", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a" + +[[package]] +name = "icu_properties" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec" +dependencies = [ + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af" + +[[package]] +name = "icu_provider" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" +dependencies = [ + "autocfg", + "hashbrown 0.12.3", + "serde", +] + +[[package]] +name = "indexmap" +version = "2.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +dependencies = [ + "equivalent", + "hashbrown 0.16.1", + "serde", + "serde_core", +] + +[[package]] +name = "indicatif" +version = "0.17.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235" +dependencies = [ + "console", + "number_prefix", + "portable-atomic", + "unicode-width", + "web-time", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + +[[package]] +name = "ipnet" +version = "2.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130" + +[[package]] +name = "iri-string" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c91338f0783edbd6195decb37bae672fd3b165faffb89bf7b9e6942f8b1a731a" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "itertools" +version = "0.10.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itertools" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" + +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "jsonrpc-core" +version = "18.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb" +dependencies = [ + "futures", + "futures-executor", + "futures-util", + "log", + "serde", + "serde_derive", + "serde_json", +] + +[[package]] +name = "kaigan" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ba15de5aeb137f0f65aa3bf82187647f1285abfe5b20c80c2c37f7007ad519a" +dependencies = [ + "borsh 0.10.4", + "serde", +] + +[[package]] +name = "keccak" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654" +dependencies = [ + "cpufeatures", +] + +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "libc" +version = "0.2.181" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "459427e2af2b9c839b132acb702a1c654d95e10f8c326bfc2ad11310e458b1c5" + +[[package]] +name = "libsecp256k1" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9d220bc1feda2ac231cb78c3d26f27676b8cf82c96971f7aeef3d0cf2797c73" +dependencies = [ + "arrayref", + "base64 0.12.3", + "digest 0.9.0", + "hmac-drbg", + "libsecp256k1-core", + "libsecp256k1-gen-ecmult", + "libsecp256k1-gen-genmult", + "rand 0.7.3", + "serde", + "sha2 0.9.9", + "typenum", +] + +[[package]] +name = "libsecp256k1-core" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0f6ab710cec28cef759c5f18671a27dae2a5f952cdaaee1d8e2908cb2478a80" +dependencies = [ + "crunchy", + "digest 0.9.0", + "subtle", +] + +[[package]] +name = "libsecp256k1-gen-ecmult" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccab96b584d38fac86a83f07e659f0deafd0253dc096dab5a36d53efe653c5c3" +dependencies = [ + "libsecp256k1-core", +] + +[[package]] +name = "libsecp256k1-gen-genmult" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67abfe149395e3aa1c48a2beb32b068e2334402df8181f818d3aee2b304c4f5d" +dependencies = [ + "libsecp256k1-core", +] + +[[package]] +name = "light-account" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f7464c25ca421182041ad563d81bf059aa5cd54d8c81caadc46e3999dcd34db" +dependencies = [ + "light-account-checks", + "light-compressed-account", + "light-compressible", + "light-hasher", + "light-macros", + "light-sdk-macros", + "light-sdk-types", + "solana-account-info", + "solana-instruction", + "solana-pubkey", +] + +[[package]] +name = "light-account-checks" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34d74dd13535c6014abb4cac694e14083b206a7f6cf1bbbc9611aa5c2e11cdd1" +dependencies = [ + "pinocchio", + "pinocchio-system", + "solana-account-info", + "solana-cpi", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "solana-system-interface", + "solana-sysvar", + "thiserror 2.0.18", +] + +[[package]] +name = "light-account-pinocchio" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbfe2fdd5073284e68b8ba3c1ffe42e40f8d7c2305792244b6bb75c3870691b8" +dependencies = [ + "light-account-checks", + "light-compressed-account", + "light-compressible", + "light-hasher", + "light-macros", + "light-sdk-macros", + "light-sdk-types", + "pinocchio", + "solana-instruction", + "solana-pubkey", +] + +[[package]] +name = "light-array-map" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bdd13b18028ac9d80d0a987551c0dad7fe81be8140e87cc9d568b80f3728203" +dependencies = [ + "tinyvec", +] + +[[package]] +name = "light-batched-merkle-tree" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb07ef41d9d99db94072d556767a93d774323bc34940db349555abc4504de015" +dependencies = [ + "aligned-sized", + "borsh 0.10.4", + "light-account-checks", + "light-bloom-filter", + "light-compressed-account", + "light-hasher", + "light-macros", + "light-merkle-tree-metadata", + "light-verifier", + "light-zero-copy", + "solana-account-info", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "solana-sysvar", + "thiserror 2.0.18", + "zerocopy", +] + +[[package]] +name = "light-bloom-filter" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "380b8cf734ccf5fbc1f5fed8e5308b57ebde6774d9304c167bcb0de2854412d8" +dependencies = [ + "bitvec", + "num-bigint 0.4.6", + "solana-nostd-keccak", + "solana-program-error", + "thiserror 2.0.18", +] + +[[package]] +name = "light-bounded-vec" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58cfa375d028164719e3ffef93d2e5c27855cc8a5bb5bf257b868d17c12a3e66" +dependencies = [ + "bytemuck", + "memoffset", + "solana-program-error", + "thiserror 1.0.69", +] + +[[package]] +name = "light-client" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "002ae865925850ff8d83448965b79c50c767886415df943170a29715103ded45" +dependencies = [ + "anchor-lang", + "async-trait", + "base64 0.13.1", + "borsh 0.10.4", + "bs58", + "futures", + "lazy_static", + "light-account", + "light-compressed-account", + "light-compressed-token-sdk", + "light-compressible", + "light-concurrent-merkle-tree", + "light-event", + "light-hasher", + "light-indexed-merkle-tree", + "light-merkle-tree-metadata", + "light-prover-client", + "light-sdk", + "light-sdk-types", + "light-token", + "light-token-interface", + "litesvm", + "num-bigint 0.4.6", + "photon-api", + "rand 0.8.5", + "reqwest 0.12.28", + "serde_json", + "smallvec", + "solana-account", + "solana-account-decoder-client-types", + "solana-address-lookup-table-interface", + "solana-banks-client", + "solana-clock", + "solana-commitment-config", + "solana-compute-budget-interface", + "solana-hash", + "solana-instruction", + "solana-keypair", + "solana-message", + "solana-program-error", + "solana-pubkey", + "solana-rpc-client", + "solana-rpc-client-api", + "solana-signature", + "solana-transaction", + "solana-transaction-error", + "solana-transaction-status-client-types", + "spl-pod", + "spl-token-2022-interface", + "thiserror 2.0.18", + "tokio", + "tracing", +] + +[[package]] +name = "light-compressed-account" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "adab5a8dddd9675306b0a808900578ed60b40b5c5457e330e28c9cb51361118d" +dependencies = [ + "anchor-lang", + "borsh 0.10.4", + "bytemuck", + "light-hasher", + "light-macros", + "light-poseidon 0.3.0", + "light-program-profiler", + "light-zero-copy", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "thiserror 2.0.18", + "tinyvec", + "zerocopy", +] + +[[package]] +name = "light-compressed-token-sdk" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76e56f85162c02208b24d7d9c817a24de1f6116e49f5751b7d8761c72f0021ff" +dependencies = [ + "anchor-lang", + "arrayvec", + "borsh 0.10.4", + "light-account", + "light-account-checks", + "light-compressed-account", + "light-program-profiler", + "light-sdk", + "light-sdk-types", + "light-token-interface", + "light-token-types", + "light-zero-copy", + "solana-account-info", + "solana-cpi", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "thiserror 2.0.18", +] + +[[package]] +name = "light-compressible" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0905b52848daea4cb7edbc9ddca0a8d5c4f1d864e89eff0aca3b6fc2a9edbb2" +dependencies = [ + "aligned-sized", + "anchor-lang", + "borsh 0.10.4", + "bytemuck", + "light-account-checks", + "light-compressed-account", + "light-hasher", + "light-macros", + "light-program-profiler", + "light-zero-copy", + "pinocchio-pubkey", + "solana-pubkey", + "solana-rent", + "thiserror 2.0.18", + "zerocopy", +] + +[[package]] +name = "light-concurrent-merkle-tree" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db96f47253a0907aaa46dac15cecb27b5510130e48da0b36690dcd2e99a6d558" +dependencies = [ + "borsh 0.10.4", + "light-bounded-vec", + "light-hasher", + "memoffset", + "solana-program-error", + "thiserror 2.0.18", +] + +[[package]] +name = "light-event" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d71e91a43f85421eee408bc9656de3158b27389310ba06a4a1c5bf2f87468e" +dependencies = [ + "borsh 0.10.4", + "light-compressed-account", + "light-hasher", + "light-zero-copy", + "thiserror 2.0.18", +] + +[[package]] +name = "light-hasher" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c822662e6e109bac0e132a43fd52a4ef684811245a794e048cf9cda001e934c8" +dependencies = [ + "ark-bn254 0.5.0", + "ark-ff 0.5.0", + "borsh 0.10.4", + "light-poseidon 0.3.0", + "num-bigint 0.4.6", + "sha2 0.10.9", + "sha3", + "solana-program-error", + "thiserror 2.0.18", + "tinyvec", +] + +[[package]] +name = "light-indexed-array" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f14f984030d86b6f07bd8f5ae04e2c40fcd0c3bdfcc7a291fff1ed59c9e6554" +dependencies = [ + "light-hasher", + "num-bigint 0.4.6", + "num-traits", + "thiserror 2.0.18", +] + +[[package]] +name = "light-indexed-merkle-tree" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0824755289075f28de2820fc7d4ec4e6b9e99d404e033c07338b91cce8c71fb8" +dependencies = [ + "light-bounded-vec", + "light-concurrent-merkle-tree", + "light-hasher", + "light-merkle-tree-reference", + "num-bigint 0.4.6", + "num-traits", + "solana-program-error", + "thiserror 2.0.18", +] + +[[package]] +name = "light-instruction-decoder" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab1c2c1594a3373d0ce2a0af11568c4f1455cb00aa42a606becb49254b0b6c2c" +dependencies = [ + "borsh 0.10.4", + "bs58", + "light-compressed-account", + "light-instruction-decoder-derive", + "light-sdk-types", + "light-token-interface", + "serde", + "solana-instruction", + "solana-pubkey", + "solana-signature", + "tabled", +] + +[[package]] +name = "light-instruction-decoder-derive" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2035d04a0a1590da05634efcac149a2ac852565e28c9a55bd07a6620c0e90bff" +dependencies = [ + "bs58", + "darling", + "heck 0.5.0", + "proc-macro2", + "quote", + "sha2 0.10.9", + "syn 2.0.115", +] + +[[package]] +name = "light-macros" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "179ac51cadc1d0ca047b4d6265a7cc245ca3affc16a20a2749585aa6464d39c2" +dependencies = [ + "bs58", + "proc-macro2", + "quote", + "solana-pubkey", + "syn 2.0.115", +] + +[[package]] +name = "light-merkle-tree-metadata" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7623246ad0015345f6a88471f554381e24635b770fe4b15b38384daddf1d2f5f" +dependencies = [ + "anchor-lang", + "borsh 0.10.4", + "bytemuck", + "light-compressed-account", + "solana-msg", + "solana-program-error", + "solana-sysvar", + "thiserror 2.0.18", + "zerocopy", +] + +[[package]] +name = "light-merkle-tree-reference" +version = "4.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8d480f62ca32b38a6231bbc5310d693f91d6b5bdcc18bb13c2d9aab7a1c90e8" +dependencies = [ + "light-hasher", + "light-indexed-array", + "num-bigint 0.4.6", + "num-traits", + "thiserror 2.0.18", +] + +[[package]] +name = "light-poseidon" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c9a85a9752c549ceb7578064b4ed891179d20acd85f27318573b64d2d7ee7ee" +dependencies = [ + "ark-bn254 0.4.0", + "ark-ff 0.4.2", + "num-bigint 0.4.6", + "thiserror 1.0.69", +] + +[[package]] +name = "light-poseidon" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39e3d87542063daaccbfecd78b60f988079b6ec4e089249658b9455075c78d42" +dependencies = [ + "ark-bn254 0.5.0", + "ark-ff 0.5.0", + "num-bigint 0.4.6", + "thiserror 1.0.69", +] + +[[package]] +name = "light-profiler-macro" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a8be18fe4de58a6f754caa74a3fbc6d8a758a26f1f3c24d5b0f5b55df5f5408" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "light-program-profiler" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1d345871581aebd8825868a3f08410290aa1cdddcb189ca7f7e588f61d79fcf" +dependencies = [ + "light-profiler-macro", +] + +[[package]] +name = "light-program-test" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49ebb1ed994a05ca5974ad1b701f0dde6c136e41d6387daca7e061720e41b41b" +dependencies = [ + "anchor-lang", + "async-trait", + "base64 0.13.1", + "borsh 0.10.4", + "bs58", + "bytemuck", + "chrono", + "light-account", + "light-account-checks", + "light-client", + "light-compressed-account", + "light-compressed-token-sdk", + "light-compressible", + "light-event", + "light-hasher", + "light-indexed-array", + "light-indexed-merkle-tree", + "light-instruction-decoder", + "light-merkle-tree-metadata", + "light-merkle-tree-reference", + "light-prover-client", + "light-sdk", + "light-sdk-types", + "light-token", + "light-token-interface", + "light-zero-copy", + "litesvm", + "log", + "num-bigint 0.4.6", + "num-traits", + "photon-api", + "rand 0.8.5", + "reqwest 0.12.28", + "serde", + "serde_json", + "solana-account", + "solana-banks-client", + "solana-compute-budget", + "solana-instruction", + "solana-pubkey", + "solana-rpc-client-api", + "solana-sdk", + "solana-transaction", + "solana-transaction-status", + "solana-transaction-status-client-types", + "spl-token-2022 7.0.0", + "tabled", + "tokio", +] + +[[package]] +name = "light-prover-client" +version = "7.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee6e9906d0b834ec2dfe1baf95d61c010f64b3151f4733195fffb8b964ad2763" +dependencies = [ + "ark-bn254 0.5.0", + "ark-serialize 0.5.0", + "ark-std 0.5.0", + "light-compressed-account", + "light-hasher", + "light-indexed-array", + "light-sparse-merkle-tree", + "num-bigint 0.4.6", + "num-traits", + "reqwest 0.11.27", + "serde", + "serde_json", + "solana-bn254", + "thiserror 2.0.18", + "tokio", + "tracing", +] + +[[package]] +name = "light-sdk" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf31676e72039c1663c9c0cc207572f5bfea985f7a39de346b942b3f4c3b92fe" +dependencies = [ + "anchor-lang", + "bincode", + "borsh 0.10.4", + "bytemuck", + "light-account-checks", + "light-compressed-account", + "light-hasher", + "light-macros", + "light-program-profiler", + "light-sdk-macros", + "light-sdk-types", + "light-token-interface", + "light-zero-copy", + "num-bigint 0.4.6", + "solana-account-info", + "solana-clock", + "solana-cpi", + "solana-instruction", + "solana-loader-v3-interface", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "solana-system-interface", + "solana-sysvar", + "thiserror 2.0.18", +] + +[[package]] +name = "light-sdk-macros" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7186366be777810e54f4025ff388d4463c2314df452a2e7f14cb218977fc1ac7" +dependencies = [ + "darling", + "light-hasher", + "light-sdk-types", + "proc-macro2", + "quote", + "solana-pubkey", + "syn 2.0.115", +] + +[[package]] +name = "light-sdk-types" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d60036a8f1af0d3aa651780aa57ae2cdca3fa0f16acecda71c98f81a53e37c9" +dependencies = [ + "anchor-lang", + "borsh 0.10.4", + "bytemuck", + "light-account-checks", + "light-compressed-account", + "light-compressible", + "light-hasher", + "light-macros", + "light-token-interface", + "solana-msg", + "solana-program-error", + "thiserror 2.0.18", +] + +[[package]] +name = "light-sparse-merkle-tree" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4251e79b6c63f4946572dcfd7623680ad0f9e0efe1a761a944733333c5645063" +dependencies = [ + "light-hasher", + "light-indexed-array", + "num-bigint 0.4.6", + "num-traits", + "thiserror 2.0.18", +] + +[[package]] +name = "light-token" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9940ddbb68ace4cd49e9312bb1d573146232c6460b95f669433b9e1c16fa147b" +dependencies = [ + "anchor-lang", + "arrayvec", + "borsh 0.10.4", + "light-account", + "light-account-checks", + "light-batched-merkle-tree", + "light-compressed-account", + "light-compressed-token-sdk", + "light-compressible", + "light-macros", + "light-program-profiler", + "light-sdk", + "light-sdk-macros", + "light-sdk-types", + "light-token-interface", + "light-token-types", + "light-zero-copy", + "solana-account-info", + "solana-cpi", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-pod", + "thiserror 2.0.18", +] + +[[package]] +name = "light-token-interface" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a457179188d9b6b7208a8a63a1fea851f818adfde3faaa262474bdcd3e3c7d" +dependencies = [ + "aligned-sized", + "anchor-lang", + "borsh 0.10.4", + "bytemuck", + "light-array-map", + "light-compressed-account", + "light-compressible", + "light-hasher", + "light-macros", + "light-program-profiler", + "light-zero-copy", + "pinocchio", + "pinocchio-pubkey", + "solana-account-info", + "solana-pubkey", + "spl-pod", + "spl-token-2022 7.0.0", + "thiserror 2.0.18", + "tinyvec", + "zerocopy", +] + +[[package]] +name = "light-token-types" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3daffe234719b109238a81d3b61009b9005a58a014436124edf55600361187e2" +dependencies = [ + "anchor-lang", + "borsh 0.10.4", + "light-account-checks", + "light-compressed-account", + "light-macros", + "light-sdk-types", + "solana-msg", + "thiserror 2.0.18", +] + +[[package]] +name = "light-verifier" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65a33dc6b302f2cfb7319006f1234f1d86c992ac1991ade7c97653828b7f1735" +dependencies = [ + "groth16-solana", + "light-compressed-account", + "thiserror 2.0.18", +] + +[[package]] +name = "light-zero-copy" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5621fb515e14af46148699c0b65334aabe230a1d2cbd06736ccc7a408c8a4af" +dependencies = [ + "light-zero-copy-derive", + "solana-program-error", + "zerocopy", +] + +[[package]] +name = "light-zero-copy-derive" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41c46425e5c7ab5203ff5c86ae2615b169cca55f9283f5f60f5dd74143be6934" +dependencies = [ + "lazy_static", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "linux-raw-sys" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039" + +[[package]] +name = "litemap" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77" + +[[package]] +name = "litesvm" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23bca37ac374948b348e29c74b324dc36f18bbbd1ccf80e2046d967521cbd143" +dependencies = [ + "agave-feature-set", + "agave-precompiles", + "agave-reserved-account-keys", + "ansi_term", + "bincode", + "indexmap 2.13.0", + "itertools 0.14.0", + "log", + "solana-account", + "solana-address-lookup-table-interface", + "solana-bpf-loader-program", + "solana-builtins", + "solana-clock", + "solana-compute-budget", + "solana-compute-budget-instruction", + "solana-epoch-rewards", + "solana-epoch-schedule", + "solana-fee", + "solana-fee-structure", + "solana-hash", + "solana-instruction", + "solana-instructions-sysvar", + "solana-keypair", + "solana-last-restart-slot", + "solana-loader-v3-interface", + "solana-loader-v4-interface", + "solana-log-collector", + "solana-message", + "solana-native-token 3.0.0", + "solana-nonce", + "solana-nonce-account", + "solana-precompile-error", + "solana-program-error", + "solana-program-runtime", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-sha256-hasher", + "solana-signature", + "solana-signer", + "solana-slot-hashes", + "solana-slot-history", + "solana-stake-interface", + "solana-svm-callback", + "solana-svm-transaction", + "solana-system-interface", + "solana-system-program", + "solana-sysvar", + "solana-sysvar-id", + "solana-timings", + "solana-transaction", + "solana-transaction-context", + "solana-transaction-error", + "solana-vote-program", + "thiserror 2.0.18", +] + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" + +[[package]] +name = "lru-slab" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" + +[[package]] +name = "memchr" +version = "2.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" + +[[package]] +name = "memmap2" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" +dependencies = [ + "libc", +] + +[[package]] +name = "memoffset" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a" +dependencies = [ + "autocfg", +] + +[[package]] +name = "merlin" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58c38e2799fc0978b65dfff8023ec7843e2330bb462f19198840b34b6582397d" +dependencies = [ + "byteorder", + "keccak", + "rand_core 0.6.4", + "zeroize", +] + +[[package]] +name = "mime" +version = "0.3.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" + +[[package]] +name = "mime_guess" +version = "2.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e" +dependencies = [ + "mime", + "unicase", +] + +[[package]] +name = "miniz_oxide" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316" +dependencies = [ + "adler2", + "simd-adler32", +] + +[[package]] +name = "mio" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc" +dependencies = [ + "libc", + "wasi 0.11.1+wasi-snapshot-preview1", + "windows-sys 0.61.2", +] + +[[package]] +name = "native-tls" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6cdede44f9a69cab2899a2049e2c3bd49bf911a157f6a3353d4a91c61abbce44" +dependencies = [ + "libc", + "log", + "openssl", + "openssl-probe", + "openssl-sys", + "schannel", + "security-framework", + "security-framework-sys", + "tempfile", +] + +[[package]] +name = "num" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8536030f9fea7127f841b45bb6243b27255787fb4eb83958aa1ef9d2fdc0c36" +dependencies = [ + "num-bigint 0.2.6", + "num-complex", + "num-integer", + "num-iter", + "num-rational", + "num-traits", +] + +[[package]] +name = "num-bigint" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-bigint" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9" +dependencies = [ + "num-integer", + "num-traits", + "serde", +] + +[[package]] +name = "num-complex" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6b19411a9719e753aff12e5187b74d60d3dc449ec3f4dc21e3989c3f554bc95" +dependencies = [ + "autocfg", + "num-traits", +] + +[[package]] +name = "num-conv" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050" + +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c000134b5dbf44adc5cb772486d335293351644b801551abe8f75c84cfa4aef" +dependencies = [ + "autocfg", + "num-bigint 0.2.6", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "num_enum" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c" +dependencies = [ + "num_enum_derive", + "rustversion", +] + +[[package]] +name = "num_enum_derive" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7" +dependencies = [ + "proc-macro-crate 3.4.0", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "number_prefix" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + +[[package]] +name = "openssl" +version = "0.10.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328" +dependencies = [ + "bitflags 2.10.0", + "cfg-if", + "foreign-types", + "libc", + "once_cell", + "openssl-macros", + "openssl-sys", +] + +[[package]] +name = "openssl-macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "openssl-probe" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e" + +[[package]] +name = "openssl-src" +version = "300.5.5+3.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f1787d533e03597a7934fd0a765f0d28e94ecc5fb7789f8053b1e699a56f709" +dependencies = [ + "cc", +] + +[[package]] +name = "openssl-sys" +version = "0.9.111" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321" +dependencies = [ + "cc", + "libc", + "openssl-src", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "opentelemetry" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6105e89802af13fdf48c49d7646d3b533a70e536d818aae7e78ba0433d01acb8" +dependencies = [ + "async-trait", + "crossbeam-channel", + "futures-channel", + "futures-executor", + "futures-util", + "js-sys", + "lazy_static", + "percent-encoding", + "pin-project", + "rand 0.8.5", + "thiserror 1.0.69", +] + +[[package]] +name = "papergrid" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6978128c8b51d8f4080631ceb2302ab51e32cc6e8615f735ee2f83fd269ae3f1" +dependencies = [ + "bytecount", + "fnv", + "unicode-width", +] + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-link", +] + +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + +[[package]] +name = "pbkdf2" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917" +dependencies = [ + "digest 0.10.7", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "percentage" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2fd23b938276f14057220b707937bcb42fa76dda7560e57a2da30cb52d557937" +dependencies = [ + "num", +] + +[[package]] +name = "photon-api" +version = "0.54.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e572dba0c255f5b8176f15b9e849330d915a8927804f7f9702d5bbbc70e4a1ad" +dependencies = [ + "reqwest 0.12.28", + "serde", + "serde_derive", + "serde_json", + "serde_with", + "url", + "uuid", +] + +[[package]] +name = "pin-project" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a" +dependencies = [ + "pin-project-internal", +] + +[[package]] +name = "pin-project-internal" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "pinocchio" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b971851087bc3699b001954ad02389d50c41405ece3548cbcafc88b3e20017a" + +[[package]] +name = "pinocchio-counter" +version = "0.1.0" +dependencies = [ + "blake3", + "borsh 0.10.4", + "bytemuck", + "light-account", + "light-account-pinocchio", + "light-client", + "light-hasher", + "light-program-test", + "pinocchio", + "pinocchio-pubkey", + "pinocchio-system", + "solana-instruction", + "solana-keypair", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "solana-sdk", + "solana-signer", + "tokio", +] + +[[package]] +name = "pinocchio-pubkey" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb0225638cadcbebae8932cb7f49cb5da7c15c21beb19f048f05a5ca7d93f065" +dependencies = [ + "five8_const", + "pinocchio", + "sha2-const-stable", +] + +[[package]] +name = "pinocchio-system" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "141ed5eafb4ab04568bb0e224e3dc9a9de13c933de4c004e0d1a553498be3a7c" +dependencies = [ + "pinocchio", + "pinocchio-pubkey", +] + +[[package]] +name = "pkg-config" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" + +[[package]] +name = "polyval" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" +dependencies = [ + "cfg-if", + "cpufeatures", + "opaque-debug", + "universal-hash", +] + +[[package]] +name = "portable-atomic" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49" + +[[package]] +name = "potential_utf" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77" +dependencies = [ + "zerovec", +] + +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn 2.0.115", +] + +[[package]] +name = "proc-macro-crate" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d6ea3c4595b96363c13943497db34af4460fb474a95c43f4446ad341b8c9785" +dependencies = [ + "toml", +] + +[[package]] +name = "proc-macro-crate" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983" +dependencies = [ + "toml_edit", +] + +[[package]] +name = "proc-macro-error-attr2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5" +dependencies = [ + "proc-macro2", + "quote", +] + +[[package]] +name = "proc-macro-error2" +version = "2.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802" +dependencies = [ + "proc-macro-error-attr2", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "qstring" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d464fae65fff2680baf48019211ce37aaec0c78e9264c84a3e484717f965104e" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "qualifier_attr" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e2e25ee72f5b24d773cae88422baddefff7714f97aab68d96fe2b6fc4a28fb2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "quinn" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20" +dependencies = [ + "bytes", + "cfg_aliases", + "pin-project-lite", + "quinn-proto", + "quinn-udp", + "rustc-hash", + "rustls 0.23.36", + "socket2 0.6.2", + "thiserror 2.0.18", + "tokio", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-proto" +version = "0.11.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" +dependencies = [ + "bytes", + "getrandom 0.3.4", + "lru-slab", + "rand 0.9.2", + "ring", + "rustc-hash", + "rustls 0.23.36", + "rustls-pki-types", + "slab", + "thiserror 2.0.18", + "tinyvec", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-udp" +version = "0.5.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" +dependencies = [ + "cfg_aliases", + "libc", + "once_cell", + "socket2 0.6.2", + "tracing", + "windows-sys 0.60.2", +] + +[[package]] +name = "quote" +version = "1.0.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "radium" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" + +[[package]] +name = "rand" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" +dependencies = [ + "getrandom 0.1.16", + "libc", + "rand_chacha 0.2.2", + "rand_core 0.5.1", + "rand_hc", +] + +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha 0.3.1", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1" +dependencies = [ + "rand_chacha 0.9.0", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_chacha" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" +dependencies = [ + "ppv-lite86", + "rand_core 0.5.1", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" +dependencies = [ + "getrandom 0.1.16", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rand_hc" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" +dependencies = [ + "rand_core 0.5.1", +] + +[[package]] +name = "rayon" +version = "1.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f" +dependencies = [ + "either", + "rayon-core", +] + +[[package]] +name = "rayon-core" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91" +dependencies = [ + "crossbeam-deque", + "crossbeam-utils", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags 2.10.0", +] + +[[package]] +name = "ref-cast" +version = "1.0.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d" +dependencies = [ + "ref-cast-impl", +] + +[[package]] +name = "ref-cast-impl" +version = "1.0.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "regex" +version = "1.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-syntax" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c" + +[[package]] +name = "reqwest" +version = "0.11.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62" +dependencies = [ + "base64 0.21.7", + "bytes", + "encoding_rs", + "futures-core", + "futures-util", + "h2 0.3.27", + "http 0.2.12", + "http-body 0.4.6", + "hyper 0.14.32", + "hyper-rustls 0.24.2", + "hyper-tls 0.5.0", + "ipnet", + "js-sys", + "log", + "mime", + "native-tls", + "once_cell", + "percent-encoding", + "pin-project-lite", + "rustls 0.21.12", + "rustls-pemfile", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper 0.1.2", + "system-configuration 0.5.1", + "tokio", + "tokio-native-tls", + "tokio-rustls 0.24.1", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "webpki-roots 0.25.4", + "winreg", +] + +[[package]] +name = "reqwest" +version = "0.12.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" +dependencies = [ + "base64 0.22.1", + "bytes", + "encoding_rs", + "futures-channel", + "futures-core", + "futures-util", + "h2 0.4.13", + "http 1.4.0", + "http-body 1.0.1", + "http-body-util", + "hyper 1.8.1", + "hyper-rustls 0.27.7", + "hyper-tls 0.6.0", + "hyper-util", + "js-sys", + "log", + "mime", + "mime_guess", + "native-tls", + "percent-encoding", + "pin-project-lite", + "quinn", + "rustls 0.23.36", + "rustls-pki-types", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper 1.0.2", + "tokio", + "tokio-native-tls", + "tokio-rustls 0.26.4", + "tower", + "tower-http", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", + "webpki-roots 1.0.6", +] + +[[package]] +name = "reqwest-middleware" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57f17d28a6e6acfe1733fe24bcd30774d13bffa4b8a22535b4c8c98423088d4e" +dependencies = [ + "anyhow", + "async-trait", + "http 1.4.0", + "reqwest 0.12.28", + "serde", + "thiserror 1.0.69", + "tower-service", +] + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rustc-demangle" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b50b8869d9fc858ce7266cce0194bd74df58b9d0e3f6df3a9fc8eb470d95c09d" + +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustix" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34" +dependencies = [ + "bitflags 2.10.0", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.21.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e" +dependencies = [ + "log", + "ring", + "rustls-webpki 0.101.7", + "sct", +] + +[[package]] +name = "rustls" +version = "0.23.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b" +dependencies = [ + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki 0.103.9", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-pemfile" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" +dependencies = [ + "base64 0.21.7", +] + +[[package]] +name = "rustls-pki-types" +version = "1.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd" +dependencies = [ + "web-time", + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.101.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" +dependencies = [ + "ring", + "untrusted", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7df23109aa6c1567d1c575b9952556388da57401e4ace1d15f79eedad0d8f53" +dependencies = [ + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + +[[package]] +name = "schannel" +version = "0.1.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "schemars" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f" +dependencies = [ + "dyn-clone", + "ref-cast", + "serde", + "serde_json", +] + +[[package]] +name = "schemars" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc" +dependencies = [ + "dyn-clone", + "ref-cast", + "serde", + "serde_json", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "sct" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" +dependencies = [ + "ring", + "untrusted", +] + +[[package]] +name = "security-framework" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02" +dependencies = [ + "bitflags 2.10.0", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "semver" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde-big-array" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11fc7cc2c76d73e0f27ee52abbd64eec84d46f370c88371120433196934e4b7f" +dependencies = [ + "serde", +] + +[[package]] +name = "serde_bytes" +version = "0.11.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8" +dependencies = [ + "serde", + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "serde_json" +version = "1.0.149" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "serde_with" +version = "3.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7" +dependencies = [ + "base64 0.22.1", + "chrono", + "hex", + "indexmap 1.9.3", + "indexmap 2.13.0", + "schemars 0.9.0", + "schemars 1.2.1", + "serde_core", + "serde_json", + "serde_with_macros", + "time", +] + +[[package]] +name = "serde_with_macros" +version = "3.16.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "sha2" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800" +dependencies = [ + "block-buffer 0.9.0", + "cfg-if", + "cpufeatures", + "digest 0.9.0", + "opaque-debug", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest 0.10.7", +] + +[[package]] +name = "sha2-const-stable" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f179d4e11094a893b82fff208f74d448a7512f99f5a0acbd5c679b705f83ed9" + +[[package]] +name = "sha3" +version = "0.10.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60" +dependencies = [ + "digest 0.10.7", + "keccak", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "signal-hook" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2" +dependencies = [ + "libc", + "signal-hook-registry", +] + +[[package]] +name = "signal-hook-registry" +version = "1.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" +dependencies = [ + "errno", + "libc", +] + +[[package]] +name = "signature" +version = "1.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c" + +[[package]] +name = "simd-adler32" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" + +[[package]] +name = "siphasher" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03" + +[[package]] +name = "socket2" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "socket2" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0" +dependencies = [ + "libc", + "windows-sys 0.60.2", +] + +[[package]] +name = "solana-account" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f949fe4edaeaea78c844023bfc1c898e0b1f5a100f8a8d2d0f85d0a7b090258" +dependencies = [ + "bincode", + "serde", + "serde_bytes", + "serde_derive", + "solana-account-info", + "solana-clock", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", + "solana-sysvar", +] + +[[package]] +name = "solana-account-decoder" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba71c97fa4d85ce4a1e0e79044ad0406c419382be598c800202903a7688ce71a" +dependencies = [ + "Inflector", + "base64 0.22.1", + "bincode", + "bs58", + "bv", + "serde", + "serde_derive", + "serde_json", + "solana-account", + "solana-account-decoder-client-types", + "solana-address-lookup-table-interface", + "solana-clock", + "solana-config-program-client", + "solana-epoch-schedule", + "solana-fee-calculator", + "solana-instruction", + "solana-loader-v3-interface", + "solana-nonce", + "solana-program-option", + "solana-program-pack", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-slot-hashes", + "solana-slot-history", + "solana-stake-interface", + "solana-sysvar", + "solana-vote-interface", + "spl-generic-token", + "spl-token 8.0.0", + "spl-token-2022 8.0.1", + "spl-token-group-interface 0.6.0", + "spl-token-metadata-interface 0.7.0", + "thiserror 2.0.18", + "zstd", +] + +[[package]] +name = "solana-account-decoder-client-types" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5519e8343325b707f17fbed54fcefb325131b692506d0af9e08a539d15e4f8cf" +dependencies = [ + "base64 0.22.1", + "bs58", + "serde", + "serde_derive", + "serde_json", + "solana-account", + "solana-pubkey", + "zstd", +] + +[[package]] +name = "solana-account-info" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8f5152a288ef1912300fc6efa6c2d1f9bb55d9398eb6c72326360b8063987da" +dependencies = [ + "bincode", + "serde", + "solana-program-error", + "solana-program-memory", + "solana-pubkey", +] + +[[package]] +name = "solana-address-lookup-table-interface" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1673f67efe870b64a65cb39e6194be5b26527691ce5922909939961a6e6b395" +dependencies = [ + "bincode", + "bytemuck", + "serde", + "serde_derive", + "solana-clock", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", + "solana-slot-hashes", +] + +[[package]] +name = "solana-atomic-u64" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d52e52720efe60465b052b9e7445a01c17550666beec855cce66f44766697bc2" +dependencies = [ + "parking_lot", +] + +[[package]] +name = "solana-banks-client" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68548570c38a021c724b5aa0112f45a54bdf7ff1b041a042848e034a95a96994" +dependencies = [ + "borsh 1.6.0", + "futures", + "solana-account", + "solana-banks-interface", + "solana-clock", + "solana-commitment-config", + "solana-hash", + "solana-message", + "solana-program-pack", + "solana-pubkey", + "solana-rent", + "solana-signature", + "solana-sysvar", + "solana-transaction", + "solana-transaction-context", + "solana-transaction-error", + "tarpc", + "thiserror 2.0.18", + "tokio", + "tokio-serde", +] + +[[package]] +name = "solana-banks-interface" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6d90edc435bf488ef7abed4dcb1f94fa1970102cbabb25688f58417fd948286" +dependencies = [ + "serde", + "serde_derive", + "solana-account", + "solana-clock", + "solana-commitment-config", + "solana-hash", + "solana-message", + "solana-pubkey", + "solana-signature", + "solana-transaction", + "solana-transaction-context", + "solana-transaction-error", + "tarpc", +] + +[[package]] +name = "solana-big-mod-exp" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75db7f2bbac3e62cfd139065d15bcda9e2428883ba61fc8d27ccb251081e7567" +dependencies = [ + "num-bigint 0.4.6", + "num-traits", + "solana-define-syscall", +] + +[[package]] +name = "solana-bincode" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19a3787b8cf9c9fe3dd360800e8b70982b9e5a8af9e11c354b6665dd4a003adc" +dependencies = [ + "bincode", + "serde", + "solana-instruction", +] + +[[package]] +name = "solana-blake3-hasher" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1a0801e25a1b31a14494fc80882a036be0ffd290efc4c2d640bfcca120a4672" +dependencies = [ + "blake3", + "solana-define-syscall", + "solana-hash", + "solana-sanitize", +] + +[[package]] +name = "solana-bn254" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4420f125118732833f36facf96a27e7b78314b2d642ba07fa9ffdacd8d79e243" +dependencies = [ + "ark-bn254 0.4.0", + "ark-ec 0.4.2", + "ark-ff 0.4.2", + "ark-serialize 0.4.2", + "bytemuck", + "solana-define-syscall", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-borsh" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "718333bcd0a1a7aed6655aa66bef8d7fb047944922b2d3a18f49cbc13e73d004" +dependencies = [ + "borsh 0.10.4", + "borsh 1.6.0", +] + +[[package]] +name = "solana-bpf-loader-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5aec57dcd80d0f6879956cad28854a6eebaed6b346ce56908ea01a9f36ab259" +dependencies = [ + "bincode", + "libsecp256k1", + "num-traits", + "qualifier_attr", + "scopeguard", + "solana-account", + "solana-account-info", + "solana-big-mod-exp", + "solana-bincode", + "solana-blake3-hasher", + "solana-bn254", + "solana-clock", + "solana-cpi", + "solana-curve25519", + "solana-hash", + "solana-instruction", + "solana-keccak-hasher", + "solana-loader-v3-interface", + "solana-loader-v4-interface", + "solana-log-collector", + "solana-measure", + "solana-packet", + "solana-poseidon", + "solana-program-entrypoint", + "solana-program-runtime", + "solana-pubkey", + "solana-sbpf", + "solana-sdk-ids", + "solana-secp256k1-recover", + "solana-sha256-hasher", + "solana-stable-layout", + "solana-svm-feature-set", + "solana-system-interface", + "solana-sysvar", + "solana-sysvar-id", + "solana-timings", + "solana-transaction-context", + "solana-type-overrides", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-builtins" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d61a31b63b52b0d268cbcd56c76f50314867d7f8e07a0f2c62ee7c9886e07b2" +dependencies = [ + "agave-feature-set", + "solana-bpf-loader-program", + "solana-compute-budget-program", + "solana-hash", + "solana-loader-v4-program", + "solana-program-runtime", + "solana-pubkey", + "solana-sdk-ids", + "solana-stake-program", + "solana-system-program", + "solana-vote-program", + "solana-zk-elgamal-proof-program", + "solana-zk-token-proof-program", +] + +[[package]] +name = "solana-builtins-default-costs" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ca69a299a6c969b18ea381a02b40c9e4dda04b2af0d15a007c1184c82163bbb" +dependencies = [ + "agave-feature-set", + "ahash", + "log", + "solana-bpf-loader-program", + "solana-compute-budget-program", + "solana-loader-v4-program", + "solana-pubkey", + "solana-sdk-ids", + "solana-stake-program", + "solana-system-program", + "solana-vote-program", +] + +[[package]] +name = "solana-client-traits" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83f0071874e629f29e0eb3dab8a863e98502ac7aba55b7e0df1803fc5cac72a7" +dependencies = [ + "solana-account", + "solana-commitment-config", + "solana-epoch-info", + "solana-hash", + "solana-instruction", + "solana-keypair", + "solana-message", + "solana-pubkey", + "solana-signature", + "solana-signer", + "solana-system-interface", + "solana-transaction", + "solana-transaction-error", +] + +[[package]] +name = "solana-clock" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8584296123df8fe229b95e2ebfd37ae637fe9db9b7d4dd677ac5a78e80dbfce" +dependencies = [ + "serde", + "serde_derive", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-sysvar-id", +] + +[[package]] +name = "solana-cluster-type" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ace9fea2daa28354d107ea879cff107181d85cd4e0f78a2bedb10e1a428c97e" +dependencies = [ + "serde", + "serde_derive", + "solana-hash", +] + +[[package]] +name = "solana-commitment-config" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac49c4dde3edfa832de1697e9bcdb7c3b3f7cb7a1981b7c62526c8bb6700fb73" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "solana-compute-budget" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f4fc63bc2276a1618ca0bfc609da7448534ecb43a1cb387cdf9eaa2dc7bc272" +dependencies = [ + "solana-fee-structure", + "solana-program-runtime", +] + +[[package]] +name = "solana-compute-budget-instruction" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "503d94430f6d3c5ac1e1fa6a342c1c714d5b03c800999e7b6cf235298f0b5341" +dependencies = [ + "agave-feature-set", + "log", + "solana-borsh", + "solana-builtins-default-costs", + "solana-compute-budget", + "solana-compute-budget-interface", + "solana-instruction", + "solana-packet", + "solana-pubkey", + "solana-sdk-ids", + "solana-svm-transaction", + "solana-transaction-error", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-compute-budget-interface" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8432d2c4c22d0499aa06d62e4f7e333f81777b3d7c96050ae9e5cb71a8c3aee4" +dependencies = [ + "borsh 1.6.0", + "serde", + "serde_derive", + "solana-instruction", + "solana-sdk-ids", +] + +[[package]] +name = "solana-compute-budget-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "072b02beed1862c6b7b7a8a699379594c4470a9371c711856a0a3c266dcf57e5" +dependencies = [ + "solana-program-runtime", +] + +[[package]] +name = "solana-config-program-client" +version = "0.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53aceac36f105fd4922e29b4f0c1f785b69d7b3e7e387e384b8985c8e0c3595e" +dependencies = [ + "bincode", + "borsh 0.10.4", + "kaigan", + "serde", + "solana-program", +] + +[[package]] +name = "solana-cpi" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8dc71126edddc2ba014622fc32d0f5e2e78ec6c5a1e0eb511b85618c09e9ea11" +dependencies = [ + "solana-account-info", + "solana-define-syscall", + "solana-instruction", + "solana-program-error", + "solana-pubkey", + "solana-stable-layout", +] + +[[package]] +name = "solana-curve25519" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eae4261b9a8613d10e77ac831a8fa60b6fa52b9b103df46d641deff9f9812a23" +dependencies = [ + "bytemuck", + "bytemuck_derive", + "curve25519-dalek 4.1.3", + "solana-define-syscall", + "subtle", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-decode-error" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c781686a18db2f942e70913f7ca15dc120ec38dcab42ff7557db2c70c625a35" +dependencies = [ + "num-traits", +] + +[[package]] +name = "solana-define-syscall" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ae3e2abcf541c8122eafe9a625d4d194b4023c20adde1e251f94e056bb1aee2" + +[[package]] +name = "solana-derivation-path" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "939756d798b25c5ec3cca10e06212bdca3b1443cb9bb740a38124f58b258737b" +dependencies = [ + "derivation-path", + "qstring", + "uriparse", +] + +[[package]] +name = "solana-ed25519-program" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1feafa1691ea3ae588f99056f4bdd1293212c7ece28243d7da257c443e84753" +dependencies = [ + "bytemuck", + "bytemuck_derive", + "ed25519-dalek", + "solana-feature-set", + "solana-instruction", + "solana-precompile-error", + "solana-sdk-ids", +] + +[[package]] +name = "solana-epoch-info" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "90ef6f0b449290b0b9f32973eefd95af35b01c5c0c34c569f936c34c5b20d77b" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "solana-epoch-rewards" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86b575d3dd323b9ea10bb6fe89bf6bf93e249b215ba8ed7f68f1a3633f384db7" +dependencies = [ + "serde", + "serde_derive", + "solana-hash", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-sysvar-id", +] + +[[package]] +name = "solana-epoch-rewards-hasher" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c5fd2662ae7574810904585fd443545ed2b568dbd304b25a31e79ccc76e81b" +dependencies = [ + "siphasher", + "solana-hash", + "solana-pubkey", +] + +[[package]] +name = "solana-epoch-schedule" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fce071fbddecc55d727b1d7ed16a629afe4f6e4c217bc8d00af3b785f6f67ed" +dependencies = [ + "serde", + "serde_derive", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-sysvar-id", +] + +[[package]] +name = "solana-example-mocks" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84461d56cbb8bb8d539347151e0525b53910102e4bced875d49d5139708e39d3" +dependencies = [ + "serde", + "serde_derive", + "solana-address-lookup-table-interface", + "solana-clock", + "solana-hash", + "solana-instruction", + "solana-keccak-hasher", + "solana-message", + "solana-nonce", + "solana-pubkey", + "solana-sdk-ids", + "solana-system-interface", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-feature-gate-interface" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43f5c5382b449e8e4e3016fb05e418c53d57782d8b5c30aa372fc265654b956d" +dependencies = [ + "bincode", + "serde", + "serde_derive", + "solana-account", + "solana-account-info", + "solana-instruction", + "solana-program-error", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-system-interface", +] + +[[package]] +name = "solana-feature-set" +version = "2.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93b93971e289d6425f88e6e3cb6668c4b05df78b3c518c249be55ced8efd6b6d" +dependencies = [ + "ahash", + "lazy_static", + "solana-epoch-schedule", + "solana-hash", + "solana-pubkey", + "solana-sha256-hasher", +] + +[[package]] +name = "solana-fee" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "16beda37597046b1edd1cea6fa7caaed033c091f99ec783fe59c82828bc2adb8" +dependencies = [ + "agave-feature-set", + "solana-fee-structure", + "solana-svm-transaction", +] + +[[package]] +name = "solana-fee-calculator" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d89bc408da0fb3812bc3008189d148b4d3e08252c79ad810b245482a3f70cd8d" +dependencies = [ + "log", + "serde", + "serde_derive", +] + +[[package]] +name = "solana-fee-structure" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33adf673581c38e810bf618f745bf31b683a0a4a4377682e6aaac5d9a058dd4e" +dependencies = [ + "serde", + "serde_derive", + "solana-message", + "solana-native-token 2.3.0", +] + +[[package]] +name = "solana-genesis-config" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3725085d47b96d37fef07a29d78d2787fc89a0b9004c66eed7753d1e554989f" +dependencies = [ + "bincode", + "chrono", + "memmap2", + "serde", + "serde_derive", + "solana-account", + "solana-clock", + "solana-cluster-type", + "solana-epoch-schedule", + "solana-fee-calculator", + "solana-hash", + "solana-inflation", + "solana-keypair", + "solana-logger", + "solana-poh-config", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-sha256-hasher", + "solana-shred-version", + "solana-signer", + "solana-time-utils", +] + +[[package]] +name = "solana-hard-forks" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c28371f878e2ead55611d8ba1b5fb879847156d04edea13693700ad1a28baf" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "solana-hash" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b96e9f0300fa287b545613f007dfe20043d7812bee255f418c1eb649c93b63" +dependencies = [ + "borsh 1.6.0", + "bytemuck", + "bytemuck_derive", + "five8", + "js-sys", + "serde", + "serde_derive", + "solana-atomic-u64", + "solana-sanitize", + "wasm-bindgen", +] + +[[package]] +name = "solana-inflation" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23eef6a09eb8e568ce6839573e4966850e85e9ce71e6ae1a6c930c1c43947de3" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "solana-instruction" +version = "2.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bab5682934bd1f65f8d2c16f21cb532526fcc1a09f796e2cacdb091eee5774ad" +dependencies = [ + "bincode", + "borsh 1.6.0", + "getrandom 0.2.17", + "js-sys", + "num-traits", + "serde", + "serde_derive", + "serde_json", + "solana-define-syscall", + "solana-pubkey", + "wasm-bindgen", +] + +[[package]] +name = "solana-instructions-sysvar" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e0e85a6fad5c2d0c4f5b91d34b8ca47118fc593af706e523cdbedf846a954f57" +dependencies = [ + "bitflags 2.10.0", + "solana-account-info", + "solana-instruction", + "solana-program-error", + "solana-pubkey", + "solana-sanitize", + "solana-sdk-ids", + "solana-serialize-utils", + "solana-sysvar-id", +] + +[[package]] +name = "solana-keccak-hasher" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7aeb957fbd42a451b99235df4942d96db7ef678e8d5061ef34c9b34cae12f79" +dependencies = [ + "sha3", + "solana-define-syscall", + "solana-hash", + "solana-sanitize", +] + +[[package]] +name = "solana-keypair" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bd3f04aa1a05c535e93e121a95f66e7dcccf57e007282e8255535d24bf1e98bb" +dependencies = [ + "ed25519-dalek", + "ed25519-dalek-bip32", + "five8", + "rand 0.7.3", + "solana-derivation-path", + "solana-pubkey", + "solana-seed-derivable", + "solana-seed-phrase", + "solana-signature", + "solana-signer", + "wasm-bindgen", +] + +[[package]] +name = "solana-last-restart-slot" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a6360ac2fdc72e7463565cd256eedcf10d7ef0c28a1249d261ec168c1b55cdd" +dependencies = [ + "serde", + "serde_derive", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-sysvar-id", +] + +[[package]] +name = "solana-loader-v2-interface" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8ab08006dad78ae7cd30df8eea0539e207d08d91eaefb3e1d49a446e1c49654" +dependencies = [ + "serde", + "serde_bytes", + "serde_derive", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", +] + +[[package]] +name = "solana-loader-v3-interface" +version = "5.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f7162a05b8b0773156b443bccd674ea78bb9aa406325b467ea78c06c99a63a2" +dependencies = [ + "serde", + "serde_bytes", + "serde_derive", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", + "solana-system-interface", +] + +[[package]] +name = "solana-loader-v4-interface" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "706a777242f1f39a83e2a96a2a6cb034cb41169c6ecbee2cf09cb873d9659e7e" +dependencies = [ + "serde", + "serde_bytes", + "serde_derive", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", + "solana-system-interface", +] + +[[package]] +name = "solana-loader-v4-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ab01855d851fa2fb6034b0d48de33d77d5c5f5fb4b0353d8e4a934cc03d48a" +dependencies = [ + "log", + "qualifier_attr", + "solana-account", + "solana-bincode", + "solana-bpf-loader-program", + "solana-instruction", + "solana-loader-v3-interface", + "solana-loader-v4-interface", + "solana-log-collector", + "solana-measure", + "solana-packet", + "solana-program-runtime", + "solana-pubkey", + "solana-sbpf", + "solana-sdk-ids", + "solana-transaction-context", + "solana-type-overrides", +] + +[[package]] +name = "solana-log-collector" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d945b1cf5bf7cbd6f5b78795beda7376370c827640df43bb2a1c17b492dc106" +dependencies = [ + "log", +] + +[[package]] +name = "solana-logger" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db8e777ec1afd733939b532a42492d888ec7c88d8b4127a5d867eb45c6eb5cd5" +dependencies = [ + "env_logger", + "lazy_static", + "libc", + "log", + "signal-hook", +] + +[[package]] +name = "solana-measure" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11dcd67cd2ae6065e494b64e861e0498d046d95a61cbbf1ae3d58be1ea0f42ed" + +[[package]] +name = "solana-message" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1796aabce376ff74bf89b78d268fa5e683d7d7a96a0a4e4813ec34de49d5314b" +dependencies = [ + "bincode", + "blake3", + "lazy_static", + "serde", + "serde_derive", + "solana-bincode", + "solana-hash", + "solana-instruction", + "solana-pubkey", + "solana-sanitize", + "solana-sdk-ids", + "solana-short-vec", + "solana-system-interface", + "solana-transaction-error", + "wasm-bindgen", +] + +[[package]] +name = "solana-metrics" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0375159d8460f423d39e5103dcff6e07796a5ec1850ee1fcfacfd2482a8f34b5" +dependencies = [ + "crossbeam-channel", + "gethostname", + "log", + "reqwest 0.12.28", + "solana-cluster-type", + "solana-sha256-hasher", + "solana-time-utils", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-msg" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f36a1a14399afaabc2781a1db09cb14ee4cc4ee5c7a5a3cfcc601811379a8092" +dependencies = [ + "solana-define-syscall", +] + +[[package]] +name = "solana-native-token" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61515b880c36974053dd499c0510066783f0cc6ac17def0c7ef2a244874cf4a9" + +[[package]] +name = "solana-native-token" +version = "3.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae8dd4c280dca9d046139eb5b7a5ac9ad10403fbd64964c7d7571214950d758f" + +[[package]] +name = "solana-nonce" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "703e22eb185537e06204a5bd9d509b948f0066f2d1d814a6f475dafb3ddf1325" +dependencies = [ + "serde", + "serde_derive", + "solana-fee-calculator", + "solana-hash", + "solana-pubkey", + "solana-sha256-hasher", +] + +[[package]] +name = "solana-nonce-account" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cde971a20b8dbf60144d6a84439dda86b5466e00e2843091fe731083cda614da" +dependencies = [ + "solana-account", + "solana-hash", + "solana-nonce", + "solana-sdk-ids", +] + +[[package]] +name = "solana-nostd-keccak" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8ced70920435b1baa58f76e6f84bbc1110ddd1d6161ec76b6d731ae8431e9c4" +dependencies = [ + "sha3", +] + +[[package]] +name = "solana-offchain-message" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b526398ade5dea37f1f147ce55dae49aa017a5d7326606359b0445ca8d946581" +dependencies = [ + "num_enum", + "solana-hash", + "solana-packet", + "solana-pubkey", + "solana-sanitize", + "solana-sha256-hasher", + "solana-signature", + "solana-signer", +] + +[[package]] +name = "solana-packet" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "004f2d2daf407b3ec1a1ca5ec34b3ccdfd6866dd2d3c7d0715004a96e4b6d127" +dependencies = [ + "bincode", + "bitflags 2.10.0", + "cfg_eval", + "serde", + "serde_derive", + "serde_with", +] + +[[package]] +name = "solana-poh-config" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d650c3b4b9060082ac6b0efbbb66865089c58405bfb45de449f3f2b91eccee75" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "solana-poseidon" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cbac4eb90016eeb1d37fa36e592d3a64421510c49666f81020736611c319faff" +dependencies = [ + "ark-bn254 0.4.0", + "light-poseidon 0.2.0", + "solana-define-syscall", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-precompile-error" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d87b2c1f5de77dfe2b175ee8dd318d196aaca4d0f66f02842f80c852811f9f8" +dependencies = [ + "num-traits", + "solana-decode-error", +] + +[[package]] +name = "solana-precompiles" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36e92768a57c652edb0f5d1b30a7d0bc64192139c517967c18600debe9ae3832" +dependencies = [ + "lazy_static", + "solana-ed25519-program", + "solana-feature-set", + "solana-message", + "solana-precompile-error", + "solana-pubkey", + "solana-sdk-ids", + "solana-secp256k1-program", + "solana-secp256r1-program", +] + +[[package]] +name = "solana-presigner" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81a57a24e6a4125fc69510b6774cd93402b943191b6cddad05de7281491c90fe" +dependencies = [ + "solana-pubkey", + "solana-signature", + "solana-signer", +] + +[[package]] +name = "solana-program" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "98eca145bd3545e2fbb07166e895370576e47a00a7d824e325390d33bf467210" +dependencies = [ + "bincode", + "blake3", + "borsh 0.10.4", + "borsh 1.6.0", + "bs58", + "bytemuck", + "console_error_panic_hook", + "console_log", + "getrandom 0.2.17", + "lazy_static", + "log", + "memoffset", + "num-bigint 0.4.6", + "num-derive", + "num-traits", + "rand 0.8.5", + "serde", + "serde_bytes", + "serde_derive", + "solana-account-info", + "solana-address-lookup-table-interface", + "solana-atomic-u64", + "solana-big-mod-exp", + "solana-bincode", + "solana-blake3-hasher", + "solana-borsh", + "solana-clock", + "solana-cpi", + "solana-decode-error", + "solana-define-syscall", + "solana-epoch-rewards", + "solana-epoch-schedule", + "solana-example-mocks", + "solana-feature-gate-interface", + "solana-fee-calculator", + "solana-hash", + "solana-instruction", + "solana-instructions-sysvar", + "solana-keccak-hasher", + "solana-last-restart-slot", + "solana-loader-v2-interface", + "solana-loader-v3-interface", + "solana-loader-v4-interface", + "solana-message", + "solana-msg", + "solana-native-token 2.3.0", + "solana-nonce", + "solana-program-entrypoint", + "solana-program-error", + "solana-program-memory", + "solana-program-option", + "solana-program-pack", + "solana-pubkey", + "solana-rent", + "solana-sanitize", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-secp256k1-recover", + "solana-serde-varint", + "solana-serialize-utils", + "solana-sha256-hasher", + "solana-short-vec", + "solana-slot-hashes", + "solana-slot-history", + "solana-stable-layout", + "solana-stake-interface", + "solana-system-interface", + "solana-sysvar", + "solana-sysvar-id", + "solana-vote-interface", + "thiserror 2.0.18", + "wasm-bindgen", +] + +[[package]] +name = "solana-program-entrypoint" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32ce041b1a0ed275290a5008ee1a4a6c48f5054c8a3d78d313c08958a06aedbd" +dependencies = [ + "solana-account-info", + "solana-msg", + "solana-program-error", + "solana-pubkey", +] + +[[package]] +name = "solana-program-error" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ee2e0217d642e2ea4bee237f37bd61bb02aec60da3647c48ff88f6556ade775" +dependencies = [ + "borsh 1.6.0", + "num-traits", + "serde", + "serde_derive", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-pubkey", +] + +[[package]] +name = "solana-program-memory" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a5426090c6f3fd6cfdc10685322fede9ca8e5af43cd6a59e98bfe4e91671712" +dependencies = [ + "solana-define-syscall", +] + +[[package]] +name = "solana-program-option" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc677a2e9bc616eda6dbdab834d463372b92848b2bfe4a1ed4e4b4adba3397d0" + +[[package]] +name = "solana-program-pack" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "319f0ef15e6e12dc37c597faccb7d62525a509fec5f6975ecb9419efddeb277b" +dependencies = [ + "solana-program-error", +] + +[[package]] +name = "solana-program-runtime" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5653001e07b657c9de6f0417cf9add1cf4325903732c480d415655e10cc86704" +dependencies = [ + "base64 0.22.1", + "bincode", + "enum-iterator", + "itertools 0.12.1", + "log", + "percentage", + "rand 0.8.5", + "serde", + "solana-account", + "solana-clock", + "solana-epoch-rewards", + "solana-epoch-schedule", + "solana-fee-structure", + "solana-hash", + "solana-instruction", + "solana-last-restart-slot", + "solana-log-collector", + "solana-measure", + "solana-metrics", + "solana-program-entrypoint", + "solana-pubkey", + "solana-rent", + "solana-sbpf", + "solana-sdk-ids", + "solana-slot-hashes", + "solana-stable-layout", + "solana-svm-callback", + "solana-svm-feature-set", + "solana-system-interface", + "solana-sysvar", + "solana-sysvar-id", + "solana-timings", + "solana-transaction-context", + "solana-type-overrides", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-pubkey" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b62adb9c3261a052ca1f999398c388f1daf558a1b492f60a6d9e64857db4ff1" +dependencies = [ + "borsh 0.10.4", + "borsh 1.6.0", + "bytemuck", + "bytemuck_derive", + "curve25519-dalek 4.1.3", + "five8", + "five8_const", + "getrandom 0.2.17", + "js-sys", + "num-traits", + "rand 0.8.5", + "serde", + "serde_derive", + "solana-atomic-u64", + "solana-decode-error", + "solana-define-syscall", + "solana-sanitize", + "solana-sha256-hasher", + "wasm-bindgen", +] + +[[package]] +name = "solana-quic-definitions" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbf0d4d5b049eb1d0c35f7b18f305a27c8986fc5c0c9b383e97adaa35334379e" +dependencies = [ + "solana-keypair", +] + +[[package]] +name = "solana-rent" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1aea8fdea9de98ca6e8c2da5827707fb3842833521b528a713810ca685d2480" +dependencies = [ + "serde", + "serde_derive", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-sysvar-id", +] + +[[package]] +name = "solana-rent-collector" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "127e6dfa51e8c8ae3aa646d8b2672bc4ac901972a338a9e1cd249e030564fb9d" +dependencies = [ + "serde", + "serde_derive", + "solana-account", + "solana-clock", + "solana-epoch-schedule", + "solana-genesis-config", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", +] + +[[package]] +name = "solana-rent-debits" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f6f9113c6003492e74438d1288e30cffa8ccfdc2ef7b49b9e816d8034da18cd" +dependencies = [ + "solana-pubkey", + "solana-reward-info", +] + +[[package]] +name = "solana-reserved-account-keys" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4b22ea19ca2a3f28af7cd047c914abf833486bf7a7c4a10fc652fff09b385b1" +dependencies = [ + "lazy_static", + "solana-feature-set", + "solana-pubkey", + "solana-sdk-ids", +] + +[[package]] +name = "solana-reward-info" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18205b69139b1ae0ab8f6e11cdcb627328c0814422ad2482000fa2ca54ae4a2f" +dependencies = [ + "serde", + "serde_derive", +] + +[[package]] +name = "solana-rpc-client" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8d3161ac0918178e674c1f7f1bfac40de3e7ed0383bd65747d63113c156eaeb" +dependencies = [ + "async-trait", + "base64 0.22.1", + "bincode", + "bs58", + "futures", + "indicatif", + "log", + "reqwest 0.12.28", + "reqwest-middleware", + "semver", + "serde", + "serde_derive", + "serde_json", + "solana-account", + "solana-account-decoder-client-types", + "solana-clock", + "solana-commitment-config", + "solana-epoch-info", + "solana-epoch-schedule", + "solana-feature-gate-interface", + "solana-hash", + "solana-instruction", + "solana-message", + "solana-pubkey", + "solana-rpc-client-api", + "solana-signature", + "solana-transaction", + "solana-transaction-error", + "solana-transaction-status-client-types", + "solana-version", + "solana-vote-interface", + "tokio", +] + +[[package]] +name = "solana-rpc-client-api" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dbc138685c79d88a766a8fd825057a74ea7a21e1dd7f8de275ada899540fff7" +dependencies = [ + "anyhow", + "jsonrpc-core", + "reqwest 0.12.28", + "reqwest-middleware", + "serde", + "serde_derive", + "serde_json", + "solana-account-decoder-client-types", + "solana-clock", + "solana-rpc-client-types", + "solana-signer", + "solana-transaction-error", + "solana-transaction-status-client-types", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-rpc-client-types" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ea428a81729255d895ea47fba9b30fd4dacbfe571a080448121bd0592751676" +dependencies = [ + "base64 0.22.1", + "bs58", + "semver", + "serde", + "serde_derive", + "serde_json", + "solana-account", + "solana-account-decoder-client-types", + "solana-clock", + "solana-commitment-config", + "solana-fee-calculator", + "solana-inflation", + "solana-pubkey", + "solana-transaction-error", + "solana-transaction-status-client-types", + "solana-version", + "spl-generic-token", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-sanitize" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61f1bc1357b8188d9c4a3af3fc55276e56987265eb7ad073ae6f8180ee54cecf" + +[[package]] +name = "solana-sbpf" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "474a2d95dc819898ded08d24f29642d02189d3e1497bbb442a92a3997b7eb55f" +dependencies = [ + "byteorder", + "combine", + "hash32", + "libc", + "log", + "rand 0.8.5", + "rustc-demangle", + "thiserror 2.0.18", + "winapi", +] + +[[package]] +name = "solana-sdk" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8cc0e4a7635b902791c44b6581bfb82f3ada32c5bc0929a64f39fe4bb384c86a" +dependencies = [ + "bincode", + "bs58", + "getrandom 0.1.16", + "js-sys", + "serde", + "serde_json", + "solana-account", + "solana-bn254", + "solana-client-traits", + "solana-cluster-type", + "solana-commitment-config", + "solana-compute-budget-interface", + "solana-decode-error", + "solana-derivation-path", + "solana-ed25519-program", + "solana-epoch-info", + "solana-epoch-rewards-hasher", + "solana-feature-set", + "solana-fee-structure", + "solana-genesis-config", + "solana-hard-forks", + "solana-inflation", + "solana-instruction", + "solana-keypair", + "solana-message", + "solana-native-token 2.3.0", + "solana-nonce-account", + "solana-offchain-message", + "solana-packet", + "solana-poh-config", + "solana-precompile-error", + "solana-precompiles", + "solana-presigner", + "solana-program", + "solana-program-memory", + "solana-pubkey", + "solana-quic-definitions", + "solana-rent-collector", + "solana-rent-debits", + "solana-reserved-account-keys", + "solana-reward-info", + "solana-sanitize", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-secp256k1-program", + "solana-secp256k1-recover", + "solana-secp256r1-program", + "solana-seed-derivable", + "solana-seed-phrase", + "solana-serde", + "solana-serde-varint", + "solana-short-vec", + "solana-shred-version", + "solana-signature", + "solana-signer", + "solana-system-transaction", + "solana-time-utils", + "solana-transaction", + "solana-transaction-context", + "solana-transaction-error", + "solana-validator-exit", + "thiserror 2.0.18", + "wasm-bindgen", +] + +[[package]] +name = "solana-sdk-ids" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c5d8b9cc68d5c88b062a33e23a6466722467dde0035152d8fb1afbcdf350a5f" +dependencies = [ + "solana-pubkey", +] + +[[package]] +name = "solana-sdk-macro" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "86280da8b99d03560f6ab5aca9de2e38805681df34e0bb8f238e69b29433b9df" +dependencies = [ + "bs58", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "solana-secp256k1-program" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f19833e4bc21558fe9ec61f239553abe7d05224347b57d65c2218aeeb82d6149" +dependencies = [ + "bincode", + "digest 0.10.7", + "libsecp256k1", + "serde", + "serde_derive", + "sha3", + "solana-feature-set", + "solana-instruction", + "solana-precompile-error", + "solana-sdk-ids", + "solana-signature", +] + +[[package]] +name = "solana-secp256k1-recover" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baa3120b6cdaa270f39444f5093a90a7b03d296d362878f7a6991d6de3bbe496" +dependencies = [ + "borsh 1.6.0", + "libsecp256k1", + "solana-define-syscall", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-secp256r1-program" +version = "2.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce0ae46da3071a900f02d367d99b2f3058fe2e90c5062ac50c4f20cfedad8f0f" +dependencies = [ + "bytemuck", + "openssl", + "solana-feature-set", + "solana-instruction", + "solana-precompile-error", + "solana-sdk-ids", +] + +[[package]] +name = "solana-security-txt" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "156bb61a96c605fa124e052d630dba2f6fb57e08c7d15b757e1e958b3ed7b3fe" +dependencies = [ + "hashbrown 0.15.2", +] + +[[package]] +name = "solana-seed-derivable" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3beb82b5adb266c6ea90e5cf3967235644848eac476c5a1f2f9283a143b7c97f" +dependencies = [ + "solana-derivation-path", +] + +[[package]] +name = "solana-seed-phrase" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36187af2324f079f65a675ec22b31c24919cb4ac22c79472e85d819db9bbbc15" +dependencies = [ + "hmac 0.12.1", + "pbkdf2", + "sha2 0.10.9", +] + +[[package]] +name = "solana-serde" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1931484a408af466e14171556a47adaa215953c7f48b24e5f6b0282763818b04" +dependencies = [ + "serde", +] + +[[package]] +name = "solana-serde-varint" +version = "2.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a7e155eba458ecfb0107b98236088c3764a09ddf0201ec29e52a0be40857113" +dependencies = [ + "serde", +] + +[[package]] +name = "solana-serialize-utils" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "817a284b63197d2b27afdba829c5ab34231da4a9b4e763466a003c40ca4f535e" +dependencies = [ + "solana-instruction", + "solana-pubkey", + "solana-sanitize", +] + +[[package]] +name = "solana-sha256-hasher" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5aa3feb32c28765f6aa1ce8f3feac30936f16c5c3f7eb73d63a5b8f6f8ecdc44" +dependencies = [ + "sha2 0.10.9", + "solana-define-syscall", + "solana-hash", +] + +[[package]] +name = "solana-short-vec" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c54c66f19b9766a56fa0057d060de8378676cb64987533fa088861858fc5a69" +dependencies = [ + "serde", +] + +[[package]] +name = "solana-shred-version" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "afd3db0461089d1ad1a78d9ba3f15b563899ca2386351d38428faa5350c60a98" +dependencies = [ + "solana-hard-forks", + "solana-hash", + "solana-sha256-hasher", +] + +[[package]] +name = "solana-signature" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64c8ec8e657aecfc187522fc67495142c12f35e55ddeca8698edbb738b8dbd8c" +dependencies = [ + "ed25519-dalek", + "five8", + "rand 0.8.5", + "serde", + "serde-big-array", + "serde_derive", + "solana-sanitize", +] + +[[package]] +name = "solana-signer" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c41991508a4b02f021c1342ba00bcfa098630b213726ceadc7cb032e051975b" +dependencies = [ + "solana-pubkey", + "solana-signature", + "solana-transaction-error", +] + +[[package]] +name = "solana-slot-hashes" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c8691982114513763e88d04094c9caa0376b867a29577939011331134c301ce" +dependencies = [ + "serde", + "serde_derive", + "solana-hash", + "solana-sdk-ids", + "solana-sysvar-id", +] + +[[package]] +name = "solana-slot-history" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97ccc1b2067ca22754d5283afb2b0126d61eae734fc616d23871b0943b0d935e" +dependencies = [ + "bv", + "serde", + "serde_derive", + "solana-sdk-ids", + "solana-sysvar-id", +] + +[[package]] +name = "solana-stable-layout" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f14f7d02af8f2bc1b5efeeae71bc1c2b7f0f65cd75bcc7d8180f2c762a57f54" +dependencies = [ + "solana-instruction", + "solana-pubkey", +] + +[[package]] +name = "solana-stake-interface" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5269e89fde216b4d7e1d1739cf5303f8398a1ff372a81232abbee80e554a838c" +dependencies = [ + "borsh 0.10.4", + "borsh 1.6.0", + "num-traits", + "serde", + "serde_derive", + "solana-clock", + "solana-cpi", + "solana-decode-error", + "solana-instruction", + "solana-program-error", + "solana-pubkey", + "solana-system-interface", + "solana-sysvar-id", +] + +[[package]] +name = "solana-stake-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "500e9b9d11573f12de91e94f9c4459882cd5ffc692776af49b610d6fcc0b167f" +dependencies = [ + "agave-feature-set", + "bincode", + "log", + "solana-account", + "solana-bincode", + "solana-clock", + "solana-config-program-client", + "solana-genesis-config", + "solana-instruction", + "solana-log-collector", + "solana-native-token 2.3.0", + "solana-packet", + "solana-program-runtime", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-stake-interface", + "solana-sysvar", + "solana-transaction-context", + "solana-type-overrides", + "solana-vote-interface", +] + +[[package]] +name = "solana-svm-callback" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cef9f7d5cfb5d375081a6c8ad712a6f0e055a15890081f845acf55d8254a7a2" +dependencies = [ + "solana-account", + "solana-precompile-error", + "solana-pubkey", +] + +[[package]] +name = "solana-svm-feature-set" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f24b836eb4d74ec255217bdbe0f24f64a07adeac31aca61f334f91cd4a3b1d5" + +[[package]] +name = "solana-svm-transaction" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab717b9539375ebb088872c6c87d1d8832d19f30f154ecc530154d23f60a6f0c" +dependencies = [ + "solana-hash", + "solana-message", + "solana-pubkey", + "solana-sdk-ids", + "solana-signature", + "solana-transaction", +] + +[[package]] +name = "solana-system-interface" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94d7c18cb1a91c6be5f5a8ac9276a1d7c737e39a21beba9ea710ab4b9c63bc90" +dependencies = [ + "js-sys", + "num-traits", + "serde", + "serde_derive", + "solana-decode-error", + "solana-instruction", + "solana-pubkey", + "wasm-bindgen", +] + +[[package]] +name = "solana-system-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23ca36cef39aea7761be58d4108a56a2e27042fb1e913355fdb142a05fc7eab7" +dependencies = [ + "bincode", + "log", + "serde", + "serde_derive", + "solana-account", + "solana-bincode", + "solana-fee-calculator", + "solana-instruction", + "solana-log-collector", + "solana-nonce", + "solana-nonce-account", + "solana-packet", + "solana-program-runtime", + "solana-pubkey", + "solana-sdk-ids", + "solana-system-interface", + "solana-sysvar", + "solana-transaction-context", + "solana-type-overrides", +] + +[[package]] +name = "solana-system-transaction" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5bd98a25e5bcba8b6be8bcbb7b84b24c2a6a8178d7fb0e3077a916855ceba91a" +dependencies = [ + "solana-hash", + "solana-keypair", + "solana-message", + "solana-pubkey", + "solana-signer", + "solana-system-interface", + "solana-transaction", +] + +[[package]] +name = "solana-sysvar" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8c3595f95069f3d90f275bb9bd235a1973c4d059028b0a7f81baca2703815db" +dependencies = [ + "base64 0.22.1", + "bincode", + "bytemuck", + "bytemuck_derive", + "lazy_static", + "serde", + "serde_derive", + "solana-account-info", + "solana-clock", + "solana-define-syscall", + "solana-epoch-rewards", + "solana-epoch-schedule", + "solana-fee-calculator", + "solana-hash", + "solana-instruction", + "solana-instructions-sysvar", + "solana-last-restart-slot", + "solana-program-entrypoint", + "solana-program-error", + "solana-program-memory", + "solana-pubkey", + "solana-rent", + "solana-sanitize", + "solana-sdk-ids", + "solana-sdk-macro", + "solana-slot-hashes", + "solana-slot-history", + "solana-stake-interface", + "solana-sysvar-id", +] + +[[package]] +name = "solana-sysvar-id" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5762b273d3325b047cfda250787f8d796d781746860d5d0a746ee29f3e8812c1" +dependencies = [ + "solana-pubkey", + "solana-sdk-ids", +] + +[[package]] +name = "solana-time-utils" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6af261afb0e8c39252a04d026e3ea9c405342b08c871a2ad8aa5448e068c784c" + +[[package]] +name = "solana-timings" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c49b842dfc53c1bf9007eaa6730296dea93b4fce73f457ce1080af43375c0d6" +dependencies = [ + "eager", + "enum-iterator", + "solana-pubkey", +] + +[[package]] +name = "solana-transaction" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80657d6088f721148f5d889c828ca60c7daeedac9a8679f9ec215e0c42bcbf41" +dependencies = [ + "bincode", + "serde", + "serde_derive", + "solana-bincode", + "solana-feature-set", + "solana-hash", + "solana-instruction", + "solana-keypair", + "solana-message", + "solana-precompiles", + "solana-pubkey", + "solana-sanitize", + "solana-sdk-ids", + "solana-short-vec", + "solana-signature", + "solana-signer", + "solana-system-interface", + "solana-transaction-error", + "wasm-bindgen", +] + +[[package]] +name = "solana-transaction-context" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54a312304361987a85b2ef2293920558e6612876a639dd1309daf6d0d59ef2fe" +dependencies = [ + "bincode", + "serde", + "serde_derive", + "solana-account", + "solana-instruction", + "solana-instructions-sysvar", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", +] + +[[package]] +name = "solana-transaction-error" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "222a9dc8fdb61c6088baab34fc3a8b8473a03a7a5fd404ed8dd502fa79b67cb1" +dependencies = [ + "serde", + "serde_derive", + "solana-instruction", + "solana-sanitize", +] + +[[package]] +name = "solana-transaction-status" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "135f92f4192cc68900c665becf97fc0a6500ae5a67ff347bf2cbc20ecfefa821" +dependencies = [ + "Inflector", + "agave-reserved-account-keys", + "base64 0.22.1", + "bincode", + "borsh 1.6.0", + "bs58", + "log", + "serde", + "serde_derive", + "serde_json", + "solana-account-decoder", + "solana-address-lookup-table-interface", + "solana-clock", + "solana-hash", + "solana-instruction", + "solana-loader-v2-interface", + "solana-loader-v3-interface", + "solana-message", + "solana-program-option", + "solana-pubkey", + "solana-reward-info", + "solana-sdk-ids", + "solana-signature", + "solana-stake-interface", + "solana-system-interface", + "solana-transaction", + "solana-transaction-error", + "solana-transaction-status-client-types", + "solana-vote-interface", + "spl-associated-token-account", + "spl-memo", + "spl-token 8.0.0", + "spl-token-2022 8.0.1", + "spl-token-group-interface 0.6.0", + "spl-token-metadata-interface 0.7.0", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-transaction-status-client-types" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51f1d7c2387c35850848212244d2b225847666cb52d3bd59a5c409d2c300303d" +dependencies = [ + "base64 0.22.1", + "bincode", + "bs58", + "serde", + "serde_derive", + "serde_json", + "solana-account-decoder-client-types", + "solana-commitment-config", + "solana-message", + "solana-reward-info", + "solana-signature", + "solana-transaction", + "solana-transaction-context", + "solana-transaction-error", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-type-overrides" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d80c44761eb398a157d809a04840865c347e1831ae3859b6100c0ee457bc1a" +dependencies = [ + "rand 0.8.5", +] + +[[package]] +name = "solana-validator-exit" +version = "2.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bbf6d7a3c0b28dd5335c52c0e9eae49d0ae489a8f324917faf0ded65a812c1d" + +[[package]] +name = "solana-version" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3324d46c7f7b7f5d34bf7dc71a2883bdc072c7b28ca81d0b2167ecec4cf8da9f" +dependencies = [ + "agave-feature-set", + "rand 0.8.5", + "semver", + "serde", + "serde_derive", + "solana-sanitize", + "solana-serde-varint", +] + +[[package]] +name = "solana-vote-interface" +version = "2.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b80d57478d6599d30acc31cc5ae7f93ec2361a06aefe8ea79bc81739a08af4c3" +dependencies = [ + "bincode", + "num-derive", + "num-traits", + "serde", + "serde_derive", + "solana-clock", + "solana-decode-error", + "solana-hash", + "solana-instruction", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-serde-varint", + "solana-serialize-utils", + "solana-short-vec", + "solana-system-interface", +] + +[[package]] +name = "solana-vote-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "908d0e72c8b83e48762eb3e8c9114497cf4b1d66e506e360c46aba9308e71299" +dependencies = [ + "agave-feature-set", + "bincode", + "log", + "num-derive", + "num-traits", + "serde", + "serde_derive", + "solana-account", + "solana-bincode", + "solana-clock", + "solana-epoch-schedule", + "solana-hash", + "solana-instruction", + "solana-keypair", + "solana-metrics", + "solana-packet", + "solana-program-runtime", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-signer", + "solana-slot-hashes", + "solana-transaction", + "solana-transaction-context", + "solana-vote-interface", + "thiserror 2.0.18", +] + +[[package]] +name = "solana-zk-elgamal-proof-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70cea14481d8efede6b115a2581f27bc7c6fdfba0752c20398456c3ac1245fc4" +dependencies = [ + "agave-feature-set", + "bytemuck", + "num-derive", + "num-traits", + "solana-instruction", + "solana-log-collector", + "solana-program-runtime", + "solana-sdk-ids", + "solana-zk-sdk", +] + +[[package]] +name = "solana-zk-sdk" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97b9fc6ec37d16d0dccff708ed1dd6ea9ba61796700c3bb7c3b401973f10f63b" +dependencies = [ + "aes-gcm-siv", + "base64 0.22.1", + "bincode", + "bytemuck", + "bytemuck_derive", + "curve25519-dalek 4.1.3", + "itertools 0.12.1", + "js-sys", + "merlin", + "num-derive", + "num-traits", + "rand 0.8.5", + "serde", + "serde_derive", + "serde_json", + "sha3", + "solana-derivation-path", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", + "solana-seed-derivable", + "solana-seed-phrase", + "solana-signature", + "solana-signer", + "subtle", + "thiserror 2.0.18", + "wasm-bindgen", + "zeroize", +] + +[[package]] +name = "solana-zk-token-proof-program" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "579752ad6ea2a671995f13c763bf28288c3c895cb857a518cc4ebab93c9a8dde" +dependencies = [ + "agave-feature-set", + "bytemuck", + "num-derive", + "num-traits", + "solana-instruction", + "solana-log-collector", + "solana-program-runtime", + "solana-sdk-ids", + "solana-zk-token-sdk", +] + +[[package]] +name = "solana-zk-token-sdk" +version = "2.3.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5055e5df94abd5badf4f947681c893375bdb6f8f543c05d2a7ab9647a6a9d205" +dependencies = [ + "aes-gcm-siv", + "base64 0.22.1", + "bincode", + "bytemuck", + "bytemuck_derive", + "curve25519-dalek 4.1.3", + "itertools 0.12.1", + "merlin", + "num-derive", + "num-traits", + "rand 0.8.5", + "serde", + "serde_derive", + "serde_json", + "sha3", + "solana-curve25519", + "solana-derivation-path", + "solana-instruction", + "solana-pubkey", + "solana-sdk-ids", + "solana-seed-derivable", + "solana-seed-phrase", + "solana-signature", + "solana-signer", + "subtle", + "thiserror 2.0.18", + "zeroize", +] + +[[package]] +name = "spl-associated-token-account" +version = "7.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae179d4a26b3c7a20c839898e6aed84cb4477adf108a366c95532f058aea041b" +dependencies = [ + "borsh 1.6.0", + "num-derive", + "num-traits", + "solana-program", + "spl-associated-token-account-client", + "spl-token 8.0.0", + "spl-token-2022 8.0.1", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-associated-token-account-client" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f8349dbcbe575f354f9a533a21f272f3eb3808a49e2fdc1c34393b88ba76cb" +dependencies = [ + "solana-instruction", + "solana-pubkey", +] + +[[package]] +name = "spl-discriminator" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7398da23554a31660f17718164e31d31900956054f54f52d5ec1be51cb4f4b3" +dependencies = [ + "bytemuck", + "solana-program-error", + "solana-sha256-hasher", + "spl-discriminator-derive", +] + +[[package]] +name = "spl-discriminator-derive" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9e8418ea6269dcfb01c712f0444d2c75542c04448b480e87de59d2865edc750" +dependencies = [ + "quote", + "spl-discriminator-syn", + "syn 2.0.115", +] + +[[package]] +name = "spl-discriminator-syn" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d1dbc82ab91422345b6df40a79e2b78c7bce1ebb366da323572dd60b7076b67" +dependencies = [ + "proc-macro2", + "quote", + "sha2 0.10.9", + "syn 2.0.115", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-elgamal-registry" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce0f668975d2b0536e8a8fd60e56a05c467f06021dae037f1d0cfed0de2e231d" +dependencies = [ + "bytemuck", + "solana-program", + "solana-zk-sdk", + "spl-pod", + "spl-token-confidential-transfer-proof-extraction 0.2.1", +] + +[[package]] +name = "spl-elgamal-registry" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65edfeed09cd4231e595616aa96022214f9c9d2be02dea62c2b30d5695a6833a" +dependencies = [ + "bytemuck", + "solana-account-info", + "solana-cpi", + "solana-instruction", + "solana-msg", + "solana-program-entrypoint", + "solana-program-error", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-system-interface", + "solana-sysvar", + "solana-zk-sdk", + "spl-pod", + "spl-token-confidential-transfer-proof-extraction 0.3.0", +] + +[[package]] +name = "spl-generic-token" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "741a62a566d97c58d33f9ed32337ceedd4e35109a686e31b1866c5dfa56abddc" +dependencies = [ + "bytemuck", + "solana-pubkey", +] + +[[package]] +name = "spl-memo" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f09647c0974e33366efeb83b8e2daebb329f0420149e74d3a4bd2c08cf9f7cb" +dependencies = [ + "solana-account-info", + "solana-instruction", + "solana-msg", + "solana-program-entrypoint", + "solana-program-error", + "solana-pubkey", +] + +[[package]] +name = "spl-pod" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d994afaf86b779104b4a95ba9ca75b8ced3fdb17ee934e38cb69e72afbe17799" +dependencies = [ + "borsh 1.6.0", + "bytemuck", + "bytemuck_derive", + "num-derive", + "num-traits", + "solana-decode-error", + "solana-msg", + "solana-program-error", + "solana-program-option", + "solana-pubkey", + "solana-zk-sdk", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-program-error" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d39b5186f42b2b50168029d81e58e800b690877ef0b30580d107659250da1d1" +dependencies = [ + "num-derive", + "num-traits", + "solana-program", + "spl-program-error-derive 0.4.1", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-program-error" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cdebc8b42553070b75aa5106f071fef2eb798c64a7ec63375da4b1f058688c6" +dependencies = [ + "num-derive", + "num-traits", + "solana-decode-error", + "solana-msg", + "solana-program-error", + "spl-program-error-derive 0.5.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-program-error-derive" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6d375dd76c517836353e093c2dbb490938ff72821ab568b545fd30ab3256b3e" +dependencies = [ + "proc-macro2", + "quote", + "sha2 0.10.9", + "syn 2.0.115", +] + +[[package]] +name = "spl-program-error-derive" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a2539e259c66910d78593475540e8072f0b10f0f61d7607bbf7593899ed52d0" +dependencies = [ + "proc-macro2", + "quote", + "sha2 0.10.9", + "syn 2.0.115", +] + +[[package]] +name = "spl-tlv-account-resolution" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd99ff1e9ed2ab86e3fd582850d47a739fec1be9f4661cba1782d3a0f26805f3" +dependencies = [ + "bytemuck", + "num-derive", + "num-traits", + "solana-account-info", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "spl-program-error 0.6.0", + "spl-type-length-value 0.7.0", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-tlv-account-resolution" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1408e961215688715d5a1063cbdcf982de225c45f99c82b4f7d7e1dd22b998d7" +dependencies = [ + "bytemuck", + "num-derive", + "num-traits", + "solana-account-info", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "spl-program-error 0.7.0", + "spl-type-length-value 0.8.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token" +version = "7.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed320a6c934128d4f7e54fe00e16b8aeaecf215799d060ae14f93378da6dc834" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "num_enum", + "solana-program", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-token" +version = "8.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053067c6a82c705004f91dae058b11b4780407e9ccd6799dc9e7d0fab5f242da" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "num_enum", + "solana-account-info", + "solana-cpi", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-entrypoint", + "solana-program-error", + "solana-program-memory", + "solana-program-option", + "solana-program-pack", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-sysvar", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-2022" +version = "7.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9048b26b0df0290f929ff91317c83db28b3ef99af2b3493dd35baa146774924c" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "num_enum", + "solana-program", + "solana-security-txt", + "solana-zk-sdk", + "spl-elgamal-registry 0.1.1", + "spl-memo", + "spl-pod", + "spl-token 7.0.0", + "spl-token-confidential-transfer-ciphertext-arithmetic 0.2.1", + "spl-token-confidential-transfer-proof-extraction 0.2.1", + "spl-token-confidential-transfer-proof-generation 0.3.0", + "spl-token-group-interface 0.5.0", + "spl-token-metadata-interface 0.6.0", + "spl-transfer-hook-interface 0.9.0", + "spl-type-length-value 0.7.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-2022" +version = "8.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "31f0dfbb079eebaee55e793e92ca5f433744f4b71ee04880bfd6beefba5973e5" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "num_enum", + "solana-account-info", + "solana-clock", + "solana-cpi", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-native-token 2.3.0", + "solana-program-entrypoint", + "solana-program-error", + "solana-program-memory", + "solana-program-option", + "solana-program-pack", + "solana-pubkey", + "solana-rent", + "solana-sdk-ids", + "solana-security-txt", + "solana-system-interface", + "solana-sysvar", + "solana-zk-sdk", + "spl-elgamal-registry 0.2.0", + "spl-memo", + "spl-pod", + "spl-token 8.0.0", + "spl-token-confidential-transfer-ciphertext-arithmetic 0.3.1", + "spl-token-confidential-transfer-proof-extraction 0.3.0", + "spl-token-confidential-transfer-proof-generation 0.4.1", + "spl-token-group-interface 0.6.0", + "spl-token-metadata-interface 0.7.0", + "spl-transfer-hook-interface 0.10.0", + "spl-type-length-value 0.8.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-2022-interface" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62d7ae2ee6b856f8ddcbdc3b3a9f4d2141582bbe150f93e5298ee97e0251fa04" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "num_enum", + "solana-account-info", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-program-option", + "solana-program-pack", + "solana-pubkey", + "solana-sdk-ids", + "solana-zk-sdk", + "spl-pod", + "spl-token-confidential-transfer-proof-extraction 0.4.1", + "spl-token-confidential-transfer-proof-generation 0.4.1", + "spl-token-group-interface 0.6.0", + "spl-token-metadata-interface 0.7.0", + "spl-type-length-value 0.8.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-confidential-transfer-ciphertext-arithmetic" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "170378693c5516090f6d37ae9bad2b9b6125069be68d9acd4865bbe9fc8499fd" +dependencies = [ + "base64 0.22.1", + "bytemuck", + "solana-curve25519", + "solana-zk-sdk", +] + +[[package]] +name = "spl-token-confidential-transfer-ciphertext-arithmetic" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cddd52bfc0f1c677b41493dafa3f2dbbb4b47cf0990f08905429e19dc8289b35" +dependencies = [ + "base64 0.22.1", + "bytemuck", + "solana-curve25519", + "solana-zk-sdk", +] + +[[package]] +name = "spl-token-confidential-transfer-proof-extraction" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eff2d6a445a147c9d6dd77b8301b1e116c8299601794b558eafa409b342faf96" +dependencies = [ + "bytemuck", + "solana-curve25519", + "solana-program", + "solana-zk-sdk", + "spl-pod", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-confidential-transfer-proof-extraction" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe2629860ff04c17bafa9ba4bed8850a404ecac81074113e1f840dbd0ebb7bd6" +dependencies = [ + "bytemuck", + "solana-account-info", + "solana-curve25519", + "solana-instruction", + "solana-instructions-sysvar", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "solana-sdk-ids", + "solana-zk-sdk", + "spl-pod", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-confidential-transfer-proof-extraction" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "512c85bdbbb4cbcc2038849a9e164c958b16541f252b53ea1a3933191c0a4a1a" +dependencies = [ + "bytemuck", + "solana-account-info", + "solana-curve25519", + "solana-instruction", + "solana-instructions-sysvar", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "solana-sdk-ids", + "solana-zk-sdk", + "spl-pod", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-confidential-transfer-proof-generation" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e3597628b0d2fe94e7900fd17cdb4cfbb31ee35c66f82809d27d86e44b2848b" +dependencies = [ + "curve25519-dalek 4.1.3", + "solana-zk-sdk", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-confidential-transfer-proof-generation" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa27b9174bea869a7ebf31e0be6890bce90b1a4288bc2bbf24bd413f80ae3fde" +dependencies = [ + "curve25519-dalek 4.1.3", + "solana-zk-sdk", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-group-interface" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d595667ed72dbfed8c251708f406d7c2814a3fa6879893b323d56a10bedfc799" +dependencies = [ + "bytemuck", + "num-derive", + "num-traits", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-token-group-interface" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5597b4cd76f85ce7cd206045b7dc22da8c25516573d42d267c8d1fd128db5129" +dependencies = [ + "bytemuck", + "num-derive", + "num-traits", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-token-metadata-interface" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfb9c89dbc877abd735f05547dcf9e6e12c00c11d6d74d8817506cab4c99fdbb" +dependencies = [ + "borsh 1.6.0", + "num-derive", + "num-traits", + "solana-borsh", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "spl-type-length-value 0.7.0", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-token-metadata-interface" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "304d6e06f0de0c13a621464b1fd5d4b1bebf60d15ca71a44d3839958e0da16ee" +dependencies = [ + "borsh 1.6.0", + "num-derive", + "num-traits", + "solana-borsh", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "spl-type-length-value 0.8.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-transfer-hook-interface" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4aa7503d52107c33c88e845e1351565050362c2314036ddf19a36cd25137c043" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "solana-account-info", + "solana-cpi", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "spl-program-error 0.6.0", + "spl-tlv-account-resolution 0.9.0", + "spl-type-length-value 0.7.0", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-transfer-hook-interface" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7e905b849b6aba63bde8c4badac944ebb6c8e6e14817029cbe1bc16829133bd" +dependencies = [ + "arrayref", + "bytemuck", + "num-derive", + "num-traits", + "solana-account-info", + "solana-cpi", + "solana-decode-error", + "solana-instruction", + "solana-msg", + "solana-program-error", + "solana-pubkey", + "spl-discriminator", + "spl-pod", + "spl-program-error 0.7.0", + "spl-tlv-account-resolution 0.10.0", + "spl-type-length-value 0.8.0", + "thiserror 2.0.18", +] + +[[package]] +name = "spl-type-length-value" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba70ef09b13af616a4c987797870122863cba03acc4284f226a4473b043923f9" +dependencies = [ + "bytemuck", + "num-derive", + "num-traits", + "solana-account-info", + "solana-decode-error", + "solana-msg", + "solana-program-error", + "spl-discriminator", + "spl-pod", + "thiserror 1.0.69", +] + +[[package]] +name = "spl-type-length-value" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d417eb548214fa822d93f84444024b4e57c13ed6719d4dcc68eec24fb481e9f5" +dependencies = [ + "bytemuck", + "num-derive", + "num-traits", + "solana-account-info", + "solana-decode-error", + "solana-msg", + "solana-program-error", + "spl-discriminator", + "spl-pod", + "thiserror 2.0.18", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "static_assertions" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.115" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e614ed320ac28113fa64972c4262d5dbc89deacdfd00c34a3e4cea073243c12" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160" + +[[package]] +name = "sync_wrapper" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" +dependencies = [ + "futures-core", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "system-configuration" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" +dependencies = [ + "bitflags 1.3.2", + "core-foundation", + "system-configuration-sys 0.5.0", +] + +[[package]] +name = "system-configuration" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b" +dependencies = [ + "bitflags 2.10.0", + "core-foundation", + "system-configuration-sys 0.6.0", +] + +[[package]] +name = "system-configuration-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "system-configuration-sys" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "tabled" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e39a2ee1fbcd360805a771e1b300f78cc88fec7b8d3e2f71cd37bbf23e725c7d" +dependencies = [ + "papergrid", + "tabled_derive", + "testing_table", +] + +[[package]] +name = "tabled_derive" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ea5d1b13ca6cff1f9231ffd62f15eefd72543dab5e468735f1a456728a02846" +dependencies = [ + "heck 0.5.0", + "proc-macro-error2", + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "tap" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" + +[[package]] +name = "tarpc" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c38a012bed6fb9681d3bf71ffaa4f88f3b4b9ed3198cda6e4c8462d24d4bb80" +dependencies = [ + "anyhow", + "fnv", + "futures", + "humantime", + "opentelemetry", + "pin-project", + "rand 0.8.5", + "serde", + "static_assertions", + "tarpc-plugins", + "thiserror 1.0.69", + "tokio", + "tokio-serde", + "tokio-util 0.6.10", + "tracing", + "tracing-opentelemetry", +] + +[[package]] +name = "tarpc-plugins" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee42b4e559f17bce0385ebf511a7beb67d5cc33c12c96b7f4e9789919d9c10f" +dependencies = [ + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "tempfile" +version = "3.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0136791f7c95b1f6dd99f9cc786b91bb81c3800b639b3478e561ddb7be95e5f1" +dependencies = [ + "fastrand", + "getrandom 0.4.1", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "termcolor" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "testing_table" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f8daae29995a24f65619e19d8d31dea5b389f3d853d8bf297bbf607cd0014cc" +dependencies = [ + "unicode-width", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + +[[package]] +name = "thiserror" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" +dependencies = [ + "thiserror-impl 2.0.18", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "thread_local" +version = "1.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "time" +version = "0.3.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c" +dependencies = [ + "deranged", + "itoa", + "num-conv", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca" + +[[package]] +name = "time-macros" +version = "0.2.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "tinystr" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinyvec" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" + +[[package]] +name = "tokio" +version = "1.49.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86" +dependencies = [ + "bytes", + "libc", + "mio", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2 0.6.2", + "tokio-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "tokio-macros" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "tokio-native-tls" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2" +dependencies = [ + "native-tls", + "tokio", +] + +[[package]] +name = "tokio-rustls" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" +dependencies = [ + "rustls 0.21.12", + "tokio", +] + +[[package]] +name = "tokio-rustls" +version = "0.26.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61" +dependencies = [ + "rustls 0.23.36", + "tokio", +] + +[[package]] +name = "tokio-serde" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "911a61637386b789af998ee23f50aa30d5fd7edcec8d6d3dedae5e5815205466" +dependencies = [ + "bincode", + "bytes", + "educe 0.4.23", + "futures-core", + "futures-sink", + "pin-project", + "serde", + "serde_json", +] + +[[package]] +name = "tokio-util" +version = "0.6.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36943ee01a6d67977dd3f84a5a1d2efeb4ada3a1ae771cadfaa535d9d9fc6507" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "log", + "pin-project-lite", + "slab", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "toml" +version = "0.5.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_datetime" +version = "0.7.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_edit" +version = "0.23.10+spec-1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269" +dependencies = [ + "indexmap 2.13.0", + "toml_datetime", + "toml_parser", + "winnow", +] + +[[package]] +name = "toml_parser" +version = "1.0.8+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0742ff5ff03ea7e67c8ae6c93cac239e0d9784833362da3f9a9c1da8dfefcbdc" +dependencies = [ + "winnow", +] + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper 1.0.2", + "tokio", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-http" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8" +dependencies = [ + "async-compression", + "bitflags 2.10.0", + "bytes", + "futures-core", + "futures-util", + "http 1.4.0", + "http-body 1.0.1", + "http-body-util", + "iri-string", + "pin-project-lite", + "tokio", + "tokio-util 0.7.18", + "tower", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-layer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "log", + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-opentelemetry" +version = "0.17.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fbbe89715c1dbbb790059e2565353978564924ee85017b5fff365c872ff6721f" +dependencies = [ + "once_cell", + "opentelemetry", + "tracing", + "tracing-core", + "tracing-subscriber", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f30143827ddab0d256fd843b7a66d164e9f271cfa0dde49142c5ca0ca291f1e" +dependencies = [ + "sharded-slab", + "thread_local", + "tracing-core", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "typenum" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb" + +[[package]] +name = "unicase" +version = "2.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142" + +[[package]] +name = "unicode-ident" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "537dd038a89878be9b64dd4bd1b260315c1bb94f4d784956b81e27a088d9a09e" + +[[package]] +name = "unicode-segmentation" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" + +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common", + "subtle", +] + +[[package]] +name = "unreachable" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56" +dependencies = [ + "void", +] + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "uriparse" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0200d0fc04d809396c2ad43f3c95da3582a2556eba8d453c1087f4120ee352ff" +dependencies = [ + "fnv", + "lazy_static", +] + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "utf8_iter" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be" + +[[package]] +name = "uuid" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee48d38b119b0cd71fe4141b30f5ba9c7c5d9f4e7a3a8b4a674e4b6ef789976f" +dependencies = [ + "getrandom 0.3.4", + "js-sys", + "serde_core", + "wasm-bindgen", +] + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "void" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" + +[[package]] +name = "want" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" +dependencies = [ + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.9.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.2+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f" +dependencies = [ + "cfg-if", + "futures-util", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 2.0.115", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap 2.13.0", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags 2.10.0", + "hashbrown 0.15.2", + "indexmap 2.13.0", + "semver", +] + +[[package]] +name = "web-sys" +version = "0.3.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "0.25.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1" + +[[package]] +name = "webpki-roots" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22cfaf3c063993ff62e73cb4311efde4db1efb31ab78a3e5c457939ad5cc0bed" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-registry" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720" +dependencies = [ + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.48.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" +dependencies = [ + "windows-targets 0.48.5", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + +[[package]] +name = "windows-sys" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" +dependencies = [ + "windows-targets 0.53.5", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" +dependencies = [ + "windows_aarch64_gnullvm 0.48.5", + "windows_aarch64_msvc 0.48.5", + "windows_i686_gnu 0.48.5", + "windows_i686_msvc 0.48.5", + "windows_x86_64_gnu 0.48.5", + "windows_x86_64_gnullvm 0.48.5", + "windows_x86_64_msvc 0.48.5", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm 0.52.6", + "windows_aarch64_msvc 0.52.6", + "windows_i686_gnu 0.52.6", + "windows_i686_gnullvm 0.52.6", + "windows_i686_msvc 0.52.6", + "windows_x86_64_gnu 0.52.6", + "windows_x86_64_gnullvm 0.52.6", + "windows_x86_64_msvc 0.52.6", +] + +[[package]] +name = "windows-targets" +version = "0.53.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" +dependencies = [ + "windows-link", + "windows_aarch64_gnullvm 0.53.1", + "windows_aarch64_msvc 0.53.1", + "windows_i686_gnu 0.53.1", + "windows_i686_gnullvm 0.53.1", + "windows_i686_msvc 0.53.1", + "windows_x86_64_gnu 0.53.1", + "windows_x86_64_gnullvm 0.53.1", + "windows_x86_64_msvc 0.53.1", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" + +[[package]] +name = "windows_i686_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" + +[[package]] +name = "windows_i686_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_i686_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.48.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.53.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" + +[[package]] +name = "winnow" +version = "0.7.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829" +dependencies = [ + "memchr", +] + +[[package]] +name = "winreg" +version = "0.50.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" +dependencies = [ + "cfg-if", + "windows-sys 0.48.0", +] + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck 0.5.0", + "wit-parser", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck 0.5.0", + "indexmap 2.13.0", + "prettyplease", + "syn 2.0.115", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn 2.0.115", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags 2.10.0", + "indexmap 2.13.0", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap 2.13.0", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "writeable" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" + +[[package]] +name = "wyz" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" +dependencies = [ + "tap", +] + +[[package]] +name = "yoke" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", + "synstructure", +] + +[[package]] +name = "zerocopy" +version = "0.8.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.39" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "zerofrom" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", + "synstructure", +] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "zerotrie" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.115", +] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/privy/FIXES.md b/privy/FIXES.md new file mode 100644 index 0000000..2af06c8 --- /dev/null +++ b/privy/FIXES.md @@ -0,0 +1,527 @@ +# Proposed fixes for `privy/nodejs/src/` + +Analysis of the `add-privy` branch against the Light Protocol SDK internals and load-ata test suite. Each issue includes severity, affected files, root cause, and proposed fix with exact code changes. + +## Issue 1: No handling of >8 cold accounts + +**Severity:** High +**Files:** `load.ts`, `transfer.ts` + +### Root cause + +`createLoadAtaInstructionsFromInterface()` returns instructions for up to 8 compressed accounts per call. The Light Protocol SDK reference implementation (`load-ata.ts:539`) handles this by calling `loadAta` in a loop until it returns `null`. Both `load.ts` and `transfer.ts` call the function once and assume all accounts are consolidated. + +If an owner has 9+ cold compressed accounts, the first call consolidates 8 and the remaining stay cold. In `transfer.ts`, this means the transfer may fail with insufficient balance. + +### Proposed fix — load.ts + +Replace single-call pattern with a loop. Each iteration builds, signs, and sends a transaction for up to 8 accounts. Loop continues until no instructions are returned. + +```typescript +// BEFORE (load.ts lines 34-67) +const ixs = await createLoadAtaInstructionsFromInterface( + connection, + ownerPubkey, + ataInfo, + undefined, + true, +); + +if (ixs.length === 0) { + console.log('Nothing to load'); + return null; +} + +const transaction = new Transaction(); +transaction.add(...ixs); +// ... sign and send single transaction +``` + +```typescript +// AFTER +const signatures: string[] = []; + +while (true) { + // Re-query each iteration — previous tx changed on-chain state + const ataInfo = await getAtaInterface(connection, lightTokenAta, ownerPubkey, mintPubkey); + + const ixs = await createLoadAtaInstructionsFromInterface( + connection, + ownerPubkey, + ataInfo, + undefined, + true, + ); + + if (ixs.length === 0) break; + + const transaction = new Transaction(); + transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })); + transaction.add(...ixs); + + const { blockhash } = await connection.getLatestBlockhash(); + transaction.recentBlockhash = blockhash; + transaction.feePayer = ownerPubkey; + + // Sign with Privy + const signResult = await privy.wallets().solana().signTransaction( + process.env.TREASURY_WALLET_ID!, + { + transaction: transaction.serialize({ requireAllSignatures: false }), + authorization_context: { + authorization_private_keys: [process.env.TREASURY_AUTHORIZATION_KEY!], + }, + }, + ); + const signedTx = (signResult as any).signed_transaction; + if (!signedTx) { + throw new Error('Privy returned invalid response: ' + JSON.stringify(signResult)); + } + + const signature = await connection.sendRawTransaction( + Buffer.from(signedTx, 'base64'), + { skipPreflight: false, preflightCommitment: 'confirmed' }, + ); + await connection.confirmTransaction(signature, 'confirmed'); + signatures.push(signature); +} + +if (signatures.length === 0) { + console.log('Nothing to load'); + return null; +} + +return signatures; +``` + +**Key changes:** +- Move `getAtaInterface()` call inside the loop (on-chain state changes after each tx) +- Add `ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })` (matches SDK reference) +- Return `string[]` instead of `string | null` +- Loop exits when `ixs.length === 0` + +**Import additions:** +```typescript +import { ComputeBudgetProgram } from '@solana/web3.js'; +``` + +### Proposed fix — transfer.ts + +Transfer is more constrained — the load + transfer must happen atomically in one transaction. The approach: loop to consolidate all cold accounts first (separate transactions), then do load-remaining + transfer in the final transaction. + +```typescript +// BEFORE (transfer.ts lines 55-65) +try { + const ataInfo = await getAtaInterface(connection, sourceAta, fromPubkey, mintPubkey); + const loadIxs = await createLoadAtaInstructionsFromInterface( + connection, fromPubkey, ataInfo, undefined, true, + ); + if (loadIxs.length > 0) transaction.add(...loadIxs); +} catch { + // Associated token account doesn't exist yet +} +``` + +```typescript +// AFTER + +// Phase 1: Consolidate all cold accounts (may require multiple transactions) +let hasMoreToLoad = true; +while (hasMoreToLoad) { + let ataInfo; + try { + ataInfo = await getAtaInterface(connection, sourceAta, fromPubkey, mintPubkey); + } catch (e) { + if (e instanceof TokenAccountNotFoundError) break; + throw e; + } + + const loadIxs = await createLoadAtaInstructionsFromInterface( + connection, fromPubkey, ataInfo, undefined, true, + ); + + if (loadIxs.length === 0) { + hasMoreToLoad = false; + break; + } + + // Check if there are likely more accounts after this batch + // If we got a full batch (8 accounts), there may be more + const coldCount = ataInfo.parsed?.compressedAccounts?.length ?? 0; + if (coldCount <= 8) { + // Last batch — include these in the final transaction with the transfer + transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })); + transaction.add(...loadIxs); + hasMoreToLoad = false; + } else { + // More batches needed — send this one separately + const loadTx = new Transaction(); + loadTx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })); + loadTx.add(...loadIxs); + + const { blockhash } = await connection.getLatestBlockhash(); + loadTx.recentBlockhash = blockhash; + loadTx.feePayer = fromPubkey; + + // Sign and send load transaction + const signResult = await privy.wallets().solana().signTransaction( + process.env.TREASURY_WALLET_ID!, + { + transaction: loadTx.serialize({ requireAllSignatures: false }), + authorization_context: { + authorization_private_keys: [process.env.TREASURY_AUTHORIZATION_KEY!], + }, + }, + ); + const signedTx = (signResult as any).signed_transaction; + if (!signedTx) throw new Error('Privy returned invalid response'); + const sig = await connection.sendRawTransaction(Buffer.from(signedTx, 'base64'), { + skipPreflight: false, preflightCommitment: 'confirmed', + }); + await connection.confirmTransaction(sig, 'confirmed'); + } +} +``` + +**Note:** This is the most complex fix. An alternative simpler approach: always consolidate all cold accounts first (separate transactions), then do a transfer-only transaction. This avoids combining load + transfer in one tx but requires an extra transaction when cold accounts exist. Simpler to implement and reason about. + +**Simpler alternative:** + +```typescript +// Phase 1: Consolidate all cold accounts first +try { + while (true) { + const ataInfo = await getAtaInterface(connection, sourceAta, fromPubkey, mintPubkey); + const loadIxs = await createLoadAtaInstructionsFromInterface( + connection, fromPubkey, ataInfo, undefined, true, + ); + if (loadIxs.length === 0) break; + + const loadTx = new Transaction(); + loadTx.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })); + loadTx.add(...loadIxs); + + const { blockhash } = await connection.getLatestBlockhash(); + loadTx.recentBlockhash = blockhash; + loadTx.feePayer = fromPubkey; + + // Sign and send (Privy signing code) + // ... same pattern as existing + } +} catch (e) { + if (!(e instanceof TokenAccountNotFoundError)) throw e; +} + +// Phase 2: Transfer (all funds now in light-token ATA) +transaction.add(createTransferInterfaceInstruction(sourceAta, destAta, fromPubkey, tokenAmount)); +``` + +**Recommendation:** Use the simpler alternative. It separates concerns cleanly: consolidate first, then transfer. + +--- + +## Issue 2: Silent error swallowing in transfer.ts + +**Severity:** Medium +**File:** `transfer.ts` + +### Root cause + +Bare `catch {}` at line 63 catches all errors, including network timeouts, RPC failures, and invalid addresses. Only `TokenAccountNotFoundError` (account doesn't exist yet) is expected. + +### Proposed fix + +```typescript +// BEFORE (transfer.ts lines 55-65) +try { + const ataInfo = await getAtaInterface(connection, sourceAta, fromPubkey, mintPubkey); + const loadIxs = await createLoadAtaInstructionsFromInterface( + connection, fromPubkey, ataInfo, undefined, true, + ); + if (loadIxs.length > 0) transaction.add(...loadIxs); +} catch { + // Associated token account doesn't exist yet +} +``` + +```typescript +// AFTER +import { TokenAccountNotFoundError } from '@solana/spl-token'; + +try { + const ataInfo = await getAtaInterface(connection, sourceAta, fromPubkey, mintPubkey); + const loadIxs = await createLoadAtaInstructionsFromInterface( + connection, fromPubkey, ataInfo, undefined, true, + ); + if (loadIxs.length > 0) { + transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })); + transaction.add(...loadIxs); + } +} catch (e) { + if (!(e instanceof TokenAccountNotFoundError)) throw e; + // Light-token ATA doesn't exist — transfer from hot balance only +} +``` + +**Import addition:** +```typescript +import { TokenAccountNotFoundError } from '@solana/spl-token'; +``` + +**Reference:** `unwrap.ts` already uses this pattern with `TokenAccountNotFoundError` for ATA existence checks. + +**Note:** If Issue 1 (loop) is also applied, this catch block becomes part of the loop structure shown above. The fixes compose — apply Issue 2's error specificity within Issue 1's loop. + +--- + +## Issue 3: Hardcoded decimals in balances.ts + +**Severity:** Medium +**File:** `balances.ts` + +### Root cause + +Line 51: `const decimals = 9;` — hardcoded. Returns wrong UI amounts for any mint with non-9 decimals (e.g., USDC has 6). + +### Proposed fix + +Query mint decimals from the token program. The `getMint()` function from `@solana/spl-token` returns a `Mint` object with a `.decimals` field. Since this mint could be SPL or T22, query both programs and use whichever succeeds. + +```typescript +// BEFORE (balances.ts line 51) +const decimals = 9; +``` + +```typescript +// AFTER +import { getMint } from '@solana/spl-token'; + +let decimals = 9; // fallback +try { + const mintInfo = await getMint(rpc, mint, undefined, TOKEN_PROGRAM_ID); + decimals = mintInfo.decimals; +} catch { + try { + const mintInfo = await getMint(rpc, mint, undefined, TOKEN_2022_PROGRAM_ID); + decimals = mintInfo.decimals; + } catch { + // Light-only mint — no SPL/T22 program. Default to 9. + // Light mints don't have on-chain decimals metadata via getMint. + } +} +``` + +**Import addition:** +```typescript +import { TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, getMint } from '@solana/spl-token'; +``` + +(`TOKEN_PROGRAM_ID` and `TOKEN_2022_PROGRAM_ID` are already imported.) + +**Alternative:** Accept `decimals` as a function parameter with default 9: + +```typescript +export async function getBalances( + ownerAddress: string, + mintAddress?: string, + decimals: number = 9, // caller can override +): Promise { +``` + +This is simpler and avoids the extra RPC call. The caller knows the mint's decimals. Both approaches are valid — the `getMint` approach is self-contained, the parameter approach is simpler. + +**Recommendation:** Use the `getMint` approach. The function is already making multiple RPC calls; one more is negligible, and it eliminates a class of caller errors. + +--- + +## Issue 4: Missing compute budget in transfer.ts + +**Severity:** Medium +**File:** `transfer.ts` + +### Root cause + +`wrap.ts` and `unwrap.ts` both set `ComputeBudgetProgram.setComputeUnitLimit({ units: 200_000 })`. `transfer.ts` omits this despite including load instructions that decompress compressed accounts — an operation the SDK reference allocates 500,000 CU for. + +Without explicit CU allocation, the transaction uses the default 200,000 CU. A load + transfer combination can exceed this, causing the transaction to fail with `ComputeBudgetExceeded`. + +### Proposed fix + +This fix is included in the Issue 1 and Issue 2 code above. Add compute budget when load instructions are present: + +```typescript +// BEFORE — no compute budget set +transaction.add(...loadIxs); + +// AFTER — set 500k CU when loading +if (loadIxs.length > 0) { + transaction.add(ComputeBudgetProgram.setComputeUnitLimit({ units: 500_000 })); + transaction.add(...loadIxs); +} +``` + +**Import addition:** +```typescript +import { PublicKey, Transaction, ComputeBudgetProgram } from '@solana/web3.js'; +``` + +(`ComputeBudgetProgram` added to existing import.) + +**Reference:** Light Protocol SDK uses 500,000 CU in `load-ata.ts:539`. The privy branch's `wrap.ts` and `unwrap.ts` use 200,000 — this is sufficient for wrap/unwrap but not for decompression + wrap + transfer. + +--- + +## Issue 5: Amount type inconsistency in transfer.ts + +**Severity:** Low-medium +**File:** `transfer.ts` + +### Root cause + +Line 35: `const tokenAmount = Math.floor(amount * Math.pow(10, decimals));` + +This produces a `number`. JavaScript `number` is IEEE 754 double-precision, which loses integer precision above 2^53 (9,007,199,254,740,992). For a 9-decimal token, this means amounts above ~9,007,199.254 tokens lose precision. + +`wrap.ts` and `unwrap.ts` correctly use `BigInt`: +```typescript +const tokenAmount = BigInt(Math.floor(amount * Math.pow(10, decimals))); +``` + +### Proposed fix + +```typescript +// BEFORE (transfer.ts line 35) +const tokenAmount = Math.floor(amount * Math.pow(10, decimals)); + +// AFTER +const tokenAmount = BigInt(Math.floor(amount * Math.pow(10, decimals))); +``` + +Also update the `createTransferInterfaceInstruction` call if it expects `bigint`: + +```typescript +// BEFORE (transfer.ts line 68) +transaction.add(createTransferInterfaceInstruction(sourceAta, destAta, fromPubkey, tokenAmount)); + +// AFTER — no change needed if the function accepts both number and bigint +// Verify the function signature accepts bigint +``` + +**Note:** Check whether `createTransferInterfaceInstruction` accepts `number | bigint` or only `number`. If it only accepts `number`, the `BigInt` conversion is unnecessary at this call site, but the inconsistency with wrap/unwrap should still be resolved for the public API (`amount` parameter type). + +--- + +## Issue 6: Privy response type assertion + +**Severity:** Low +**Files:** `load.ts`, `transfer.ts`, `wrap.ts`, `unwrap.ts` + +### Root cause + +All four files use: +```typescript +const signedTx = (signResult as any).signed_transaction; +``` + +The `as any` cast bypasses TypeScript's type system. If `@privy-io/node` changes the response shape (likely — it's `0.1.0-alpha.2`), this silently returns `undefined`, and the `if (!signedTx)` check throws a generic error. + +### Proposed fix + +Extract a shared helper in `config.ts`: + +```typescript +// config.ts — add at bottom + +export async function signWithPrivy( + privy: PrivyClient, + walletId: string, + transaction: Transaction, + authorizationKey: string, +): Promise { + const signResult = await privy.wallets().solana().signTransaction(walletId, { + transaction: transaction.serialize({ requireAllSignatures: false }), + authorization_context: { + authorization_private_keys: [authorizationKey], + }, + }); + + // Type assertion — @privy-io/node@0.1.0-alpha.2 doesn't export response types + // TODO: Replace with typed response when Privy SDK stabilizes + const signedTx = (signResult as Record).signed_transaction; + if (typeof signedTx !== 'string') { + throw new Error( + `Privy signTransaction returned unexpected shape. ` + + `Expected { signed_transaction: string }, got: ${JSON.stringify(signResult)}`, + ); + } + + return Buffer.from(signedTx, 'base64'); +} +``` + +Then in each file, replace the duplicated signing block: + +```typescript +// BEFORE (repeated in load.ts, transfer.ts, wrap.ts, unwrap.ts) +const signResult = await privy.wallets().solana().signTransaction(process.env.TREASURY_WALLET_ID!, { + transaction: transaction.serialize({requireAllSignatures: false}), + authorization_context: { + authorization_private_keys: [process.env.TREASURY_AUTHORIZATION_KEY!] + } +}); +const signedTx = (signResult as any).signed_transaction; +if (!signedTx) { + throw new Error('Privy returned invalid response: ' + JSON.stringify(signResult)); +} +const signedTransaction = Buffer.from(signedTx, 'base64'); + +// AFTER +import { signWithPrivy, TREASURY_WALLET_ID, TREASURY_AUTHORIZATION_KEY } from './config.js'; + +const signedTransaction = await signWithPrivy( + privy, TREASURY_WALLET_ID, transaction, TREASURY_AUTHORIZATION_KEY, +); +``` + +**Benefits:** +- Single place to update when Privy SDK changes +- `Record` instead of `any` — slightly safer +- `typeof` check instead of truthiness check — catches `0`, `false`, etc. +- Better error message with expected vs actual shape +- Removes ~10 lines of duplicated code per file + +**Recommendation:** Apply this even though the SDK is alpha. The deduplication alone justifies it — 4 copies of the same signing code is a maintenance burden. + +--- + +## Summary + +| # | Issue | Severity | File(s) | Type | +|---|-------|----------|---------|------| +| 1 | No >8 cold account loop | High | `load.ts`, `transfer.ts` | Architectural | +| 2 | Silent catch-all | Medium | `transfer.ts` | Error handling | +| 3 | Hardcoded decimals | Medium | `balances.ts` | Correctness | +| 4 | Missing compute budget | Medium | `transfer.ts` | Reliability | +| 5 | Number vs BigInt | Low-medium | `transfer.ts` | Type safety | +| 6 | Privy `as any` cast | Low | All 4 action files + `config.ts` | Maintainability | + +### Dependency order + +Issues 1, 2, and 4 overlap in `transfer.ts`. Apply them together: + +1. **Issue 6** first — extract `signWithPrivy` helper to `config.ts` (reduces diff noise for other fixes) +2. **Issues 1 + 2 + 4** together in `transfer.ts` (loop + specific errors + compute budget) +3. **Issue 1** in `load.ts` (loop + compute budget, uses `signWithPrivy` from step 1) +4. **Issue 3** in `balances.ts` (independent) +5. **Issue 5** in `transfer.ts` (one-line change, apply last) + +### Files modified + +| File | Issues | +|------|--------| +| `privy/nodejs/src/config.ts` | #6 (add `signWithPrivy` helper) | +| `privy/nodejs/src/load.ts` | #1, #6 | +| `privy/nodejs/src/transfer.ts` | #1, #2, #4, #5, #6 | +| `privy/nodejs/src/balances.ts` | #3 | +| `privy/nodejs/src/wrap.ts` | #6 | +| `privy/nodejs/src/unwrap.ts` | #6 | diff --git a/programs/anchor/Cargo.lock b/programs/anchor/Cargo.lock index 9c661ad..3cc34de 100644 --- a/programs/anchor/Cargo.lock +++ b/programs/anchor/Cargo.lock @@ -1293,12 +1293,12 @@ dependencies = [ [[package]] name = "deranged" -version = "0.5.5" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587" +checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e" dependencies = [ "powerfmt", - "serde_core", + "serde", ] [[package]] @@ -3628,9 +3628,9 @@ dependencies = [ [[package]] name = "num-conv" -version = "0.2.0" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050" +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" [[package]] name = "num-derive" @@ -8079,30 +8079,30 @@ dependencies = [ [[package]] name = "time" -version = "0.3.46" +version = "0.3.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9da98b7d9b7dad93488a84b8248efc35352b0b2657397d4167e7ad67e5d535e5" +checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40" dependencies = [ "deranged", "itoa", "num-conv", "powerfmt", - "serde_core", + "serde", "time-core", "time-macros", ] [[package]] name = "time-core" -version = "0.1.8" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca" +checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c" [[package]] name = "time-macros" -version = "0.2.26" +version = "0.2.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78cc610bac2dcee56805c99642447d4c5dbde4d01f752ffea0199aee1f601dc4" +checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49" dependencies = [ "num-conv", "time-core", diff --git a/typescript-client/package.json b/typescript-client/package.json index 8397750..33779bb 100644 --- a/typescript-client/package.json +++ b/typescript-client/package.json @@ -4,8 +4,9 @@ "type": "module", "description": "Working examples for light-token operations on Solana devnet", "dependencies": { - "@lightprotocol/compressed-token": "beta", - "@lightprotocol/stateless.js": "beta", + "@lightprotocol/compressed-token": "file:../../light-protocol/js/compressed-token", + "@lightprotocol/stateless.js": "file:../../light-protocol/js/stateless.js", + "@solana/spl-token": "^0.4.14", "@solana/web3.js": "^1.98.0", "dotenv": "^16.0.0" }, @@ -42,6 +43,12 @@ "load-ata:instruction": "tsx instructions/load-ata.ts", "delegate:approve": "tsx actions/delegate-approve.ts", "delegate:revoke": "tsx actions/delegate-revoke.ts", - "merge-accounts": "tsx actions/merge-token-accounts.ts" + "merge-accounts": "tsx actions/merge-token-accounts.ts", + "test:load-ata": "npm run test:load-ata:cold && npm run test:load-ata:spl && npm run test:load-ata:t22 && npm run test:load-ata:transfer && npm run test:load-ata:idempotency", + "test:load-ata:cold": "tsx tests/load-ata/cold-only.ts", + "test:load-ata:spl": "tsx tests/load-ata/spl-sources.ts", + "test:load-ata:t22": "tsx tests/load-ata/t22-sources.ts", + "test:load-ata:transfer": "tsx tests/load-ata/load-and-transfer.ts", + "test:load-ata:idempotency": "tsx tests/load-ata/idempotency.ts" } } diff --git a/typescript-client/tests/load-ata/E2E-PLAN.md b/typescript-client/tests/load-ata/E2E-PLAN.md deleted file mode 100644 index 3bcdb77..0000000 --- a/typescript-client/tests/load-ata/E2E-PLAN.md +++ /dev/null @@ -1,82 +0,0 @@ -# E2E: Verify loadAta multi-account fix - -## Context - -The `sources.find` → `sources.filter` fix for `loadAta` is merged into `light-protocol` main. The examples project (`package.json`) links locally to `../../light-protocol/js/compressed-token` and `../../light-protocol/js/stateless.js`. - -Because `tsx` resolves raw `.ts` source from `file:` links (bypassing rollup's `__BUILD_VERSION__` replacement), all test commands need `LIGHT_PROTOCOL_VERSION=V2`. - -## Steps - -```yaml -tasks: - - id: 1 - name: Rebuild SDK packages with V2 - commands: - - cd ~/Workspace/light-protocol/js/stateless.js && pnpm run build - - cd ~/Workspace/light-protocol/js/compressed-token && LIGHT_PROTOCOL_VERSION=V2 pnpm run build - why: Ensure dist/ reflects latest main + fix - - - id: 2 - name: Install deps in examples project - command: cd ~/Workspace/examples-light-token/typescript-client && npm install - depends_on: [1] - - - id: 3 - name: Run cold-only tests - command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:cold - depends_on: [2] - expect: All 9 scenarios pass (A1-A9) - - - id: 4 - name: Run SPL source tests - command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:spl - depends_on: [2] - expect: All 7 scenarios pass (B1-B7) - - - id: 5 - name: Run T22 source tests - command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:t22 - depends_on: [2] - expect: All 5 scenarios pass (C1-C5) - - - id: 6 - name: Run load+transfer tests - command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:transfer - depends_on: [2] - expect: All 4 scenarios pass (D1-D4) - - - id: 7 - name: Run idempotency tests - command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata:idempotency - depends_on: [2] - expect: All 3 scenarios pass (E1-E3) - - - id: 8 - name: Full suite (confirms sequential pass) - command: LIGHT_PROTOCOL_VERSION=V2 npm run test:load-ata - depends_on: [3, 4, 5, 6, 7] - expect: All 28 scenarios pass end-to-end -``` - -## Prerequisites - -- Local test validator running with Light programs loaded -- Solana CLI configured for localnet (`solana config set -ul`) -- Payer keypair at `~/.config/solana/id.json` with SOL balance - -## Permissions needed for auto mode - -| Permission | Commands | Why | -|---|---|---| -| Build SDK | `pnpm run build` in light-protocol/js/* | Rebuild dist from source | -| Install deps | `npm install` in examples project | Link local packages | -| Run tests | `npm run test:load-ata*` with env var | Execute test scripts via tsx | - -All commands are local, read-only on chain (mints + transfers to localnet only), and reversible. - -## If tests fail - -- **V2 error persists**: tsx still hitting raw source. Try `rm -rf node_modules && npm install` -- **Indexer timeout**: Validator may need restart — `light test-validator` in separate terminal -- **Balance mismatch**: Check `coldBalance` computation in load-ata.ts line ~414 diff --git a/typescript-client/tests/load-ata/README.md b/typescript-client/tests/load-ata/README.md deleted file mode 100644 index 9efb6c3..0000000 --- a/typescript-client/tests/load-ata/README.md +++ /dev/null @@ -1,147 +0,0 @@ -# loadAta edge case tests - -28 scenarios testing `loadAta` across all combinations of cold (compressed) accounts, Light ATA state, and SPL/T22 ATAs. - -## Imports: standard vs unified - -The SDK exports `loadAta` from two entry points: - -| Entry point | Import path | Wraps SPL/T22 ATA | -|---|---|---| -| Standard | `@lightprotocol/compressed-token` | No — cold accounts only | -| Unified | `@lightprotocol/compressed-token/unified` | Yes — wraps SPL/T22 ATA balance into Light ATA | - -Tests that involve SPL or T22 wrapping (`spl-sources.ts`, `t22-sources.ts`, `load-and-transfer.ts`, `idempotency.ts`) import from the **unified** entry point. `cold-only.ts` uses the standard import since no wrapping is needed. - -The unified `loadAta` sets `wrap=true` internally. For cold-only scenarios this is a no-op (no SPL/T22 ATA exists to wrap), so unified works for all cases. The standard version never wraps. - -## Account limit - -Each `loadAta` call decompresses up to **8 compressed accounts** per instruction. If an owner has more than 8 cold accounts, call `loadAta` repeatedly until it returns `null`. - -## Run - -Requires a running local validator: - -```bash -light test-validator -``` - -Run all scenarios: - -```bash -npm run test:load-ata -``` - -Run individually: - -```bash -npm run test:load-ata:cold -npm run test:load-ata:spl -npm run test:load-ata:t22 -npm run test:load-ata:transfer -npm run test:load-ata:idempotency -``` - -## Scenarios - -Each scenario uses a fresh mint and owner keypair for isolation. Cold accounts hold 100 tokens each. - -### Cold only — Light mint (`cold-only.ts`) - -Tests `loadAta` with compressed accounts only (no SPL/T22 involvement). - -| # | Cold | Light ATA | Expected result | -|---|------|-----------|-----------------| -| A1 | 1 | none | Creates ATA, loads 1. Balance = 100 | -| A2 | 2 | none | Creates ATA, loads 2. Balance = 200 | -| A3 | 4 | none | Creates ATA, loads 4. Balance = 400 | -| A4 | 8 | none | Creates ATA, loads 8 (max). Balance = 800 | -| A5 | 1 | exists, empty | Loads 1. Balance = 100 | -| A6 | 4 | exists, 500 | Loads 4. Balance = 900 | -| A7 | 8 | exists, 500 | Loads 8. Balance = 1300 | -| A8 | 0 | none | Returns `null`. No ATA created | -| A9 | 0 | exists, 500 | Returns `null`. Balance unchanged at 500 | - -### SPL sources (`spl-sources.ts`) - -Tests `loadAta` with an SPL mint. `loadAta` wraps SPL ATA balance into the Light ATA automatically. - -| # | Cold | SPL ATA | Light ATA | Expected result | -|---|------|---------|-----------|-----------------| -| B1 | 0 | 1000 | none | Creates ATA, wraps SPL. Balance = 1000 | -| B2 | 1 | 1000 | none | Creates ATA, loads 1 + wraps. Balance = 1100 | -| B3 | 4 | 1000 | none | Creates ATA, loads 4 + wraps. Balance = 1400 | -| B4 | 8 | 1000 | none | Creates ATA, loads 8 + wraps. Balance = 1800 | -| B5 | 4 | 1000 | exists, 500 | Loads 4 + wraps. Balance = 1900 | -| B6 | 4 | 0 | none | Creates ATA, loads cold only. Balance = 400 | -| B7 | 0 | 0 | none | Returns `null` | - -### T22 sources (`t22-sources.ts`) - -Tests `loadAta` with a Token-2022 mint. Same wrapping behavior as SPL. - -| # | Cold | T22 ATA | Light ATA | Expected result | -|---|------|---------|-----------|-----------------| -| C1 | 0 | 1000 | none | Creates ATA, wraps T22. Balance = 1000 | -| C2 | 1 | 1000 | none | Creates ATA, loads 1 + wraps. Balance = 1100 | -| C3 | 4 | 1000 | none | Creates ATA, loads 4 + wraps. Balance = 1400 | -| C4 | 8 | 1000 | exists, 500 | Loads 8 + wraps. Balance = 2300 | -| C5 | 4 | 0 | none | Creates ATA, loads cold only. Balance = 400 | - -### Load + transfer (`load-and-transfer.ts`) - -Tests composing `createLoadAtaInstructions` with `createTransferInterfaceInstruction` in a single transaction. - -| # | Sources | Mint type | Expected result | -|---|---------|-----------|-----------------| -| D1 | 1 cold | Light | Load + transfer 50 in 1 tx | -| D2 | 4 cold | Light | Load + transfer 50 in 1 tx | -| D3 | 2 cold + 1000 SPL ATA | SPL | Load + wrap + transfer 50 in 1 tx | -| D4 | 2 cold + 1000 T22 ATA | T22 | Load + wrap + transfer 50 in 1 tx | - -### Idempotency (`idempotency.ts`) - -Tests repeated `loadAta` calls on the same ATA. - -| # | Scenario | Expected result | -|---|----------|-----------------| -| E1 | Load 2 cold, then load again | Second call returns `null` | -| E2 | Load 2 cold, mint 2 more cold, load again | Second call loads the 2 new ones | -| E3 | Load 1 cold + 1000 SPL, then load again | Second call returns `null` | - -## Setup (`setup.ts`) - -Shared utilities used across all test files. Connects to localnet RPC and reads the payer keypair from `~/.config/solana/id.json`. - -### Mint creators - -| Function | Creates | -|----------|---------| -| `createLightMint()` | Light mint (no token program) | -| `createSplMint()` | SPL mint + Light interface PDA | -| `createT22Mint()` | T22 mint + Light interface PDA | - -### Account creators - -| Function | Does | -|----------|------| -| `createMultipleCompressed(mint, owner, count, amountEach)` | Calls `mintToCompressed` N times to create N cold accounts | -| `createLightAtaWithBalance(mint, owner, amount?)` | Creates Light ATA, optionally mints tokens to it | -| `getSplAtaWithBalance(mint, owner, amount)` | Creates SPL ATA via `@solana/spl-token`, mints tokens to it | -| `getT22AtaWithBalance(mint, owner, amount)` | Creates T22 ATA via `@solana/spl-token`, mints tokens to it | - -### Balance readers - -| Function | Returns | -|----------|---------| -| `getCompressedCount(owner, mint)` | Number of compressed accounts for owner + mint | -| `getLightAtaBalance(ata, owner, mint)` | Light ATA token balance (0 if account doesn't exist) | -| `getSplAtaBalance(ata, programId?)` | SPL/T22 ATA balance (0 if account doesn't exist) | - -### Assertions - -| Function | Does | -|----------|------| -| `assert(condition, msg)` | Throws on failure | -| `logScenario(name, expected, actual)` | Prints `[PASS]` or `[FAIL]` with values, throws on mismatch | diff --git a/typescript-client/tests/load-ata/cold-only.ts b/typescript-client/tests/load-ata/cold-only.ts deleted file mode 100644 index 6f01755..0000000 --- a/typescript-client/tests/load-ata/cold-only.ts +++ /dev/null @@ -1,179 +0,0 @@ -import "dotenv/config"; -import { Keypair } from "@solana/web3.js"; -import { loadAta } from "@lightprotocol/compressed-token"; -import { - rpc, - payer, - createMultipleCompressed, - createSplMint, - createLightAtaWithBalance, - waitForCompressedCount, - getLightAtaBalance, - getAssociatedTokenAddressInterface, - assert, - logScenario, -} from "./setup.js"; - -const AMOUNT_EACH = 100n; - -(async function () { - console.log("\n=== Cold-Only Scenarios (SPL Mint) ===\n"); - - // ── Setup ────────────────────────────────────────────── - // Create all mints, owners, and compressed accounts upfront. - // By the time setup completes, the indexer has had time to - // reflect all state — matching real-world usage where - // accounts exist well before loadAta is called. - - console.log(" Setting up scenarios...\n"); - - // A1: 1 cold, no ATA - const a1Mint = await createSplMint(); - const a1Owner = Keypair.generate(); - await createMultipleCompressed(a1Mint, a1Owner.publicKey, 1, AMOUNT_EACH); - - // A2: 2 cold, no ATA - const a2Mint = await createSplMint(); - const a2Owner = Keypair.generate(); - await createMultipleCompressed(a2Mint, a2Owner.publicKey, 2, AMOUNT_EACH); - - // A3: 4 cold, no ATA - const a3Mint = await createSplMint(); - const a3Owner = Keypair.generate(); - await createMultipleCompressed(a3Mint, a3Owner.publicKey, 4, AMOUNT_EACH); - - // A4: 8 cold, no ATA - const a4Mint = await createSplMint(); - const a4Owner = Keypair.generate(); - await createMultipleCompressed(a4Mint, a4Owner.publicKey, 8, AMOUNT_EACH); - - // A5: 1 cold, ATA exists (empty) - const a5Mint = await createSplMint(); - const a5Owner = Keypair.generate(); - await createLightAtaWithBalance(a5Mint, a5Owner); - await createMultipleCompressed(a5Mint, a5Owner.publicKey, 1, AMOUNT_EACH); - - // A6: 4 cold, ATA exists with 500 - const a6Mint = await createSplMint(); - const a6Owner = Keypair.generate(); - await createLightAtaWithBalance(a6Mint, a6Owner, 500n); - await createMultipleCompressed(a6Mint, a6Owner.publicKey, 4, AMOUNT_EACH); - - // A7: 8 cold, ATA exists with 500 - const a7Mint = await createSplMint(); - const a7Owner = Keypair.generate(); - await createLightAtaWithBalance(a7Mint, a7Owner, 500n); - await createMultipleCompressed(a7Mint, a7Owner.publicKey, 8, AMOUNT_EACH); - - // A8: 0 cold, no ATA - const a8Mint = await createSplMint(); - const a8Owner = Keypair.generate(); - - // A9: 0 cold, ATA exists with 500 - const a9Mint = await createSplMint(); - const a9Owner = Keypair.generate(); - await createLightAtaWithBalance(a9Mint, a9Owner, 500n); - - // ── Tests ────────────────────────────────────────────── - - console.log(" Running tests...\n"); - - // A1: 1 cold, no ATA -> creates ATA, loads 1 - { - const ata = getAssociatedTokenAddressInterface(a1Mint, a1Owner.publicKey); - const tx = await loadAta(rpc, ata, a1Owner, a1Mint, payer); - assert(tx !== null, "A1: should return tx signature"); - - await waitForCompressedCount(a1Owner.publicKey, a1Mint, 0); - const balance = await getLightAtaBalance(ata, a1Owner.publicKey, a1Mint); - logScenario("A1: 1 cold, no ATA", 1n * AMOUNT_EACH, balance); - } - - // A2: 2 cold, no ATA -> creates ATA, loads 2 - { - const ata = getAssociatedTokenAddressInterface(a2Mint, a2Owner.publicKey); - const tx = await loadAta(rpc, ata, a2Owner, a2Mint, payer); - assert(tx !== null, "A2: should return tx signature"); - - await waitForCompressedCount(a2Owner.publicKey, a2Mint, 0); - const balance = await getLightAtaBalance(ata, a2Owner.publicKey, a2Mint); - logScenario("A2: 2 cold, no ATA", 2n * AMOUNT_EACH, balance); - } - - // A3: 4 cold, no ATA -> creates ATA, loads 4 - { - const ata = getAssociatedTokenAddressInterface(a3Mint, a3Owner.publicKey); - const tx = await loadAta(rpc, ata, a3Owner, a3Mint, payer); - assert(tx !== null, "A3: should return tx signature"); - - await waitForCompressedCount(a3Owner.publicKey, a3Mint, 0); - const balance = await getLightAtaBalance(ata, a3Owner.publicKey, a3Mint); - logScenario("A3: 4 cold, no ATA", 4n * AMOUNT_EACH, balance); - } - - // A4: 8 cold, no ATA -> creates ATA, loads 8 (max) - { - const ata = getAssociatedTokenAddressInterface(a4Mint, a4Owner.publicKey); - const tx = await loadAta(rpc, ata, a4Owner, a4Mint, payer); - assert(tx !== null, "A4: should return tx signature"); - - await waitForCompressedCount(a4Owner.publicKey, a4Mint, 0); - const balance = await getLightAtaBalance(ata, a4Owner.publicKey, a4Mint); - logScenario("A4: 8 cold, no ATA", 8n * AMOUNT_EACH, balance); - } - - // A5: 1 cold, ATA exists (empty) -> loads 1 - { - const ata = getAssociatedTokenAddressInterface(a5Mint, a5Owner.publicKey); - const tx = await loadAta(rpc, ata, a5Owner, a5Mint, payer); - assert(tx !== null, "A5: should return tx signature"); - - await waitForCompressedCount(a5Owner.publicKey, a5Mint, 0); - const balance = await getLightAtaBalance(ata, a5Owner.publicKey, a5Mint); - logScenario("A5: 1 cold, ATA exists (empty)", 1n * AMOUNT_EACH, balance); - } - - // A6: 4 cold, ATA exists with 500 -> loads 4, total = 500 + 4*100 - { - const ata = getAssociatedTokenAddressInterface(a6Mint, a6Owner.publicKey); - const tx = await loadAta(rpc, ata, a6Owner, a6Mint, payer); - assert(tx !== null, "A6: should return tx signature"); - - await waitForCompressedCount(a6Owner.publicKey, a6Mint, 0); - const balance = await getLightAtaBalance(ata, a6Owner.publicKey, a6Mint); - logScenario("A6: 4 cold, ATA has 500", 500n + 4n * AMOUNT_EACH, balance); - } - - // A7: 8 cold, ATA exists with 500 -> loads 8, total = 500 + 8*100 - { - const ata = getAssociatedTokenAddressInterface(a7Mint, a7Owner.publicKey); - const tx = await loadAta(rpc, ata, a7Owner, a7Mint, payer); - assert(tx !== null, "A7: should return tx signature"); - - await waitForCompressedCount(a7Owner.publicKey, a7Mint, 0); - const balance = await getLightAtaBalance(ata, a7Owner.publicKey, a7Mint); - logScenario("A7: 8 cold, ATA has 500", 500n + 8n * AMOUNT_EACH, balance); - } - - // A8: 0 cold, no ATA -> returns null, no ATA created - { - const ata = getAssociatedTokenAddressInterface(a8Mint, a8Owner.publicKey); - const tx = await loadAta(rpc, ata, a8Owner, a8Mint, payer); - assert(tx === null, "A8: should return null"); - - const balance = await getLightAtaBalance(ata, a8Owner.publicKey, a8Mint); - logScenario("A8: 0 cold, no ATA", 0n, balance); - } - - // A9: 0 cold, ATA exists with 500 -> returns null, balance unchanged - { - const ata = getAssociatedTokenAddressInterface(a9Mint, a9Owner.publicKey); - const tx = await loadAta(rpc, ata, a9Owner, a9Mint, payer); - assert(tx === null, "A9: should return null"); - - const balance = await getLightAtaBalance(ata, a9Owner.publicKey, a9Mint); - logScenario("A9: 0 cold, ATA has 500", 500n, balance); - } - - console.log("\n=== All Cold-Only Scenarios Passed ===\n"); -})(); diff --git a/typescript-client/tests/load-ata/idempotency.ts b/typescript-client/tests/load-ata/idempotency.ts deleted file mode 100644 index 43d1f93..0000000 --- a/typescript-client/tests/load-ata/idempotency.ts +++ /dev/null @@ -1,105 +0,0 @@ -import "dotenv/config"; -import { Keypair } from "@solana/web3.js"; -import { loadAta } from "@lightprotocol/compressed-token/unified"; -import { - rpc, - payer, - createMultipleCompressed, - createSplMint, - getSplAtaWithBalance, - getCompressedCount, - waitForCompressedCount, - getLightAtaBalance, - getAssociatedTokenAddressInterface, - assert, - logScenario, -} from "./setup.js"; - -const AMOUNT_EACH = 100n; - -(async function () { - console.log("\n=== Idempotency Scenarios ===\n"); - - // ── Setup ────────────────────────────────────────────── - - console.log(" Setting up scenarios...\n"); - - // E1: 2 cold (SPL mint) - const e1Mint = await createSplMint(); - const e1Owner = Keypair.generate(); - await createMultipleCompressed(e1Mint, e1Owner.publicKey, 2, AMOUNT_EACH); - - // E2: 2 cold (SPL mint) — second batch compressed mid-test - const e2Mint = await createSplMint(); - const e2Owner = Keypair.generate(); - await createMultipleCompressed(e2Mint, e2Owner.publicKey, 2, AMOUNT_EACH); - - // E3: 1 cold + 1000 SPL - const e3Mint = await createSplMint(); - const e3Owner = Keypair.generate(); - await createMultipleCompressed(e3Mint, e3Owner.publicKey, 1, AMOUNT_EACH); - await getSplAtaWithBalance(e3Mint, e3Owner.publicKey, 1000n); - - // ── Tests ────────────────────────────────────────────── - - console.log(" Running tests...\n"); - - // E1: Load, then load again immediately -> second returns null - { - const ata = getAssociatedTokenAddressInterface(e1Mint, e1Owner.publicKey); - - const tx1 = await loadAta(rpc, ata, e1Owner, e1Mint, payer); - assert(tx1 !== null, "E1: first load should return tx"); - - await waitForCompressedCount(e1Owner.publicKey, e1Mint, 0); - - const tx2 = await loadAta(rpc, ata, e1Owner, e1Mint, payer); - assert(tx2 === null, "E1: second load should return null"); - - const balance = await getLightAtaBalance(ata, e1Owner.publicKey, e1Mint); - logScenario("E1: load then load again", 2n * AMOUNT_EACH, balance); - } - - // E2: Load, create 2 more cold, load again -> second loads the 2 new ones - { - const ata = getAssociatedTokenAddressInterface(e2Mint, e2Owner.publicKey); - - const tx1 = await loadAta(rpc, ata, e2Owner, e2Mint, payer); - assert(tx1 !== null, "E2: first load should return tx"); - - const balanceAfterFirst = await getLightAtaBalance(ata, e2Owner.publicKey, e2Mint); - assert(balanceAfterFirst === 2n * AMOUNT_EACH, "E2: first load balance check"); - - // Mint 2 more compressed accounts mid-test (inherently sequential) - await createMultipleCompressed(e2Mint, e2Owner.publicKey, 2, AMOUNT_EACH); - - const coldCount = await getCompressedCount(e2Owner.publicKey, e2Mint); - assert(coldCount === 2, "E2: should have 2 new compressed accounts"); - - const tx2 = await loadAta(rpc, ata, e2Owner, e2Mint, payer); - assert(tx2 !== null, "E2: second load should return tx (new cold accounts)"); - - await waitForCompressedCount(e2Owner.publicKey, e2Mint, 0); - - const balance = await getLightAtaBalance(ata, e2Owner.publicKey, e2Mint); - logScenario("E2: load, add 2 more cold, load again", 4n * AMOUNT_EACH, balance); - } - - // E3: Load SPL wrap, then load again -> second returns null - { - const ata = getAssociatedTokenAddressInterface(e3Mint, e3Owner.publicKey); - - const tx1 = await loadAta(rpc, ata, e3Owner, e3Mint, payer); - assert(tx1 !== null, "E3: first load should return tx"); - - await waitForCompressedCount(e3Owner.publicKey, e3Mint, 0); - - const tx2 = await loadAta(rpc, ata, e3Owner, e3Mint, payer); - assert(tx2 === null, "E3: second load should return null"); - - const balance = await getLightAtaBalance(ata, e3Owner.publicKey, e3Mint); - logScenario("E3: load SPL+cold, then load again", 1n * AMOUNT_EACH + 1000n, balance); - } - - console.log("\n=== All Idempotency Scenarios Passed ===\n"); -})(); diff --git a/typescript-client/tests/load-ata/load-and-transfer.ts b/typescript-client/tests/load-ata/load-and-transfer.ts deleted file mode 100644 index 6f164f2..0000000 --- a/typescript-client/tests/load-ata/load-and-transfer.ts +++ /dev/null @@ -1,182 +0,0 @@ -import "dotenv/config"; -import { Keypair } from "@solana/web3.js"; -import { - createLoadAtaInstructions, - createTransferInterfaceInstruction, -} from "@lightprotocol/compressed-token/unified"; -import { - buildAndSignTx, - sendAndConfirmTx, -} from "@lightprotocol/stateless.js"; -import { - rpc, - payer, - createMultipleCompressed, - createSplMint, - createT22Mint, - TOKEN_2022_PROGRAM_ID, - getSplAtaWithBalance, - getT22AtaWithBalance, - getLightAtaBalance, - getAssociatedTokenAddressInterface, - createAtaInterface, - assert, - logScenario, -} from "./setup.js"; - -const AMOUNT_EACH = 100n; -const TRANSFER_AMOUNT = 50; - -(async function () { - console.log("\n=== Load + Transfer in Single Tx ===\n"); - - // ── Setup ────────────────────────────────────────────── - - console.log(" Setting up scenarios...\n"); - - // D1: 1 cold (SPL mint) - const d1Mint = await createSplMint(); - const d1Sender = Keypair.generate(); - const d1Recipient = Keypair.generate(); - await createMultipleCompressed(d1Mint, d1Sender.publicKey, 1, AMOUNT_EACH); - await createAtaInterface(rpc, payer, d1Mint, d1Recipient.publicKey); - - // D2: 4 cold (SPL mint) - const d2Mint = await createSplMint(); - const d2Sender = Keypair.generate(); - const d2Recipient = Keypair.generate(); - await createMultipleCompressed(d2Mint, d2Sender.publicKey, 4, AMOUNT_EACH); - await createAtaInterface(rpc, payer, d2Mint, d2Recipient.publicKey); - - // D3: 2 cold + 1000 SPL - const d3Mint = await createSplMint(); - const d3Sender = Keypair.generate(); - const d3Recipient = Keypair.generate(); - await createMultipleCompressed(d3Mint, d3Sender.publicKey, 2, AMOUNT_EACH); - await getSplAtaWithBalance(d3Mint, d3Sender.publicKey, 1000n); - await createAtaInterface(rpc, payer, d3Mint, d3Recipient.publicKey); - - // D4: 2 cold + 1000 T22 - const d4Mint = await createT22Mint(); - const d4Sender = Keypair.generate(); - const d4Recipient = Keypair.generate(); - await createMultipleCompressed(d4Mint, d4Sender.publicKey, 2, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); - await getT22AtaWithBalance(d4Mint, d4Sender.publicKey, 1000n); - await createAtaInterface(rpc, payer, d4Mint, d4Recipient.publicKey); - - // ── Tests ────────────────────────────────────────────── - - console.log(" Running tests...\n"); - - // D1: 1 cold (SPL mint) -> load + transfer in 1 tx - { - const senderAta = getAssociatedTokenAddressInterface(d1Mint, d1Sender.publicKey); - const recipientAta = getAssociatedTokenAddressInterface(d1Mint, d1Recipient.publicKey); - - const loadIxs = await createLoadAtaInstructions( - rpc, senderAta, d1Sender.publicKey, d1Mint, payer.publicKey, - ); - assert(loadIxs.length > 0, "D1: should have load instructions"); - - const transferIx = createTransferInterfaceInstruction( - senderAta, recipientAta, d1Sender.publicKey, TRANSFER_AMOUNT, - ); - - const blockhash = await rpc.getLatestBlockhash(); - const tx = buildAndSignTx( - [...loadIxs, transferIx], payer, blockhash.blockhash, [d1Sender], - ); - await sendAndConfirmTx(rpc, tx); - - const senderBalance = await getLightAtaBalance(senderAta, d1Sender.publicKey, d1Mint); - const recipientBalance = await getLightAtaBalance(recipientAta, d1Recipient.publicKey, d1Mint); - - logScenario("D1: sender balance after load+transfer", 1n * AMOUNT_EACH - BigInt(TRANSFER_AMOUNT), senderBalance); - logScenario("D1: recipient balance after load+transfer", BigInt(TRANSFER_AMOUNT), recipientBalance); - } - - // D2: 4 cold (SPL mint) -> load + transfer in 1 tx - { - const senderAta = getAssociatedTokenAddressInterface(d2Mint, d2Sender.publicKey); - const recipientAta = getAssociatedTokenAddressInterface(d2Mint, d2Recipient.publicKey); - - const loadIxs = await createLoadAtaInstructions( - rpc, senderAta, d2Sender.publicKey, d2Mint, payer.publicKey, - ); - assert(loadIxs.length > 0, "D2: should have load instructions"); - - const transferIx = createTransferInterfaceInstruction( - senderAta, recipientAta, d2Sender.publicKey, TRANSFER_AMOUNT, - ); - - const blockhash = await rpc.getLatestBlockhash(); - const tx = buildAndSignTx( - [...loadIxs, transferIx], payer, blockhash.blockhash, [d2Sender], - ); - await sendAndConfirmTx(rpc, tx); - - const senderBalance = await getLightAtaBalance(senderAta, d2Sender.publicKey, d2Mint); - const recipientBalance = await getLightAtaBalance(recipientAta, d2Recipient.publicKey, d2Mint); - - logScenario("D2: sender (4 cold load+transfer)", 4n * AMOUNT_EACH - BigInt(TRANSFER_AMOUNT), senderBalance); - logScenario("D2: recipient (4 cold load+transfer)", BigInt(TRANSFER_AMOUNT), recipientBalance); - } - - // D3: SPL ATA + 2 cold -> load + wrap + transfer in 1 tx - { - const senderAta = getAssociatedTokenAddressInterface(d3Mint, d3Sender.publicKey); - const recipientAta = getAssociatedTokenAddressInterface(d3Mint, d3Recipient.publicKey); - - const loadIxs = await createLoadAtaInstructions( - rpc, senderAta, d3Sender.publicKey, d3Mint, payer.publicKey, - ); - assert(loadIxs.length > 0, "D3: should have load instructions"); - - const transferIx = createTransferInterfaceInstruction( - senderAta, recipientAta, d3Sender.publicKey, TRANSFER_AMOUNT, - ); - - const blockhash = await rpc.getLatestBlockhash(); - const tx = buildAndSignTx( - [...loadIxs, transferIx], payer, blockhash.blockhash, [d3Sender], - ); - await sendAndConfirmTx(rpc, tx); - - const senderBalance = await getLightAtaBalance(senderAta, d3Sender.publicKey, d3Mint); - const recipientBalance = await getLightAtaBalance(recipientAta, d3Recipient.publicKey, d3Mint); - const totalLoaded = 2n * AMOUNT_EACH + 1000n; - - logScenario("D3: sender (SPL+2 cold load+transfer)", totalLoaded - BigInt(TRANSFER_AMOUNT), senderBalance); - logScenario("D3: recipient (SPL+2 cold load+transfer)", BigInt(TRANSFER_AMOUNT), recipientBalance); - } - - // D4: T22 ATA + 2 cold -> load + wrap + transfer in 1 tx - { - const senderAta = getAssociatedTokenAddressInterface(d4Mint, d4Sender.publicKey); - const recipientAta = getAssociatedTokenAddressInterface(d4Mint, d4Recipient.publicKey); - - const loadIxs = await createLoadAtaInstructions( - rpc, senderAta, d4Sender.publicKey, d4Mint, payer.publicKey, - ); - assert(loadIxs.length > 0, "D4: should have load instructions"); - - const transferIx = createTransferInterfaceInstruction( - senderAta, recipientAta, d4Sender.publicKey, TRANSFER_AMOUNT, - ); - - const blockhash = await rpc.getLatestBlockhash(); - const tx = buildAndSignTx( - [...loadIxs, transferIx], payer, blockhash.blockhash, [d4Sender], - ); - await sendAndConfirmTx(rpc, tx); - - const senderBalance = await getLightAtaBalance(senderAta, d4Sender.publicKey, d4Mint); - const recipientBalance = await getLightAtaBalance(recipientAta, d4Recipient.publicKey, d4Mint); - const totalLoaded = 2n * AMOUNT_EACH + 1000n; - - logScenario("D4: sender (T22+2 cold load+transfer)", totalLoaded - BigInt(TRANSFER_AMOUNT), senderBalance); - logScenario("D4: recipient (T22+2 cold load+transfer)", BigInt(TRANSFER_AMOUNT), recipientBalance); - } - - console.log("\n=== All Load+Transfer Scenarios Passed ===\n"); -})(); diff --git a/typescript-client/tests/load-ata/setup.ts b/typescript-client/tests/load-ata/setup.ts deleted file mode 100644 index 386e039..0000000 --- a/typescript-client/tests/load-ata/setup.ts +++ /dev/null @@ -1,250 +0,0 @@ -import { Keypair, PublicKey } from "@solana/web3.js"; -import { createRpc, Rpc } from "@lightprotocol/stateless.js"; -import { - createMintInterface, - compress, - createAtaInterface, - loadAta, - getAssociatedTokenAddressInterface, - getAtaInterface, -} from "@lightprotocol/compressed-token"; -import { - createAssociatedTokenAccount, - getOrCreateAssociatedTokenAccount, - mintTo, - getAccount, - TOKEN_PROGRAM_ID, - TOKEN_2022_PROGRAM_ID, -} from "@solana/spl-token"; -import { homedir } from "os"; -import { readFileSync } from "fs"; - -// localnet RPC -export const rpc: Rpc = createRpc(); - -export const payer = Keypair.fromSecretKey( - new Uint8Array( - JSON.parse(readFileSync(`${homedir()}/.config/solana/id.json`, "utf8")), - ), -); - -// Create N compressed token accounts for owner, each with `amountEach`. -// Mints tokens to payer's ATA, then compresses into cold accounts owned by `owner`. -// Waits for the indexer to reflect all new accounts before returning. -export async function createMultipleCompressed( - mint: PublicKey, - owner: PublicKey, - count: number, - amountEach: bigint, - tokenProgramId: PublicKey = TOKEN_PROGRAM_ID, -): Promise { - const before = await getCompressedCount(owner, mint); - - // Get or create payer's ATA for this mint - const payerAta = await getOrCreateAssociatedTokenAccount( - rpc, payer, mint, payer.publicKey, undefined, undefined, undefined, tokenProgramId, - ); - - // Mint total amount to payer's ATA - const totalAmount = amountEach * BigInt(count); - await mintTo(rpc, payer, mint, payerAta.address, payer, totalAmount, [], undefined, tokenProgramId); - - // Compress into N cold accounts owned by `owner` - const amounts = Array(count).fill(Number(amountEach)); - const recipients = Array(count).fill(owner); - await compress(rpc, payer, mint, amounts, payer, payerAta.address, recipients); - - const expected = before + count; - const deadline = Date.now() + 30_000; - while (Date.now() < deadline) { - const indexed = await getCompressedCount(owner, mint); - if (indexed >= expected) return; - await new Promise((r) => setTimeout(r, 200)); - } - throw new Error( - `Indexer timeout: expected ${expected} compressed accounts, got ${await getCompressedCount(owner, mint)}`, - ); -} - -// Create SPL ATA and mint tokens into it -export async function getSplAtaWithBalance( - mint: PublicKey, - owner: PublicKey, - amount: bigint, -): Promise { - const ata = await createAssociatedTokenAccount( - rpc, - payer, - mint, - owner, - undefined, - TOKEN_PROGRAM_ID, - ); - if (amount > 0n) { - await mintTo(rpc, payer, mint, ata, payer, amount, [], undefined, TOKEN_PROGRAM_ID); - } - return ata; -} - -// Create T22 ATA and mint tokens into it -export async function getT22AtaWithBalance( - mint: PublicKey, - owner: PublicKey, - amount: bigint, -): Promise { - const ata = await createAssociatedTokenAccount( - rpc, - payer, - mint, - owner, - undefined, - TOKEN_2022_PROGRAM_ID, - ); - if (amount > 0n) { - await mintTo(rpc, payer, mint, ata, payer, amount, [], undefined, TOKEN_2022_PROGRAM_ID); - } - return ata; -} - -// Count compressed token accounts for owner + mint -export async function getCompressedCount( - owner: PublicKey, - mint: PublicKey, -): Promise { - const result = await rpc.getCompressedTokenAccountsByOwner(owner, { - mint, - }); - return result.items.length; -} - -// Poll indexer until compressed count reaches expected value. -// Use after loadAta to wait for consumed accounts to disappear from the index. -export async function waitForCompressedCount( - owner: PublicKey, - mint: PublicKey, - expected: number, - timeoutMs = 30_000, -): Promise { - const deadline = Date.now() + timeoutMs; - while (Date.now() < deadline) { - const count = await getCompressedCount(owner, mint); - if (count === expected) return; - await new Promise((r) => setTimeout(r, 200)); - } - const actual = await getCompressedCount(owner, mint); - throw new Error( - `Indexer timeout: expected ${expected} compressed accounts, got ${actual}`, - ); -} - -// Get Light ATA balance (returns 0n if account doesn't exist) -export async function getLightAtaBalance( - ata: PublicKey, - owner: PublicKey, - mint: PublicKey, -): Promise { - try { - const account = await getAtaInterface(rpc, ata, owner, mint); - return account.parsed.amount; - } catch { - return 0n; - } -} - -// Get SPL/T22 ATA balance -export async function getSplAtaBalance( - ata: PublicKey, - programId: PublicKey = TOKEN_PROGRAM_ID, -): Promise { - try { - const account = await getAccount(rpc, ata, undefined, programId); - return account.amount; - } catch { - return 0n; - } -} - -// Simple assert -export function assert(condition: boolean, msg: string): void { - if (!condition) { - throw new Error(`FAIL: ${msg}`); - } -} - -// Log scenario result -export function logScenario( - name: string, - expected: bigint, - actual: bigint, -): void { - const pass = expected === actual; - const status = pass ? "PASS" : "FAIL"; - console.log( - ` [${status}] ${name}: expected=${expected}, actual=${actual}`, - ); - if (!pass) { - throw new Error( - `${name}: expected=${expected}, actual=${actual}`, - ); - } -} - -// Create a fresh SPL mint with Light interface PDA -export async function createSplMint(): Promise { - const mintKeypair = Keypair.generate(); - const { mint } = await createMintInterface( - rpc, - payer, - payer, - null, - 9, - mintKeypair, - undefined, - TOKEN_PROGRAM_ID, - ); - return mint; -} - -// Create a fresh T22 mint with Light interface PDA -export async function createT22Mint(): Promise { - const mintKeypair = Keypair.generate(); - const { mint } = await createMintInterface( - rpc, - payer, - payer, - null, - 9, - mintKeypair, - undefined, - TOKEN_2022_PROGRAM_ID, - ); - return mint; -} - -// Create Light ATA and optionally pre-fill it with balance. -// When amount is provided: creates a temporary cold account, then loads it into the ATA. -// IMPORTANT: Call this BEFORE creating test cold accounts and SPL/T22 ATAs, -// otherwise loadAta in setup would consume them. -export async function createLightAtaWithBalance( - mint: PublicKey, - owner: Keypair, - amount?: bigint, - tokenProgramId: PublicKey = TOKEN_PROGRAM_ID, -): Promise { - await createAtaInterface(rpc, payer, mint, owner.publicKey); - const ata = getAssociatedTokenAddressInterface(mint, owner.publicKey); - if (amount && amount > 0n) { - await createMultipleCompressed(mint, owner.publicKey, 1, amount, tokenProgramId); - await loadAta(rpc, ata, owner, mint, payer); - await waitForCompressedCount(owner.publicKey, mint, 0); - } - return ata; -} - -// Re-export commonly used functions -export { - getAssociatedTokenAddressInterface, - createAtaInterface, - TOKEN_PROGRAM_ID, - TOKEN_2022_PROGRAM_ID, -}; diff --git a/typescript-client/tests/load-ata/spl-sources.ts b/typescript-client/tests/load-ata/spl-sources.ts deleted file mode 100644 index 824f116..0000000 --- a/typescript-client/tests/load-ata/spl-sources.ts +++ /dev/null @@ -1,173 +0,0 @@ -import "dotenv/config"; -import { Keypair } from "@solana/web3.js"; -import { loadAta } from "@lightprotocol/compressed-token/unified"; -import { - rpc, - payer, - createMultipleCompressed, - createSplMint, - createLightAtaWithBalance, - getSplAtaWithBalance, - getSplAtaBalance, - waitForCompressedCount, - getLightAtaBalance, - getAssociatedTokenAddressInterface, - assert, - logScenario, - TOKEN_PROGRAM_ID, -} from "./setup.js"; - -const AMOUNT_EACH = 100n; -const SPL_AMOUNT = 1000n; - -(async function () { - console.log("\n=== loadAta: SPL mint sources ===\n"); - - // ── Setup ────────────────────────────────────────────── - - console.log(" Setting up scenarios...\n"); - - // B1: 0 cold, 1000 SPL, no Light ATA - const b1Mint = await createSplMint(); - const b1Owner = Keypair.generate(); - const b1SplAta = await getSplAtaWithBalance(b1Mint, b1Owner.publicKey, SPL_AMOUNT); - - // B2: 1 cold, 1000 SPL, no Light ATA - const b2Mint = await createSplMint(); - const b2Owner = Keypair.generate(); - await createMultipleCompressed(b2Mint, b2Owner.publicKey, 1, AMOUNT_EACH); - const b2SplAta = await getSplAtaWithBalance(b2Mint, b2Owner.publicKey, SPL_AMOUNT); - - // B3: 4 cold, 1000 SPL, no Light ATA - const b3Mint = await createSplMint(); - const b3Owner = Keypair.generate(); - await createMultipleCompressed(b3Mint, b3Owner.publicKey, 4, AMOUNT_EACH); - const b3SplAta = await getSplAtaWithBalance(b3Mint, b3Owner.publicKey, SPL_AMOUNT); - - // B4: 8 cold, 1000 SPL, no Light ATA - const b4Mint = await createSplMint(); - const b4Owner = Keypair.generate(); - await createMultipleCompressed(b4Mint, b4Owner.publicKey, 8, AMOUNT_EACH); - const b4SplAta = await getSplAtaWithBalance(b4Mint, b4Owner.publicKey, SPL_AMOUNT); - - // B5: 4 cold, 1000 SPL, Light ATA has 500 - const b5Mint = await createSplMint(); - const b5Owner = Keypair.generate(); - await createLightAtaWithBalance(b5Mint, b5Owner, 500n); - await createMultipleCompressed(b5Mint, b5Owner.publicKey, 4, AMOUNT_EACH); - const b5SplAta = await getSplAtaWithBalance(b5Mint, b5Owner.publicKey, SPL_AMOUNT); - - // B6: 4 cold, 0 SPL, no Light ATA - const b6Mint = await createSplMint(); - const b6Owner = Keypair.generate(); - await createMultipleCompressed(b6Mint, b6Owner.publicKey, 4, AMOUNT_EACH); - await getSplAtaWithBalance(b6Mint, b6Owner.publicKey, 0n); - - // B7: 0 cold, 0 SPL, no Light ATA - const b7Mint = await createSplMint(); - const b7Owner = Keypair.generate(); - await getSplAtaWithBalance(b7Mint, b7Owner.publicKey, 0n); - - // ── Tests ────────────────────────────────────────────── - - console.log(" Running tests...\n"); - - // B1: 0 cold, 1000 SPL, no Light ATA -> creates ATA, wraps SPL - { - const ata = getAssociatedTokenAddressInterface(b1Mint, b1Owner.publicKey); - const tx = await loadAta(rpc, ata, b1Owner, b1Mint, payer); - assert(tx !== null, "B1: expected transaction signature"); - - await waitForCompressedCount(b1Owner.publicKey, b1Mint, 0); - - const splBalance = await getSplAtaBalance(b1SplAta, TOKEN_PROGRAM_ID); - assert(splBalance === 0n, `B1: expected SPL balance 0, got ${splBalance}`); - - const lightBalance = await getLightAtaBalance(ata, b1Owner.publicKey, b1Mint); - logScenario("B1: 0 cold + 1000 SPL, no ATA", SPL_AMOUNT, lightBalance); - } - - // B2: 1 cold, 1000 SPL, no Light ATA -> creates ATA, loads 1 + wraps - { - const ata = getAssociatedTokenAddressInterface(b2Mint, b2Owner.publicKey); - const tx = await loadAta(rpc, ata, b2Owner, b2Mint, payer); - assert(tx !== null, "B2: expected transaction signature"); - - await waitForCompressedCount(b2Owner.publicKey, b2Mint, 0); - - const splBalance = await getSplAtaBalance(b2SplAta, TOKEN_PROGRAM_ID); - assert(splBalance === 0n, `B2: expected SPL balance 0, got ${splBalance}`); - - const lightBalance = await getLightAtaBalance(ata, b2Owner.publicKey, b2Mint); - logScenario("B2: 1 cold + 1000 SPL, no ATA", 1n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); - } - - // B3: 4 cold, 1000 SPL, no Light ATA -> creates ATA, loads 4 + wraps - { - const ata = getAssociatedTokenAddressInterface(b3Mint, b3Owner.publicKey); - const tx = await loadAta(rpc, ata, b3Owner, b3Mint, payer); - assert(tx !== null, "B3: expected transaction signature"); - - await waitForCompressedCount(b3Owner.publicKey, b3Mint, 0); - - const splBalance = await getSplAtaBalance(b3SplAta, TOKEN_PROGRAM_ID); - assert(splBalance === 0n, `B3: expected SPL balance 0, got ${splBalance}`); - - const lightBalance = await getLightAtaBalance(ata, b3Owner.publicKey, b3Mint); - logScenario("B3: 4 cold + 1000 SPL, no ATA", 4n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); - } - - // B4: 8 cold, 1000 SPL, no Light ATA -> creates ATA, loads 8 + wraps - { - const ata = getAssociatedTokenAddressInterface(b4Mint, b4Owner.publicKey); - const tx = await loadAta(rpc, ata, b4Owner, b4Mint, payer); - assert(tx !== null, "B4: expected transaction signature"); - - await waitForCompressedCount(b4Owner.publicKey, b4Mint, 0); - - const splBalance = await getSplAtaBalance(b4SplAta, TOKEN_PROGRAM_ID); - assert(splBalance === 0n, `B4: expected SPL balance 0, got ${splBalance}`); - - const lightBalance = await getLightAtaBalance(ata, b4Owner.publicKey, b4Mint); - logScenario("B4: 8 cold + 1000 SPL, no ATA", 8n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); - } - - // B5: 4 cold, 1000 SPL, Light ATA has 500 -> loads 4 + wraps, total = 500 + 400 + 1000 - { - const ata = getAssociatedTokenAddressInterface(b5Mint, b5Owner.publicKey); - const tx = await loadAta(rpc, ata, b5Owner, b5Mint, payer); - assert(tx !== null, "B5: expected transaction signature"); - - await waitForCompressedCount(b5Owner.publicKey, b5Mint, 0); - - const splBalance = await getSplAtaBalance(b5SplAta, TOKEN_PROGRAM_ID); - assert(splBalance === 0n, `B5: expected SPL balance 0, got ${splBalance}`); - - const lightBalance = await getLightAtaBalance(ata, b5Owner.publicKey, b5Mint); - logScenario("B5: 4 cold + 1000 SPL, ATA has 500", 500n + 4n * AMOUNT_EACH + SPL_AMOUNT, lightBalance); - } - - // B6: 4 cold, 0 SPL, no Light ATA -> creates ATA, loads 4 cold only - { - const ata = getAssociatedTokenAddressInterface(b6Mint, b6Owner.publicKey); - const tx = await loadAta(rpc, ata, b6Owner, b6Mint, payer); - assert(tx !== null, "B6: expected transaction signature"); - - await waitForCompressedCount(b6Owner.publicKey, b6Mint, 0); - - const lightBalance = await getLightAtaBalance(ata, b6Owner.publicKey, b6Mint); - logScenario("B6: 4 cold + 0 SPL, no ATA", 4n * AMOUNT_EACH, lightBalance); - } - - // B7: 0 cold, 0 SPL, no Light ATA -> returns null - { - const ata = getAssociatedTokenAddressInterface(b7Mint, b7Owner.publicKey); - const tx = await loadAta(rpc, ata, b7Owner, b7Mint, payer); - assert(tx === null, "B7: expected null (nothing to load)"); - - const lightBalance = await getLightAtaBalance(ata, b7Owner.publicKey, b7Mint); - logScenario("B7: 0 cold + 0 SPL, no ATA", 0n, lightBalance); - } - - console.log("\n=== All SPL source scenarios passed ===\n"); -})(); diff --git a/typescript-client/tests/load-ata/t22-sources.ts b/typescript-client/tests/load-ata/t22-sources.ts deleted file mode 100644 index a8f0919..0000000 --- a/typescript-client/tests/load-ata/t22-sources.ts +++ /dev/null @@ -1,135 +0,0 @@ -import "dotenv/config"; -import { Keypair } from "@solana/web3.js"; -import { loadAta } from "@lightprotocol/compressed-token/unified"; -import { - rpc, - payer, - createMultipleCompressed, - createT22Mint, - createLightAtaWithBalance, - getT22AtaWithBalance, - getSplAtaBalance, - waitForCompressedCount, - getLightAtaBalance, - getAssociatedTokenAddressInterface, - assert, - logScenario, - TOKEN_2022_PROGRAM_ID, -} from "./setup.js"; - -const AMOUNT_EACH = 100n; -const T22_AMOUNT = 1000n; - -(async function () { - console.log("=== loadAta: Token-2022 mint sources ===\n"); - - // ── Setup ────────────────────────────────────────────── - - console.log(" Setting up scenarios...\n"); - - // C1: T22 ATA only, no cold, no existing Light ATA - const c1Mint = await createT22Mint(); - const c1Owner = Keypair.generate(); - const c1T22Ata = await getT22AtaWithBalance(c1Mint, c1Owner.publicKey, T22_AMOUNT); - - // C2: 1 cold + T22 ATA, no existing Light ATA - const c2Mint = await createT22Mint(); - const c2Owner = Keypair.generate(); - await createMultipleCompressed(c2Mint, c2Owner.publicKey, 1, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); - const c2T22Ata = await getT22AtaWithBalance(c2Mint, c2Owner.publicKey, T22_AMOUNT); - - // C3: 4 cold + T22 ATA, no existing Light ATA - const c3Mint = await createT22Mint(); - const c3Owner = Keypair.generate(); - await createMultipleCompressed(c3Mint, c3Owner.publicKey, 4, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); - const c3T22Ata = await getT22AtaWithBalance(c3Mint, c3Owner.publicKey, T22_AMOUNT); - - // C4: 8 cold + T22 ATA + existing Light ATA with 500 - const c4Mint = await createT22Mint(); - const c4Owner = Keypair.generate(); - await createLightAtaWithBalance(c4Mint, c4Owner, 500n, TOKEN_2022_PROGRAM_ID); - await createMultipleCompressed(c4Mint, c4Owner.publicKey, 8, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); - const c4T22Ata = await getT22AtaWithBalance(c4Mint, c4Owner.publicKey, T22_AMOUNT); - - // C5: 4 cold + empty T22 ATA (0 balance), no existing Light ATA - const c5Mint = await createT22Mint(); - const c5Owner = Keypair.generate(); - await createMultipleCompressed(c5Mint, c5Owner.publicKey, 4, AMOUNT_EACH, TOKEN_2022_PROGRAM_ID); - const c5T22Ata = await getT22AtaWithBalance(c5Mint, c5Owner.publicKey, 0n); - - // ── Tests ────────────────────────────────────────────── - - console.log(" Running tests...\n"); - - // C1: T22 ATA only -> creates ATA, wraps T22 - { - const ata = getAssociatedTokenAddressInterface(c1Mint, c1Owner.publicKey); - await loadAta(rpc, ata, c1Owner, c1Mint, payer); - - await waitForCompressedCount(c1Owner.publicKey, c1Mint, 0); - - const t22Balance = await getSplAtaBalance(c1T22Ata, TOKEN_2022_PROGRAM_ID); - assert(t22Balance === 0n, "C1: T22 ATA should be drained"); - - const lightBalance = await getLightAtaBalance(ata, c1Owner.publicKey, c1Mint); - logScenario("C1: T22 ATA only (no cold)", T22_AMOUNT, lightBalance); - } - - // C2: 1 cold + T22 ATA -> creates ATA, loads 1 + wraps - { - const ata = getAssociatedTokenAddressInterface(c2Mint, c2Owner.publicKey); - await loadAta(rpc, ata, c2Owner, c2Mint, payer); - - await waitForCompressedCount(c2Owner.publicKey, c2Mint, 0); - - const t22Balance = await getSplAtaBalance(c2T22Ata, TOKEN_2022_PROGRAM_ID); - assert(t22Balance === 0n, "C2: T22 ATA should be drained"); - - const lightBalance = await getLightAtaBalance(ata, c2Owner.publicKey, c2Mint); - logScenario("C2: 1 cold + T22 ATA", 1n * AMOUNT_EACH + T22_AMOUNT, lightBalance); - } - - // C3: 4 cold + T22 ATA -> creates ATA, loads 4 + wraps - { - const ata = getAssociatedTokenAddressInterface(c3Mint, c3Owner.publicKey); - await loadAta(rpc, ata, c3Owner, c3Mint, payer); - - await waitForCompressedCount(c3Owner.publicKey, c3Mint, 0); - - const t22Balance = await getSplAtaBalance(c3T22Ata, TOKEN_2022_PROGRAM_ID); - assert(t22Balance === 0n, "C3: T22 ATA should be drained"); - - const lightBalance = await getLightAtaBalance(ata, c3Owner.publicKey, c3Mint); - logScenario("C3: 4 cold + T22 ATA", 4n * AMOUNT_EACH + T22_AMOUNT, lightBalance); - } - - // C4: 8 cold + T22 ATA + existing 500 -> loads 8 + wraps - { - const ata = getAssociatedTokenAddressInterface(c4Mint, c4Owner.publicKey); - await loadAta(rpc, ata, c4Owner, c4Mint, payer); - - await waitForCompressedCount(c4Owner.publicKey, c4Mint, 0); - - const t22Balance = await getSplAtaBalance(c4T22Ata, TOKEN_2022_PROGRAM_ID); - assert(t22Balance === 0n, "C4: T22 ATA should be drained"); - - const lightBalance = await getLightAtaBalance(ata, c4Owner.publicKey, c4Mint); - logScenario("C4: 8 cold + T22 ATA + existing 500", 500n + 8n * AMOUNT_EACH + T22_AMOUNT, lightBalance); - } - - // C5: 4 cold + empty T22 ATA -> creates ATA, loads 4 cold only - { - const ata = getAssociatedTokenAddressInterface(c5Mint, c5Owner.publicKey); - await loadAta(rpc, ata, c5Owner, c5Mint, payer); - - await waitForCompressedCount(c5Owner.publicKey, c5Mint, 0); - - const t22Balance = await getSplAtaBalance(c5T22Ata, TOKEN_2022_PROGRAM_ID); - assert(t22Balance === 0n, "C5: T22 ATA should remain 0"); - - const lightBalance = await getLightAtaBalance(ata, c5Owner.publicKey, c5Mint); - logScenario("C5: 4 cold + empty T22 ATA", 4n * AMOUNT_EACH, lightBalance); - } - - console.log("\n=== All T22 source scenarios passed ==="); -})();