Transaction Settlement

Comprehensive technical documentation on how StyxPay settles transactions on Solana with zero-knowledge proofs.

Table of Contents

1. Settlement Overview

2. Solana Program Architecture

3. Account State Management

4. Settlement Flow

5. Cross-Program Invocations

6. State Synchronization

7. Finality & Rollbacks

---

Settlement Overview

High-Level Architecture

┌──────────────┐         ┌──────────────┐         ┌──────────────┐
│   Frontend   │         │   Backend    │         │   Solana     │
│  (User Sign) │────────▶│  (Generate   │────────▶│  (Verify &   │
│              │         │   ZK Proof)  │         │   Settle)    │
└──────────────┘         └──────────────┘         └──────────────┘
       │                        │                        │
       │                        │                        ▼
       │                        │                 ┌──────────────┐
       │                        │                 │  SPL Token   │
       │                        │                 │  Transfer    │
       │                        │                 └──────────────┘
       │                        ▼                        │
       │                 ┌──────────────┐               │
       │                 │  Store Proof │               │
       │                 │  & Nullifier │               │
       │                 └──────────────┘               │
       │                                                 │
       └─────────────────────Event Emission─────────────┘

Settlement Guarantees

1. Atomicity: Transaction either fully completes or fully reverts

2. Consistency: State transitions maintain all invariants

3. Isolation: Concurrent transactions don't interfere

4. Durability: Committed transactions are permanent (after finality)

---

Solana Program Architecture

Program Structure

// Program ID (deployed address)
declare_id!("STYXpaydm3KVEKCUNb4QJdYsV7KJbBywKq8Qn5X2VUK");

#[program]
pub mod styxpay_settlement {
    use super::*;

    /// Initialize the settlement program
    pub fn initialize(
        ctx: Context<Initialize>,
        params: InitParams,
    ) -> Result<()> {
        // Implementation
    }

    /// Verify ZK proof and settle transaction
    pub fn settle_transaction(
        ctx: Context<SettleTransaction>,
        proof: CompressedProof,
        public_inputs: PublicInputs,
    ) -> Result<()> {
        // Implementation
    }

    /// Update authorization policy
    pub fn update_policy(
        ctx: Context<UpdatePolicy>,
        new_policy_hash: [u8; 32],
    ) -> Result<()> {
        // Implementation
    }

    /// Withdraw funds from vault
    pub fn withdraw(
        ctx: Context<Withdraw>,
        amount: u64,
    ) -> Result<()> {
        // Implementation
    }
}

Account Structures

Settlement State Account

#[account]
#[derive(Default)]
pub struct SettlementState {
    /// Program authority
    pub authority: Pubkey,

    /// Verifying key for ZK proofs
    pub verifying_key: VerifyingKey,

    /// Current merkle root of account tree
    pub merkle_root: [u8; 32],

    /// Total number of accounts
    pub account_count: u64,

    /// Total transaction count
    pub transaction_count: u64,

    /// Program bump seed
    pub bump: u8,

    /// Reserved for future use
    pub _reserved: [u64; 16],
}

impl SettlementState {
    pub const LEN: usize = 32 + // authority
                           512 + // verifying_key
                           32 +  // merkle_root
                           8 +   // account_count
                           8 +   // transaction_count
                           1 +   // bump
                           128;  // reserved
}

User Account

#[account]
pub struct UserAccount {
    /// User's public key
    pub owner: Pubkey,

    /// Commitment to account balance
    pub balance_commitment: [u8; 32],

    /// Leaf index in merkle tree
    pub leaf_index: u64,

    /// Account creation timestamp
    pub created_at: i64,

    /// Total deposits
    pub total_deposited: u64,

    /// Total withdrawals
    pub total_withdrawn: u64,

    /// Account status flags
    pub flags: u8,

    /// Reserved
    pub _reserved: [u64; 8],
}

impl UserAccount {
    pub const LEN: usize = 32 +  // owner
                           32 +  // balance_commitment
                           8 +   // leaf_index
                           8 +   // created_at
                           8 +   // total_deposited
                           8 +   // total_withdrawn
                           1 +   // flags
                           64;   // reserved
}

Nullifier Set Account

#[account]
pub struct NullifierSet {
    /// Bloom filter for fast lookups
    pub bloom_filter: [u64; 1024],

    /// Merkle tree of used nullifiers
    pub nullifier_tree_root: [u8; 32],

