Policy

Simulate policy rules, write receipts, attest policy hashes, check invariants, and query policy via CPI.

Pre-alpha — not production ready

aura-sdk targets Solana devnet only. APIs may change without notice. Do not use for real funds until a stable release and audit are published.

simulate_policy

Run the full policy evaluation against a treasury without committing any state changes.

// Build only
let instruction = client.simulate_policy_instruction(accounts, args);

// Build + send
client.simulate_policy(&payer, accounts, args)?;

use aura_sdk::pda::derive_policy_simulation_pda;

let simulation_id: u64 = 1;
let (simulation_result, _) = derive_policy_simulation_pda(&treasury, simulation_id, &client.program_id());

client.simulate_policy(
    &payer,
    aura_core::accounts::SimulatePolicy {
        payer: payer.pubkey(),
        treasury,
        operator_role: None,
        simulation_result,
        system_program: anchor_lang::system_program::ID,
    },
    aura_core::SimulatePolicyArgs {
        simulation_id,
        amount_usd: 500,
        target_chain: 2,
        tx_type: 0,
        protocol_id: None,
        recipient_or_contract: "0xdeadbeef...".to_string(),
        counterparty_risk_score: None,
        quote_age_secs: None,
        expected_output_usd: None,
        actual_output_usd: None,
        current_timestamp: now,
    },
)?;

write_policy_receipt

Store an immutable snapshot of the policy decision for the current pending proposal.

// Build only
let instruction = client.write_policy_receipt_instruction(accounts, args);

// Build + send
client.write_policy_receipt(&payer, accounts, args)?;

use aura_sdk::pda::derive_policy_receipt_pda;

let (receipt, _) = derive_policy_receipt_pda(&treasury, proposal_id, &client.program_id());

client.write_policy_receipt(
    &payer,
    aura_core::accounts::WritePolicyReceipt {
        payer: payer.pubkey(),
        treasury,
        receipt,
        attestation: None,
        system_program: anchor_lang::system_program::ID,
    },
    aura_core::WritePolicyReceiptArgs { proposal_id, timestamp: now },
)?;

apply_policy_preset

Apply a named policy preset to the treasury, replacing the current PolicyConfig.

// Build only
let instruction = client.apply_policy_preset_instruction(accounts, args);

// Build + send
client.apply_policy_preset(&owner, accounts, args)?;

client.apply_policy_preset(
    &owner,
    aura_core::accounts::ApplyPolicyPreset { owner: owner.pubkey(), treasury },
    aura_core::ApplyPolicyPresetArgs { preset_kind: 0, timestamp: now },
)?;

attest_policy

Sign and store a hash of the current policy configuration.

// Build only
let instruction = client.attest_policy_instruction(accounts, args);

// Build + send — payer and attester may be different keypairs
client.attest_policy(&payer, &attester, accounts, args)?;

use aura_sdk::pda::derive_policy_attestation_pda;

let treasury_account = client.get_treasury_account(&treasury)?;
let policy_version = treasury_account.current_policy_version as u64;
let (attestation, _) = derive_policy_attestation_pda(&treasury, &attester.pubkey(), policy_version, &client.program_id());

client.attest_policy(
    &payer,
    &attester,
    aura_core::accounts::AttestPolicy {
        payer: payer.pubkey(),
        attester: attester.pubkey(),
        treasury,
        attestation,
        system_program: anchor_lang::system_program::ID,
    },
    aura_core::AttestPolicyArgs { policy_version, timestamp: now },
)?;

check_invariants

Run on-chain invariant checks against the treasury and store the result.

// Build only
let instruction = client.check_invariants_instruction(accounts, args);

// Build + send
client.check_invariants(&payer, accounts, args)?;

use aura_sdk::pda::derive_invariant_report_pda;

let report_id: u64 = 1;
let (report, _) = derive_invariant_report_pda(&treasury, report_id, &client.program_id());

client.check_invariants(
    &payer,
    aura_core::accounts::CheckInvariants {
        payer: payer.pubkey(),
        treasury,
        report,
        system_program: anchor_lang::system_program::ID,
    },
    aura_core::CheckInvariantsArgs { report_id, timestamp: now },
)?;

check_policy_cpi

Allow an external program to query AURA policy for a treasury via CPI.

// Build only
let instruction = client.check_policy_cpi_instruction(accounts, args);

// Build + send
client.check_policy_cpi(&fee_payer, accounts, args)?;

Budget

Budget envelopes, exposure groups, and approval ladders.

Execution

Drive proposals through policy and dWallet signing.