    /// Number of nullifiers
    pub count: u64,

    /// Reserved
    pub _reserved: [u64; 8],
}

impl NullifierSet {
    pub const LEN: usize = 8192 + // bloom_filter
                           32 +   // nullifier_tree_root
                           8 +    // count
                           64;    // reserved

    pub fn insert(&mut self, nullifier: &[u8; 32]) -> Result<()> {
        // Check if nullifier already exists
        require!(
            !self.contains(nullifier),
            ErrorCode::NullifierAlreadyUsed
        );

        // Add to bloom filter
        let hash1 = hash_to_u64(nullifier, 0);
        let hash2 = hash_to_u64(nullifier, 1);
        let hash3 = hash_to_u64(nullifier, 2);

        self.bloom_filter[(hash1 % 1024) as usize] |= 1 << (hash1 % 64);
        self.bloom_filter[(hash2 % 1024) as usize] |= 1 << (hash2 % 64);
        self.bloom_filter[(hash3 % 1024) as usize] |= 1 << (hash3 % 64);

        // Update count
        self.count += 1;

        Ok(())
    }

    pub fn contains(&self, nullifier: &[u8; 32]) -> bool {
        let hash1 = hash_to_u64(nullifier, 0);
        let hash2 = hash_to_u64(nullifier, 1);
        let hash3 = hash_to_u64(nullifier, 2);

        let check1 = (self.bloom_filter[(hash1 % 1024) as usize] >> (hash1 % 64)) & 1;
        let check2 = (self.bloom_filter[(hash2 % 1024) as usize] >> (hash2 % 64)) & 1;
        let check3 = (self.bloom_filter[(hash3 % 1024) as usize] >> (hash3 % 64)) & 1;

        check1 == 1 && check2 == 1 && check3 == 1
    }
}

---

Account State Management

State Transitions

pub enum StateTransition {
    /// Deposit funds into account
    Deposit {
        user: Pubkey,
        amount: u64,
        new_commitment: [u8; 32],
    },

    /// Settle a transaction
    Transaction {
        nullifier: [u8; 32],
        sender_new_commitment: [u8; 32],
        receiver_new_commitment: [u8; 32],
    },

    /// Withdraw funds from account
    Withdraw {
        user: Pubkey,
        amount: u64,
        new_commitment: [u8; 32],
    },
}

impl StateTransition {
    pub fn apply(
        &self,
        state: &mut SettlementState,
        accounts: &mut AccountInfo,
    ) -> Result<()> {
        match self {
            StateTransition::Deposit { user, amount, new_commitment } => {
                self.apply_deposit(state, accounts, user, *amount, new_commitment)
            }
            StateTransition::Transaction { nullifier, sender_new_commitment, receiver_new_commitment } => {
                self.apply_transaction(state, accounts, nullifier, sender_new_commitment, receiver_new_commitment)
            }
            StateTransition::Withdraw { user, amount, new_commitment } => {
                self.apply_withdraw(state, accounts, user, *amount, new_commitment)
            }
        }
    }

    fn apply_transaction(
        &self,
        state: &mut SettlementState,
        accounts: &mut AccountInfo,
        nullifier: &[u8; 32],
        sender_new_commitment: &[u8; 32],
        receiver_new_commitment: &[u8; 32],
    ) -> Result<()> {
        // 1. Update sender's commitment
        let sender_account = get_user_account_mut(accounts, 0)?;
        sender_account.balance_commitment = *sender_new_commitment;

        // 2. Update receiver's commitment
        let receiver_account = get_user_account_mut(accounts, 1)?;
        receiver_account.balance_commitment = *receiver_new_commitment;

        // 3. Recompute merkle root
        state.merkle_root = compute_new_merkle_root(
            &state.merkle_root,
            &[
                (sender_account.leaf_index, *sender_new_commitment),
                (receiver_account.leaf_index, *receiver_new_commitment),
            ],
        )?;

        // 4. Add nullifier
        let nullifier_set = get_nullifier_set_mut(accounts)?;
        nullifier_set.insert(nullifier)?;

        // 5. Increment transaction count
        state.transaction_count = state.transaction_count
            .checked_add(1)
            .ok_or(ErrorCode::Overflow)?;

        Ok(())
    }
}

Merkle Tree Updates

pub fn compute_new_merkle_root(
    old_root: &[u8; 32],
    updates: &[(u64, [u8; 32])],  // (leaf_index, new_leaf_value)
) -> Result<[u8; 32]> {
    const TREE_DEPTH: usize = 20;  // Supports 2^20 = 1M accounts

    let mut current_root = *old_root;

    for (leaf_index, new_leaf) in updates {
        // Get merkle path for this leaf
        let path = get_merkle_path(*leaf_index)?;

        // Recompute root with new leaf
        let mut current = *new_leaf;
        let mut index = *leaf_index;

        for sibling in path.iter() {
            current = if index & 1 == 0 {
                poseidon_hash(&[current, *sibling])
            } else {
                poseidon_hash(&[*sibling, current])
            };
            index >>= 1;
        }

        current_root = current;
    }

    Ok(current_root)
}

pub fn get_merkle_path(leaf_index: u64) -> Result<Vec<[u8; 32]>> {
    const TREE_DEPTH: usize = 20;
    let mut path = Vec::with_capacity(TREE_DEPTH);

    // Load merkle tree from account data
    let tree_account = get_merkle_tree_account()?;
    let tree_data = tree_account.data.borrow();

    let mut index = leaf_index;
    for level in 0..TREE_DEPTH {
        let sibling_index = index ^ 1;
        let offset = get_node_offset(level, sibling_index);

        let mut sibling = [0u8; 32];
        sibling.copy_from_slice(&tree_data[offset..offset + 32]);

        path.push(sibling);
        index >>= 1;
    }

    Ok(path)
}

---

Settlement Flow

1. Instruction: settle_transaction

#[derive(Accounts)]
pub struct SettleTransaction<'info> {
    #[account(mut)]
    pub settlement_state: Account<'info, SettlementState>,

    #[account(
        mut,
        constraint = sender.owner == sender_authority.key()
    )]
    pub sender: Account<'info, UserAccount>,

    #[account(
        mut,
        constraint = receiver.owner == receiver_authority.key()
    )]
    pub receiver: Account<'info, UserAccount>,

    #[account(mut)]
    pub nullifier_set: Account<'info, NullifierSet>,

    #[account(mut)]
    pub merkle_tree: AccountInfo<'info>,

    pub sender_authority: Signer<'info>,

    /// CHECK: Receiver doesn't need to sign
    pub receiver_authority: AccountInfo<'info>,

    #[account(mut)]
    pub vault: Account<'info, TokenAccount>,

    #[account(
        mut,
        constraint = receiver_token_account.owner == receiver_authority.key()
    )]
    pub receiver_token_account: Account<'info, TokenAccount>,

    pub token_program: Program<'info, Token>,

    pub system_program: Program<'info, System>,
}

pub fn settle_transaction(
    ctx: Context<SettleTransaction>,
    proof: CompressedProof,
    public_inputs: PublicInputs,
) -> Result<()> {
    let state = &mut ctx.accounts.settlement_state;

    // Step 1: Verify ZK proof
    msg!("Verifying ZK proof...");
    verify_groth16_proof(
        &proof,
        &public_inputs,
        &state.verifying_key,
    )?;

    // Step 2: Check nullifier hasn't been used
    msg!("Checking nullifier uniqueness...");
    require!(
        !ctx.accounts.nullifier_set.contains(&public_inputs.nullifier),
        ErrorCode::NullifierAlreadyUsed
    );

    // Step 3: Verify merkle root matches current state
    msg!("Verifying merkle root...");
    require!(
        public_inputs.merkle_root == state.merkle_root,
        ErrorCode::InvalidMerkleRoot
    );

    // Step 4: Decrypt transaction amount (using homomorphic properties)
    msg!("Decrypting transaction amount...");
    let amount = decrypt_amount(
        &public_inputs.encrypted_amount,
        &state.decryption_key,
    )?;

    // Step 5: Update sender's commitment
    msg!("Updating sender commitment...");
    ctx.accounts.sender.balance_commitment = public_inputs.sender_new_commitment;

    // Step 6: Update receiver's commitment
    msg!("Updating receiver commitment...");
    ctx.accounts.receiver.balance_commitment = public_inputs.receiver_new_commitment;

    // Step 7: Update merkle root
    msg!("Updating merkle root...");
    state.merkle_root = compute_new_merkle_root(
        &state.merkle_root,
        &[
            (ctx.accounts.sender.leaf_index, public_inputs.sender_new_commitment),
            (ctx.accounts.receiver.leaf_index, public_inputs.receiver_new_commitment),
        ],
    )?;

    // Step 8: Add nullifier to set
    msg!("Adding nullifier...");
    ctx.accounts.nullifier_set.insert(&public_inputs.nullifier)?;

    // Step 9: Execute SPL token transfer
    msg!("Executing token transfer...");
    let vault_seeds = &[
        b"vault",
        state.authority.as_ref(),
        &[state.bump],
    ];
    let signer = &[&vault_seeds[..]];

    let cpi_accounts = Transfer {
        from: ctx.accounts.vault.to_account_info(),
        to: ctx.accounts.receiver_token_account.to_account_info(),
        authority: state.to_account_info(),
    };

    let cpi_program = ctx.accounts.token_program.to_account_info();
    let cpi_ctx = CpiContext::new_with_signer(cpi_program, cpi_accounts, signer);

    token::transfer(cpi_ctx, amount)?;

    // Step 10: Increment transaction count
    state.transaction_count = state.transaction_count
        .checked_add(1)
        .ok_or(ErrorCode::Overflow)?;

    // Step 11: Emit settlement event
    emit!(TransactionSettled {
        nullifier: public_inputs.nullifier,
        sender: ctx.accounts.sender.owner,
        receiver: ctx.accounts.receiver.owner,
        commitment: public_inputs.sender_new_commitment,
        timestamp: Clock::get()?.unix_timestamp,
        transaction_id: state.transaction_count,
    });

    msg!("Transaction settled successfully");
    Ok(())
}

2. Proof Verification

pub fn verify_groth16_proof(
    proof: &CompressedProof,
    public_inputs: &PublicInputs,
    vk: &VerifyingKey,
) -> Result<()> {
    // Deserialize proof points
    let proof_a = decompress_g1(&proof.a)?;
    let proof_b = decompress_g2(&proof.b)?;
    let proof_c = decompress_g1(&proof.c)?;

    // Prepare public inputs
    let inputs = [
        public_inputs.nullifier_scalar(),
        public_inputs.commitment_scalar(),
        public_inputs.merkle_root_scalar(),
        public_inputs.policy_hash_scalar(),
    ];

    // Compute linear combination L = Σ(input_i * vk.gamma_abc[i+1]) + vk.gamma_abc[0]
    let mut l = vk.gamma_abc_g1[0];
    for (input, base) in inputs.iter().zip(vk.gamma_abc_g1.iter().skip(1)) {
        l = l.add(&base.mul(input));
    }

    // Verify pairing equation: e(A, B) = e(α, β) * e(L, γ) * e(C, δ)
    let lhs = pairing(&proof_a, &proof_b);

    let rhs = pairing(&vk.alpha_g1, &vk.beta_g2)
        .mul(&pairing(&l, &vk.gamma_g2))
        .mul(&pairing(&proof_c, &vk.delta_g2));

    require!(lhs == rhs, ErrorCode::InvalidProof);

    Ok(())
}

3. Amount Decryption

pub fn decrypt_amount(
    encrypted: &EncryptedAmount,
    key: &DecryptionKey,
) -> Result<u64> {
    // Encrypted amount is an ElGamal ciphertext: (C₁, C₂)
    // C₁ = r·G
    // C₂ = m·G + r·P (where P is public key)

    // Decrypt: m·G = C₂ - key·C₁
    let mg = encrypted.c2.sub(&encrypted.c1.mul(key.scalar));

    // Discrete log to recover amount (brute force for small amounts)
    let amount = solve_discrete_log(&mg, MAX_AMOUNT)?;

    Ok(amount)
}

fn solve_discrete_log(
    mg: &G1Point,
    max_value: u64,
) -> Result<u64> {
    // Baby-step giant-step algorithm
    const BATCH_SIZE: u64 = 10_000;
    let num_batches = (max_value + BATCH_SIZE - 1) / BATCH_SIZE;

    // Baby steps: store m·G for m = 0 to BATCH_SIZE
    let mut baby_steps = HashMap::new();
    let g = G1Point::generator();
    let mut current = G1Point::identity();

    for i in 0..BATCH_SIZE {
        baby_steps.insert(current, i);
        current = current.add(&g);
    }

    // Giant steps: check mg - (k·BATCH_SIZE)·G
    let giant_step = g.mul(&Scalar::from(BATCH_SIZE));
    let mut current = *mg;

    for k in 0..num_batches {
        if let Some(&m) = baby_steps.get(&current) {
            return Ok(k * BATCH_SIZE + m);
        }
        current = current.sub(&giant_step);
    }

    Err(ErrorCode::DecryptionFailed.into())
}

---

Cross-Program Invocations

SPL Token Integration

use anchor_spl::token::{self, Token, TokenAccount, Transfer};

pub fn transfer_tokens<'info>(
    from: &Account<'info, TokenAccount>,
    to: &Account<'info, TokenAccount>,
    authority: &AccountInfo<'info>,
    token_program: &Program<'info, Token>,
    amount: u64,
    signer_seeds: &[&[&[u8]]],
) -> Result<()> {
    let cpi_accounts = Transfer {
        from: from.to_account_info(),
        to: to.to_account_info(),
        authority: authority.clone(),
    };

    let cpi_program = token_program.to_account_info();
    let cpi_ctx = CpiContext::new_with_signer(
        cpi_program,
        cpi_accounts,
        signer_seeds,
    );

    token::transfer(cpi_ctx, amount)?;

    Ok(())
}

Associated Token Account Creation

use anchor_spl::associated_token::AssociatedToken;

pub fn create_associated_token_account<'info>(
    payer: &Signer<'info>,
    associated_token: &AccountInfo<'info>,
    authority: &AccountInfo<'info>,
    mint: &Account<'info, Mint>,
    system_program: &Program<'info, System>,
    token_program: &Program<'info, Token>,
    associated_token_program: &Program<'info, AssociatedToken>,
) -> Result<()> {
    let cpi_accounts = anchor_spl::associated_token::Create {
        payer: payer.to_account_info(),
        associated_token: associated_token.clone(),
        authority: authority.clone(),
        mint: mint.to_account_info(),
        system_program: system_program.to_account_info(),
        token_program: token_program.to_account_info(),
    };

    let cpi_program = associated_token_program.to_account_info();
    let cpi_ctx = CpiContext::new(cpi_program, cpi_accounts);

    anchor_spl::associated_token::create(cpi_ctx)?;

    Ok(())
}

---

State Synchronization

Off-Chain Indexer

use solana_client::rpc_client::RpcClient;
use solana_client::rpc_config::RpcTransactionLogsFilter;
use solana_sdk::signature::Signature;

pub struct TransactionIndexer {
    rpc_client: RpcClient,
    program_id: Pubkey,
    db: Database,
}

impl TransactionIndexer {
    pub async fn sync(&mut self) -> Result<()> {
        // Get transaction logs for our program
        let logs = self.rpc_client.get_logs(
            &RpcTransactionLogsFilter::Mentions(vec![
                self.program_id.to_string()
            ])
        )?;

        for log_result in logs {
            if let Some(signature) = log_result.signature {
                self.process_transaction(&signature).await?;
            }
        }

        Ok(())
    }

    async fn process_transaction(
        &mut self,
        signature: &Signature,
    ) -> Result<()> {
        // Fetch transaction details
        let tx = self.rpc_client.get_transaction(
            signature,
            solana_client::rpc_config::RpcTransactionConfig {
                encoding: Some(UiTransactionEncoding::Json),
                commitment: Some(CommitmentConfig::confirmed()),
                max_supported_transaction_version: Some(0),
            }
        )?;

        // Parse transaction
        if let Some(meta) = tx.transaction.meta {
            // Check if transaction succeeded
            if meta.status.is_ok() {
                // Extract and store event data
                if let Some(logs) = meta.log_messages {
                    self.parse_logs(&logs).await?;
                }
            }
        }

        Ok(())
    }

    async fn parse_logs(&mut self, logs: &[String]) -> Result<()> {
        for log in logs {
            if log.contains("TransactionSettled") {
                // Parse event from log
                let event: TransactionSettled = parse_event(log)?;

                // Store in database
                self.db.insert_transaction(Transaction {
                    nullifier: event.nullifier,
                    sender: event.sender,
                    receiver: event.receiver,
                    commitment: event.commitment,
                    timestamp: event.timestamp,
                    transaction_id: event.transaction_id,
                }).await?;
            }
        }

        Ok(())
    }
}

WebSocket Event Stream

use solana_client::nonblocking::pubsub_client::PubsubClient;

pub async fn subscribe_to_events(
    program_id: Pubkey,
    event_handler: impl Fn(TransactionSettled) + Send + 'static,
) -> Result<()> {
    let ws_url = "wss://api.mainnet-beta.solana.com";
    let pubsub_client = PubsubClient::new(ws_url).await?;

    // Subscribe to program logs
    let (mut stream, unsubscribe) = pubsub_client
        .logs_subscribe(
            RpcTransactionLogsFilter::Mentions(vec![program_id.to_string()]),
            RpcTransactionLogsConfig {
                commitment: Some(CommitmentConfig::confirmed()),
            },
        )
        .await?;

    // Process events
    tokio::spawn(async move {
        while let Some(log_result) = stream.next().await {
            if let Ok(log) = log_result {
                for log_msg in log.value.logs {
                    if log_msg.contains("TransactionSettled") {
                        if let Ok(event) = parse_event(&log_msg) {
                            event_handler(event);
                        }
                    }
                }
            }
        }
    });

    Ok(())
}

---

Finality & Rollbacks

Commitment Levels

Solana provides three commitment levels:

1. Processed: Transaction included in a block

   • Latency: ~400ms

   • Risk: May be rolled back

2. Confirmed: Block confirmed by supermajority

   • Latency: ~1-2s

   • Risk: Very low rollback probability

3. Finalized: Block is ancient enough to be finalized

   • Latency: ~30s

   • Risk: Zero rollback probability

Handling Rollbacks

pub struct TransactionMonitor {
    rpc_client: RpcClient,
    pending_transactions: HashMap<Signature, PendingTransaction>,
}

#[derive(Debug)]
struct PendingTransaction {
    signature: Signature,
    commitment: CommitmentLevel,
    retry_count: u8,
    created_at: SystemTime,
}

impl TransactionMonitor {
    pub async fn monitor_transaction(
        &mut self,
        signature: Signature,
    ) -> Result<TransactionStatus> {
        let mut attempts = 0;
        const MAX_ATTEMPTS: u8 = 30;

        loop {
            attempts += 1;

            // Check transaction status
            let status = self.rpc_client.get_signature_status(
                &signature
            )?.ok_or(ErrorCode::TransactionNotFound)?;

            match status {
                Ok(_) => {
                    // Transaction succeeded
                    // Wait for finality
                    self.wait_for_finality(&signature).await?;
                    return Ok(TransactionStatus::Finalized);
                }
                Err(e) => {
                    // Transaction failed
                    if attempts >= MAX_ATTEMPTS {
                        return Err(ErrorCode::TransactionFailed.into());
                    }

                    // Retry with higher priority fee
                    let new_sig = self.retry_transaction(&signature).await?;
                    signature = new_sig;
                }
            }

            // Wait before next attempt
            tokio::time::sleep(Duration::from_secs(2)).await;
        }
    }

    async fn wait_for_finality(
        &self,
        signature: &Signature,
    ) -> Result<()> {
        loop {
            let status = self.rpc_client.get_signature_status_with_commitment(
                signature,
                CommitmentConfig::finalized(),
            )?;

            if status.is_some() {
                return Ok(());
            }

            tokio::time::sleep(Duration::from_secs(1)).await;
        }
    }
}

---

Performance Optimization

Parallel Transaction Processing

use rayon::prelude::*;

pub async fn process_batch(
    transactions: Vec<PendingTransaction>,
) -> Result<Vec<ProcessedTransaction>> {
    // Split into batches of 10
    let batches: Vec<_> = transactions
        .chunks(10)
        .collect();

    // Process batches in parallel
    let results: Vec<_> = batches
        .par_iter()
        .map(|batch| {
            batch.iter()
                .map(|tx| process_transaction(tx))
                .collect::<Vec<_>>()
        })
        .flatten()
        .collect();

    Ok(results)
}

Compute Unit Optimization

use solana_sdk::compute_budget::ComputeBudgetInstruction;

pub fn create_optimized_transaction(
    instructions: Vec<Instruction>,
    payer: &Pubkey,
    recent_blockhash: Hash,
) -> Transaction {
    let mut all_instructions = vec![
        // Request higher compute units
        ComputeBudgetInstruction::set_compute_unit_limit(400_000),

        // Set priority fee (micro-lamports per compute unit)
        ComputeBudgetInstruction::set_compute_unit_price(10_000),
    ];

    all_instructions.extend(instructions);

    Transaction::new_with_payer(
        &all_instructions,
        Some(payer),
    )
}

---

Related Documentation

• ZK Proof System

• Solana Program Security

• Performance Benchmarks

---

Last Updated: January 2026 Version: 1.0.0 Authors: StyxPay Engineering Team