@sip-protocol/sdk 0.11.0 → 0.12.0

package/dist/{index-X8qPQdp6.d.ts → index-rqQpCeVM.d.ts}

@@ -1,5 +1,5 @@
 import * as _solana_web3_js from '@solana/web3.js';
-import { Connection, PublicKey, Transaction, VersionedTransaction, TransactionInstruction, Keypair } from '@solana/web3.js';
+import { Connection, PublicKey, Transaction, VersionedTransaction, Keypair, TransactionInstruction } from '@solana/web3.js';
 import * as _sip_protocol_types from '@sip-protocol/types';
 import { ZKProof, ViewingKey, SingleProof, ComposedProof, ProofSystem, HexString, CompositionEventListener, VerificationResult as VerificationResult$1, IndividualVerificationResult, ProofAggregationStrategy, ProofCompositionConfig, CompositionResult, PrivacyLevel, ShieldedIntent, CreateIntentParams, TrackedIntent, OneClickConfig, OneClickToken, OneClickQuoteRequest, OneClickQuoteResponse, OneClickDepositSubmit, OneClickStatusResponse, OneClickWithdrawal, StealthAddress, StealthAddressRecovery, StealthMetaAddress, ChainId as ChainId$1, DefuseAssetId, Asset, OneClickSwapStatus, Quote as Quote$1, FulfillmentResult, EncryptedTransaction, Commitment, Hash, IntentInput, IntentOutput, SIPSolver, Solver, SolverCapabilities, SolverVisibleIntent, SolverQuote, FulfillmentStatus, ZcashConfig, ZcashAddressInfo, ZcashNewAccount, ZcashReceiverType, ZcashAccountAddress, ZcashAccountBalance, ZcashUnspentNote, ZcashShieldedSendParams, ZcashOperation, ZcashBlockHeader, ZcashBlock, ZcashBlockchainInfo, ZcashNetworkInfo, StablecoinSymbol, PaymentPurpose, ShieldedPayment, CreatePaymentParams, TrackedPayment, CreateTreasuryParams, TreasuryConfig as TreasuryConfig$1, TreasuryMember, CreatePaymentProposalParams, TreasuryProposal, CreateBatchProposalParams, AuditorViewingKey, TreasuryBalance, CreateComplianceConfigParams, ComplianceConfig, RegisterAuditorParams, AuditorRegistration, AuditScope, DisclosedTransaction, DisclosureRequest, GenerateReportParams, ComplianceReport, ComplianceMetrics, AuditLogEntry as AuditLogEntry$1, WinnerResult, WinnerProof, WinnerVerification, CreatePrivateOwnershipParams, PrivateNFTOwnership, ProveOwnershipParams, OwnershipProof, OwnershipVerification, TransferPrivatelyParams, TransferResult, NFTTransfer, OwnedNFT, WalletAdapter as WalletAdapter$1, WalletConnectionState, WalletEventType, WalletEventHandler, WalletEvent, Signature, UnsignedTransaction, SignedTransaction, TransactionReceipt, WalletErrorCodeType, PrivateWalletAdapter, WalletAdapterFactory, WalletRegistryEntry, WalletInfo, ChainType } from '@sip-protocol/types';
 import { d as ProofProvider, b as ProofFramework, F as FundingProofParams, P as ProofResult, V as ValidityProofParams, a as FulfillmentProofParams } from './noir-CwPIyBLj.js';
@@ -15224,6 +15224,16 @@ declare const MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
  * Format: SIP:1:<ephemeral_pubkey_base58>:<view_tag_hex>
  */
 declare const SIP_MEMO_PREFIX = "SIP:1:";
+/**
+ * Canonical EIP-5564 (SIP:2) announcement memo prefix — emitted by new sends.
+ * Format: SIP:2:<ephemeral_pubkey_base58>:<view_tag_hex>[:<stealth_address_base58>]
+ */
+declare const SIP_MEMO_PREFIX_V2 = "SIP:2:";
+/**
+ * Version-agnostic prefix for filtering announcement logs during scanning.
+ * Matches both SIP:1 (legacy) and SIP:2 (canonical) announcements.
+ */
+declare const SIP_MEMO_PREFIX_ANY = "SIP:";
 /**
  * Get explorer URL for a transaction
  */
@@ -15589,6 +15599,8 @@ interface SolanaScanResult {
     stealthAddress: string;
     /** Ephemeral public key from the sender (base58) */
     ephemeralPublicKey: string;
+    /** Announcement scheme version ('1' legacy | '2' canonical) — pass to claim */
+    version: '1' | '2';
     /** Amount received (in token's smallest unit) */
     amount: bigint;
     /** Token mint address */
@@ -17154,765 +17166,962 @@ declare function createNetworkPrivacyClient(config?: NetworkPrivacyConfig): Prom
 }>;
 
 /**
- * Solana Noir Verifier Types
+ * Relayer fee model for gasless cash-out.
  *
- * Type definitions for verifying Noir ZK proofs on Solana.
+ * The relayer fronts the SOL transaction fee on behalf of a stealth recipient
+ * and recovers its cost from the SPL tokens being cashed out (fee-from-claim).
+ * The fee is `max(flatFloor, amount * bps / 10_000)`: the floor guarantees the
+ * fixed SOL gas cost is covered even on tiny claims; bps scales on large ones.
+ * No price oracle in v1 — the floor is set in the token's base units.
+ */
+/** Relayer fee configuration (per token mint). */
+interface RelayerFeeConfig {
+    /** Flat floor fee in the token's base units. Guarantees gas coverage on small claims. */
+    flatFloor: bigint;
+    /** Basis points of the claim amount (1 bps = 0.01%). e.g. 10 = 0.1%. */
+    bps: number;
+}
+/**
+ * Compute the relayer fee for a claim.
+ *
+ * @param amount - Gross amount available in the stealth token account (base units)
+ * @param config - Fee model
+ * @returns Fee in the token's base units (always >= flatFloor)
+ * @throws If `bps` is negative or non-integer, or if `amount` is negative, or if flatFloor is negative
+ */
+declare function computeRelayerFee(amount: bigint, config: RelayerFeeConfig): bigint;
+
+/**
+ * Jito Relayer for SIP Protocol
+ *
+ * Enables gas abstraction for Solana shielded transactions using Jito's MEV infrastructure.
+ * The relayer submits transaction bundles on behalf of users, paying gas fees and breaking
+ * the direct link between the user's wallet and the privacy transaction.
+ *
+ * ## Why Jito?
+ *
+ * 1. **Native Solana**: Jito is battle-tested MEV infrastructure on Solana
+ * 2. **No Dedicated Server**: Uses Jito's network, no VPS maintenance needed
+ * 3. **Bundle Guarantees**: Atomic execution, no partial failures
+ * 4. **Lower Regulatory Risk**: Relayer only handles gas, not asset movement
  *
  * ## Architecture
  *
  * ```
- * ┌─────────────────────────────────────────────────────────────┐
- * │  NOIR PROOF FLOW ON SOLANA                                  │
- * │                                                             │
- * │  1. Generate proof (BrowserNoirProvider / NoirProofProvider)│
- * │  2. Serialize for Solana (SolanaNoirVerifier)               │
- * │  3. Submit to Solana program (verify instruction)           │
- * │  4. On-chain verification (ZK Token Proof / Custom)         │
- * └─────────────────────────────────────────────────────────────┘
+ * ┌─────────────────────────────────────────────────────────────────────────────┐
+ * │  GAS ABSTRACTION FLOW                                                       │
+ * │                                                                             │
+ * │  ┌─────────┐      ┌───────────────┐      ┌───────────┐      ┌──────────┐  │
+ * │  │  User   │ ──▶  │ Sign TX       │ ──▶  │ Jito      │ ──▶  │ Solana   │  │
+ * │  │  Wallet │      │ (no SOL fee)  │      │ Relayer   │      │ Network  │  │
+ * │  └─────────┘      └───────────────┘      └───────────┘      └──────────┘  │
+ * │                                                │                          │
+ * │                                                ▼                          │
+ * │                                          Relayer pays                     │
+ * │                                          gas from tip                     │
+ * └─────────────────────────────────────────────────────────────────────────────┘
  * ```
  *
- * @module solana/noir-verifier-types
+ * ## Fee Model
+ *
+ * The relayer takes a small tip from the transaction (configurable, typically 0.1-0.5%)
+ * to cover gas costs and operational overhead.
+ *
+ * @see https://jito-foundation.gitbook.io/mev/
+ * @see https://jito-labs.github.io/jito-ts/
  */
 
 /**
- * Supported Noir circuit types for Solana verification
+ * Jito Block Engine endpoints
+ * @see https://jito-foundation.gitbook.io/mev/searcher-resources/block-engine
  */
-type NoirCircuitType = 'funding' | 'validity' | 'fulfillment';
+declare const JITO_BLOCK_ENGINES: {
+    readonly mainnet: {
+        readonly amsterdam: "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1";
+        readonly frankfurt: "https://frankfurt.mainnet.block-engine.jito.wtf/api/v1";
+        readonly ny: "https://ny.mainnet.block-engine.jito.wtf/api/v1";
+        readonly tokyo: "https://tokyo.mainnet.block-engine.jito.wtf/api/v1";
+    };
+};
 /**
- * Circuit metadata for verification key generation
+ * Jito tip accounts (one must receive the tip)
+ * @see https://jito-foundation.gitbook.io/mev/searcher-resources/tip-accounts
  */
-interface CircuitMetadata {
-    /** Circuit type identifier */
-    type: NoirCircuitType;
-    /** Number of public inputs */
-    publicInputCount: number;
-    /** Approximate constraint count */
-    constraintCount: number;
-    /** Circuit version hash */
-    versionHash: string;
-}
+declare const JITO_TIP_ACCOUNTS: readonly ["96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5", "HFqU5x63VTqvQss8hp11i4bVmkekGTo46ibhvdrPnSVX", "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY", "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49", "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh", "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt", "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL", "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT"];
 /**
- * Circuit metadata for all supported circuits
+ * Default configuration values
  */
-declare const CIRCUIT_METADATA: Record<NoirCircuitType, CircuitMetadata>;
+declare const JITO_DEFAULTS: {
+    /** Default tip in lamports (0.001 SOL) */
+    readonly tipLamports: 1000000;
+    /** Maximum bundle size */
+    readonly maxBundleSize: 5;
+    /** Bundle submission timeout (ms) */
+    readonly submissionTimeout: 30000;
+    /** Confirmation timeout (ms) */
+    readonly confirmationTimeout: 60000;
+    /** Default retry attempts */
+    readonly maxRetries: 3;
+};
 /**
- * Verification key for Solana on-chain verification
- *
- * Contains the cryptographic parameters needed to verify proofs on-chain.
+ * Jito relayer configuration
  */
-interface SolanaVerificationKey {
-    /** Circuit type this key is for */
-    circuitType: NoirCircuitType;
-    /** Serialized verification key bytes */
-    keyBytes: Uint8Array;
-    /** Key hash for integrity check */
-    keyHash: string;
-    /** Number of public inputs expected */
-    publicInputCount: number;
-    /** Solana account address where key is stored (if deployed) */
-    accountAddress?: string;
+interface JitoRelayerConfig {
+    /** Jito block engine endpoint */
+    blockEngineUrl?: string;
+    /** Solana RPC URL */
+    rpcUrl?: string;
+    /** Default tip amount in lamports */
+    defaultTipLamports?: number;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Maximum retries for bundle submission */
+    maxRetries?: number;
+    /** Submission timeout in ms */
+    submissionTimeout?: number;
 }
 /**
- * Solana-serialized proof ready for on-chain verification
+ * Bundle submission request
  */
-interface SolanaSerializedProof {
-    /** Original proof type */
-    circuitType: NoirCircuitType;
-    /** Proof bytes in Solana-compatible format */
-    proofBytes: Uint8Array;
-    /** Public inputs as Field elements (32 bytes each) */
-    publicInputs: Uint8Array[];
-    /** Total serialized size in bytes */
-    totalSize: number;
+interface JitoBundleRequest {
+    /** Transactions to include in bundle */
+    transactions: (Transaction | VersionedTransaction)[];
+    /** Tip amount in lamports */
+    tipLamports?: number;
+    /** Tip payer keypair */
+    tipPayer: Keypair;
+    /** Whether to wait for confirmation */
+    waitForConfirmation?: boolean;
 }
 /**
- * Proof verification result from Solana
+ * Bundle submission result
  */
-interface SolanaVerificationResult {
-    /** Whether the proof is valid */
-    valid: boolean;
-    /** Transaction signature if submitted on-chain */
-    signature?: string;
-    /** Slot number of verification */
+interface JitoBundleResult {
+    /** Bundle UUID */
+    bundleId: string;
+    /** Transaction signatures in bundle */
+    signatures: string[];
+    /** Submission status */
+    status: 'submitted' | 'landed' | 'failed' | 'timeout';
+    /** Slot where bundle landed (if confirmed) */
     slot?: number;
-    /** Compute units used */
-    computeUnits?: number;
-    /** Error message if verification failed */
+    /** Error message if failed */
     error?: string;
+    /** Actual tip paid in lamports */
+    tipPaid: number;
 }
 /**
- * Solana instruction for proof verification
+ * Relayed transaction request
  */
-interface SolanaVerifyInstruction {
-    /** Program ID to call */
-    programId: string;
-    /** Instruction data */
-    data: Uint8Array;
-    /** Account keys required */
-    keys: SolanaAccountMeta[];
+interface RelayedTransactionRequest {
+    /** Signed transaction to relay */
+    transaction: Transaction | VersionedTransaction;
+    /** Tip amount in lamports (paid by relayer, recovered from user) */
+    tipLamports?: number;
+    /** Keypair that pays the Jito tip. Required for the Jito-bundle path to land. */
+    tipPayer?: Keypair;
+    /** Whether to wait for confirmation */
+    waitForConfirmation?: boolean;
 }
 /**
- * Account metadata for Solana instruction
+ * Relayed transaction result
  */
-interface SolanaAccountMeta {
-    /** Account public key */
-    pubkey: string;
-    /** Is signer */
-    isSigner: boolean;
-    /** Is writable */
-    isWritable: boolean;
+interface RelayedTransactionResult {
+    /** Transaction signature */
+    signature: string;
+    /** Bundle ID if submitted via Jito */
+    bundleId?: string;
+    /** Submission status */
+    status: 'submitted' | 'confirmed' | 'failed';
+    /** Slot where transaction landed */
+    slot?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Whether relayer was used or fell back to direct submission */
+    relayed: boolean;
 }
 /**
- * Network configuration for Solana
- */
-type SolanaNetwork = 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
-/**
- * Solana Noir Verifier configuration
+ * Jito relayer error codes
  */
-interface SolanaNoirVerifierConfig {
-    /**
-     * Solana network to use
-     * @default 'devnet'
-     */
-    network?: SolanaNetwork;
-    /**
-     * Custom RPC endpoint URL
-     * If not provided, uses default for network
-     */
-    rpcUrl?: string;
-    /**
-     * Verification program ID
-     * Uses native ZK Token Proof program by default
-     */
-    programId?: string;
-    /**
-     * Enable verbose logging
-     * @default false
-     */
-    verbose?: boolean;
-    /**
-     * Commitment level for transactions
-     * @default 'confirmed'
-     */
-    commitment?: 'processed' | 'confirmed' | 'finalized';
-    /**
-     * Maximum compute units for verification
-     * @default 400000
-     */
-    maxComputeUnits?: number;
+declare enum JitoRelayerErrorCode {
+    BUNDLE_SUBMISSION_FAILED = "BUNDLE_SUBMISSION_FAILED",
+    BUNDLE_TIMEOUT = "BUNDLE_TIMEOUT",
+    BUNDLE_INVALID = "BUNDLE_INVALID",
+    INSUFFICIENT_TIP = "INSUFFICIENT_TIP",
+    CONNECTION_ERROR = "CONNECTION_ERROR",
+    RATE_LIMITED = "RATE_LIMITED",
+    INVALID_TRANSACTION = "INVALID_TRANSACTION"
 }
 /**
- * Default RPC URLs for each network
- * Localnet is configurable via SOLANA_LOCALNET_RPC environment variable
+ * Jito relayer error
  */
-declare const DEFAULT_RPC_URLS: Record<SolanaNetwork, string>;
+declare class JitoRelayerError extends Error {
+    readonly code: JitoRelayerErrorCode;
+    readonly details?: unknown | undefined;
+    constructor(code: JitoRelayerErrorCode, message: string, details?: unknown | undefined);
+}
 /**
- * Native Solana ZK proof program IDs
+ * Jito Relayer for gas abstraction
  *
- * Note: These are the native Solana programs for ZK proof verification.
- * For custom Noir circuits, a dedicated verifier program would be needed.
- */
-declare const SOLANA_ZK_PROGRAM_IDS: {
-    /** ZK Token Proof Program (native) */
-    readonly ZK_TOKEN_PROOF: "ZkTokenProof1111111111111111111111111111111";
-    /** ZK ElGamal Proof Program (native) */
-    readonly ZK_ELGAMAL_PROOF: "ZkE1Gama1Proof11111111111111111111111111111";
-    /** Custom SIP Noir Verifier (TBD - to be deployed) */
-    readonly SIP_NOIR_VERIFIER: "SIPNoirVerifier1111111111111111111111111";
-};
-/**
- * Error codes for Solana Noir verification
- */
-declare enum SolanaNoirErrorCode {
-    /** Invalid proof format */
-    INVALID_PROOF_FORMAT = "INVALID_PROOF_FORMAT",
-    /** Invalid public inputs */
-    INVALID_PUBLIC_INPUTS = "INVALID_PUBLIC_INPUTS",
-    /** Verification failed on-chain */
-    VERIFICATION_FAILED = "VERIFICATION_FAILED",
-    /** Network error */
-    NETWORK_ERROR = "NETWORK_ERROR",
-    /** Insufficient compute units */
-    INSUFFICIENT_COMPUTE = "INSUFFICIENT_COMPUTE",
-    /** Verification key not found */
-    VKEY_NOT_FOUND = "VKEY_NOT_FOUND",
-    /** Unsupported circuit type */
-    UNSUPPORTED_CIRCUIT = "UNSUPPORTED_CIRCUIT",
-    /** Transaction failed */
-    TRANSACTION_FAILED = "TRANSACTION_FAILED"
-}
-/**
- * Solana Noir verification error
+ * Submits Solana transactions via Jito's MEV infrastructure,
+ * enabling gas abstraction for privacy transactions.
+ *
+ * @example
+ * ```typescript
+ * import { JitoRelayer } from '@sip-protocol/sdk'
+ *
+ * const relayer = new JitoRelayer({
+ *   blockEngineUrl: 'https://ny.mainnet.block-engine.jito.wtf/api/v1',
+ * })
+ *
+ * // Submit a signed transaction via the relayer (tipPayer is required for the bundle to land)
+ * const result = await relayer.relayTransaction({
+ *   transaction: signedTx,
+ *   tipLamports: 10_000, // 0.00001 SOL tip
+ *   tipPayer: relayerKeypair,
+ * })
+ *
+ * console.log('Transaction relayed:', result.signature)
+ * ```
  */
-declare class SolanaNoirError extends Error {
-    readonly code: SolanaNoirErrorCode;
-    readonly details?: Record<string, unknown> | undefined;
-    constructor(message: string, code: SolanaNoirErrorCode, details?: Record<string, unknown> | undefined);
+declare class JitoRelayer {
+    private readonly connection;
+    private readonly blockEngineUrl;
+    private readonly defaultTipLamports;
+    private readonly debug;
+    private readonly maxRetries;
+    private readonly submissionTimeout;
+    constructor(config?: JitoRelayerConfig);
+    /** Encode a 64-byte ed25519 signature as a base58 string (Solana canonical form). */
+    static encodeSignature(sig: Uint8Array): string;
+    /**
+     * Submit a bundle of transactions to Jito
+     *
+     * @param request - Bundle request with transactions and tip
+     * @returns Bundle submission result
+     */
+    submitBundle(request: JitoBundleRequest): Promise<JitoBundleResult>;
+    /**
+     * Relay a single transaction via Jito
+     *
+     * This is the main method for gas abstraction - submit a transaction
+     * through the relayer instead of paying gas directly.
+     *
+     * @param request - Transaction to relay
+     * @returns Relay result
+     */
+    relayTransaction(request: RelayedTransactionRequest): Promise<RelayedTransactionResult>;
+    /**
+     * Check if Jito relayer is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Get current tip floor (minimum tip for inclusion)
+     */
+    getTipFloor(): Promise<number>;
+    /**
+     * Get a random tip account
+     */
+    getRandomTipAccount(): PublicKey;
+    /**
+     * Create tip instruction
+     */
+    private createTipInstruction;
+    /**
+     * Prepare transactions for bundle submission
+     */
+    private prepareBundleTransactions;
+    /**
+     * Send bundle to Jito block engine
+     */
+    private sendBundle;
+    /**
+     * Wait for bundle confirmation
+     */
+    private waitForBundleConfirmation;
+    /**
+     * Get bundle status from Jito
+     */
+    private getBundleStatus;
+    /**
+     * Direct submission fallback
+     */
+    private directSubmit;
+    /**
+     * Log debug message
+     */
+    private log;
+    /**
+     * Sleep utility
+     */
+    private sleep;
 }
 /**
- * Maximum proof size in bytes
+ * Create a Jito relayer instance
  *
- * UltraHonk proofs are typically ~2KB, but we allow up to 4KB for safety.
+ * @param config - Relayer configuration
+ * @returns Jito relayer instance
  */
-declare const MAX_PROOF_SIZE_BYTES = 4096;
+declare function createJitoRelayer(config?: JitoRelayerConfig): JitoRelayer;
 /**
- * Maximum number of public inputs
- *
- * Based on Solana transaction size limits and our circuit designs.
+ * Create a mainnet Jito relayer with NY block engine
  */
-declare const MAX_PUBLIC_INPUTS = 32;
+declare function createMainnetRelayer(rpcUrl?: string): JitoRelayer;
+
 /**
- * Proof statistics for monitoring
+ * Gasless cash-out for stealth recipients.
+ *
+ * A stealth address that received SPL tokens typically holds ZERO SOL, so it cannot
+ * pay a transaction fee to move those tokens out. Here a relayer is the fee-payer; the
+ * stealth address signs only the token transfers (via its raw ed25519 scalar — see
+ * deriveStealthSigner). The relayer recovers its SOL cost as an SPL fee deducted from
+ * the tokens being moved (fee-from-claim). Direct submission is the primary path; a
+ * Jito bundle is an optional mainnet hardening layer (see submitGaslessCashout).
  */
-interface ProofStatistics {
-    /** Circuit type */
-    circuitType: NoirCircuitType;
-    /** Proof size in bytes */
-    proofSize: number;
-    /** Public inputs size in bytes */
-    publicInputsSize: number;
-    /** Total serialized size */
-    totalSize: number;
-    /** Estimated compute units */
-    estimatedComputeUnits: number;
+
+/** Parameters for building a gasless cash-out transaction. */
+interface GaslessCashoutParams {
+    /** Solana RPC connection */
+    connection: Connection;
+    /** Stealth address holding the tokens (base58) */
+    stealthAddress: string;
+    /** Ephemeral public key from the payment (base58) */
+    ephemeralPublicKey: string;
+    /** Recipient's viewing private key (hex) */
+    viewingPrivateKey: HexString;
+    /** Recipient's spending private key (hex) */
+    spendingPrivateKey: HexString;
+    /** Final destination address (base58) */
+    destinationAddress: string;
+    /** SPL token mint */
+    mint: PublicKey;
+    /** Relayer public key — the transaction fee-payer (must hold SOL) */
+    relayerPublicKey: PublicKey;
+    /** Relayer's token account that receives the fee (ATA for `mint`) */
+    relayerFeeAccount: PublicKey;
+    /** Fee model */
+    feeConfig: RelayerFeeConfig;
+    /** Announcement scheme version: '2' canonical (default) | '1' legacy */
+    version?: '1' | '2';
 }
-/**
- * Batch verification request
- */
-interface BatchVerificationRequest {
-    /** Proofs to verify */
-    proofs: ZKProof[];
-    /** Whether to fail fast on first invalid proof */
-    failFast?: boolean;
+/** A stealth-signed gasless cash-out transaction, awaiting the relayer's fee-payer signature. */
+interface GaslessCashoutBuild {
+    /** Transaction signed by the stealth address; feePayer = relayer (relayer must still sign) */
+    transaction: Transaction;
+    /** Stealth address (base58) */
+    stealthAddress: string;
+    /** Final destination (base58) */
+    destinationAddress: string;
+    /** Gross amount in the stealth token account (base units) */
+    grossAmount: bigint;
+    /** Relayer fee deducted (base units) */
+    relayerFee: bigint;
+    /** Net amount forwarded to the destination (base units) */
+    netAmount: bigint;
+    /** Blockhash the transaction is bound to */
+    blockhash: string;
+    /** Last valid block height for confirmation */
+    lastValidBlockHeight: number;
 }
 /**
- * Batch verification result
+ * Build a gasless cash-out transaction.
+ *
+ * Derives the stealth signer from the recipient's keys, computes the fee-from-claim,
+ * assembles a two- (or three-) instruction transaction with the relayer as fee-payer,
+ * and pre-signs with the stealth scalar. The relayer must add its own signature before
+ * broadcasting.
+ *
+ * @throws If the relayer fee >= the gross claim amount (nothing left for the recipient)
  */
-interface BatchVerificationResult {
-    /** Overall success */
-    success: boolean;
-    /** Results for each proof */
-    results: SolanaVerificationResult[];
-    /** Total proofs verified */
-    totalVerified: number;
-    /** Number of valid proofs */
-    validCount: number;
-    /** Total compute units used */
-    totalComputeUnits: number;
+declare function buildGaslessCashout(params: GaslessCashoutParams): Promise<GaslessCashoutBuild>;
+/** Parameters for submitting a built gasless cash-out. */
+interface SubmitGaslessCashoutParams {
+    /** Solana RPC connection */
+    connection: Connection;
+    /** Output of buildGaslessCashout (stealth already signed) */
+    build: GaslessCashoutBuild;
+    /** Relayer keypair — must equal build.transaction.feePayer */
+    relayerKeypair: Keypair;
+    /** Optional Jito relayer for the bundle path (mainnet hardening). Default: direct submit. */
+    jitoRelayer?: JitoRelayer;
+    /** Tip in lamports for the Jito path (ignored on the direct path) */
+    tipLamports?: number;
+}
+/** Result of a gasless cash-out. */
+interface GaslessCashoutResult {
+    /** Transaction signature (base58) */
+    txSignature: string;
+    /** Destination that received the net amount (base58) */
+    destinationAddress: string;
+    /** Net amount forwarded (base units) */
+    amount: bigint;
+    /** Relayer fee charged (base units) */
+    relayerFee: bigint;
+    /** Explorer URL */
+    explorerUrl: string;
+    /** Whether the Jito bundle path was used */
+    viaJito: boolean;
 }
 /**
- * Check if a string is a valid circuit type
- */
-declare function isNoirCircuitType(value: string): value is NoirCircuitType;
-/**
- * Check if a proof has the expected structure for Solana verification
+ * Sign as the relayer (fee-payer) and submit a gasless cash-out.
+ *
+ * Direct submission is the primary path (works on devnet + mainnet). Supplying a
+ * `jitoRelayer` routes through a Jito bundle instead (optional mainnet hardening;
+ * Jito has no devnet block engine).
+ *
+ * @throws If `relayerKeypair` is not the transaction's fee-payer
  */
-declare function isValidSolanaProof(proof: unknown): proof is ZKProof;
+declare function submitGaslessCashout(params: SubmitGaslessCashoutParams): Promise<GaslessCashoutResult>;
+
 /**
- * Estimate compute units for verification
+ * Stealth address signing for Solana.
  *
- * Based on circuit complexity and proof size
+ * SIP's ed25519 stealth derivation yields a RAW SCALAR (s = s_spend + H(S) mod L),
+ * not a standard ed25519 seed. Solana's `Keypair` (tweetnacl) signs by treating the
+ * first 32 bytes as a seed (SHA-512 + clamp), so it cannot sign for a stealth address
+ * whose private key is a raw scalar. This module signs directly with the scalar using
+ * RFC 8032 Ed25519 — producing signatures any standard verifier and the Solana runtime
+ * accept — and attaches them to a transaction via `Transaction.addSignature`.
  */
-declare function estimateComputeUnits(circuitType: NoirCircuitType): number;
 
 /**
- * Solana Noir Verifier
+ * Produce an RFC 8032 Ed25519 signature from a raw little-endian scalar.
  *
- * Verifies Noir ZK proofs on Solana blockchain.
- *
- * ## Overview
+ * Unlike `Keypair`/tweetnacl signing (which expects a 32-byte seed and re-derives the
+ * scalar via SHA-512 + clamp), this signs directly with the provided scalar `a` whose
+ * public key is `A = a·G`. The per-signature nonce is derived deterministically from a
+ * hash of the scalar and the message (RFC 8032 structure): unique per message, never
+ * reused across distinct messages.
  *
- * This module enables verification of SIP Protocol's Noir proofs on Solana:
- * - Funding Proofs: Prove sufficient balance without revealing amount
- * - Validity Proofs: Prove intent authorization without revealing sender
- * - Fulfillment Proofs: Prove correct execution without revealing path
- *
- * ## Usage
- *
- * ```typescript
- * import { SolanaNoirVerifier } from '@sip-protocol/sdk'
- * import { NoirProofProvider } from '@sip-protocol/sdk'
- *
- * // Generate proof
- * const provider = new NoirProofProvider()
- * await provider.initialize()
- * const { proof } = await provider.generateFundingProof(params)
+ * @param message - Exact bytes to sign (e.g. a compiled transaction message)
+ * @param scalar - 32-byte little-endian ed25519 scalar (the stealth private key)
+ * @returns 64-byte signature (R ‖ S)
+ * @throws If the scalar reduces to zero
+ */
+declare function signEd25519WithScalar(message: Uint8Array, scalar: Uint8Array): Uint8Array;
+/** Parameters needed to derive a stealth address's signer. */
+interface DeriveStealthSignerParams {
+    /** Stealth address (base58) */
+    stealthAddress: string;
+    /** Ephemeral public key from the payment (base58) */
+    ephemeralPublicKey: string;
+    /** Recipient's viewing private key (hex) */
+    viewingPrivateKey: HexString;
+    /** Recipient's spending private key (hex) */
+    spendingPrivateKey: HexString;
+    /** Announcement scheme version: '2' canonical (default) | '1' legacy */
+    version?: '1' | '2';
+}
+/** Signs transactions/messages as a stealth address using its raw ed25519 scalar. */
+interface StealthSigner {
+    /** The stealth address this signer controls */
+    readonly publicKey: PublicKey;
+    /** Sign arbitrary bytes, returning a 64-byte ed25519 signature */
+    signMessage(message: Uint8Array): Uint8Array;
+    /** Attach this stealth address's signature to a transaction. Call LAST — after feePayer, recentBlockhash, and all instructions are finalized (the signature covers the serialized message at call time). */
+    signTransaction(transaction: Transaction): void;
+}
+/**
+ * Re-derive the signer that controls a stealth address.
  *
- * // Verify on Solana
- * const verifier = new SolanaNoirVerifier({ network: 'devnet' })
- * await verifier.initialize()
+ * Routes derivation by announcement version (canonical SIP:2 vs legacy SIP:1) and
+ * validates the derived scalar reproduces the on-chain stealth public key before
+ * returning a signer. The signer signs with the raw scalar (see
+ * {@link signEd25519WithScalar}); it does NOT construct a `Keypair`, which cannot sign
+ * for a scalar-derived stealth address.
  *
- * // Off-chain verification (fast, no transaction)
- * const isValid = await verifier.verifyOffChain(proof)
+ * @throws If the derived scalar does not produce the expected stealth public key
+ */
+declare function deriveStealthSigner(params: DeriveStealthSignerParams): StealthSigner;
+
+/**
+ * Solana Noir Verifier Types
  *
- * // On-chain verification (submits transaction)
- * const result = await verifier.verifyOnChain(proof, wallet)
- * ```
+ * Type definitions for verifying Noir ZK proofs on Solana.
  *
  * ## Architecture
  *
  * ```
  * ┌─────────────────────────────────────────────────────────────┐
- * │  CLIENT SIDE                                                │
- * │  ┌─────────────┐    ┌──────────────────┐                   │
- * │  │ Noir Proof  │───►│ SolanaNoirVerifier│                  │
- * │  │ Provider    │    │ - serialize()     │                  │
- * │  └─────────────┘    │ - verifyOffChain()│                  │
- * │                     │ - verifyOnChain() │                  │
- * │                     └────────┬─────────┘                   │
- * └──────────────────────────────┼─────────────────────────────┘
- *                                │
- *                                ▼
- * ┌─────────────────────────────────────────────────────────────┐
- * │  SOLANA BLOCKCHAIN                                          │
- * │  ┌──────────────────────────────────────────────────────┐  │
- * │  │ ZK Proof Verification Program                         │  │
- * │  │ - Deserialize proof                                   │  │
- * │  │ - Load verification key                               │  │
- * │  │ - Execute pairing checks                              │  │
- * │  │ - Return verification result                          │  │
- * │  └──────────────────────────────────────────────────────┘  │
+ * │  NOIR PROOF FLOW ON SOLANA                                  │
+ * │                                                             │
+ * │  1. Generate proof (BrowserNoirProvider / NoirProofProvider)│
+ * │  2. Serialize for Solana (SolanaNoirVerifier)               │
+ * │  3. Submit to Solana program (verify instruction)           │
+ * │  4. On-chain verification (ZK Token Proof / Custom)         │
  * └─────────────────────────────────────────────────────────────┘
  * ```
  *
- * @module solana/noir-verifier
+ * @module solana/noir-verifier-types
  */
 
 /**
- * Solana Noir Verifier
- *
- * Enables verification of Noir ZK proofs on Solana blockchain.
- *
- * @example
- * ```typescript
- * const verifier = new SolanaNoirVerifier({
- *   network: 'devnet',
- *   verbose: true,
- * })
- *
- * await verifier.initialize()
- *
- * // Verify proof off-chain (no transaction)
- * const valid = await verifier.verifyOffChain(proof)
+ * Supported Noir circuit types for Solana verification
+ */
+type NoirCircuitType = 'funding' | 'validity' | 'fulfillment';
+/**
+ * Circuit metadata for verification key generation
+ */
+interface CircuitMetadata {
+    /** Circuit type identifier */
+    type: NoirCircuitType;
+    /** Number of public inputs */
+    publicInputCount: number;
+    /** Approximate constraint count */
+    constraintCount: number;
+    /** Circuit version hash */
+    versionHash: string;
+}
+/**
+ * Circuit metadata for all supported circuits
+ */
+declare const CIRCUIT_METADATA: Record<NoirCircuitType, CircuitMetadata>;
+/**
+ * Verification key for Solana on-chain verification
  *
- * // Or verify on-chain (submits transaction)
- * const result = await verifier.verifyOnChain(proof, wallet)
- * ```
+ * Contains the cryptographic parameters needed to verify proofs on-chain.
  */
-declare class SolanaNoirVerifier {
-    private config;
-    private _isReady;
-    private verificationKeys;
-    private connection;
-    constructor(config?: SolanaNoirVerifierConfig);
-    /**
-     * Get the Solana connection
-     */
-    getConnection(): Connection;
-    /**
-     * Check if verifier is initialized
-     */
-    get isReady(): boolean;
-    /**
-     * Get current configuration
-     */
-    getConfig(): Readonly<SolanaNoirVerifierConfig>;
-    /**
-     * Get RPC URL being used
-     */
-    getRpcUrl(): string;
-    /**
-     * Initialize the verifier
-     *
-     * Loads verification keys for all circuit types.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Generate verification key for a circuit type
-     *
-     * Creates the cryptographic verification key needed to verify proofs.
-     */
-    generateVerificationKey(circuitType: NoirCircuitType): Promise<SolanaVerificationKey>;
-    /**
-     * Serialize a proof for Solana
-     *
-     * Converts a Noir proof into a format suitable for Solana transaction.
-     */
-    serializeProof(proof: ZKProof): SolanaSerializedProof;
-    /**
-     * Verify a proof off-chain
-     *
-     * Fast verification without submitting a transaction.
-     * Uses the local Noir backend for verification if @aztec/bb.js is available,
-     * otherwise falls back to mock verification.
-     *
-     * @param proof - The proof to verify
-     * @returns true if valid, false otherwise
-     *
-     * @remarks
-     * For production use, install @aztec/bb.js as a dependency:
-     * ```bash
-     * npm install @aztec/bb.js
-     * ```
-     */
-    verifyOffChain(proof: ZKProof): Promise<boolean>;
-    /**
-     * Try to import @aztec/bb.js dynamically
-     * Returns null if not available (allows graceful fallback)
-     */
-    private tryImportBBJS;
-    /**
-     * Verify proof using the real Noir backend
-     */
-    private verifyWithBackend;
-    /**
-     * Mock verification for testing and development
-     *
-     * WARNING: This does NOT provide cryptographic security.
-     * Only used when @aztec/bb.js is not available.
-     */
-    private mockVerify;
-    /**
-     * Verify a proof on-chain
-     *
-     * Submits a transaction to Solana to verify the proof using the Sunspot verifier.
-     *
-     * @param proof - The proof to verify
-     * @param wallet - Wallet interface with signTransaction method
-     * @returns Verification result with transaction signature
-     */
-    verifyOnChain(proof: ZKProof, wallet: {
-        publicKey: {
-            toBase58(): string;
-        };
-        signTransaction: <T extends Transaction>(tx: T) => Promise<T>;
-    }): Promise<SolanaVerificationResult>;
-    /**
-     * Create a Sunspot verifier instruction
-     *
-     * Sunspot verifiers expect instruction data in format: proof_bytes || public_witness_bytes
-     */
-    createSunspotVerifyInstruction(proof: ZKProof, programId: string): TransactionInstruction;
+interface SolanaVerificationKey {
+    /** Circuit type this key is for */
+    circuitType: NoirCircuitType;
+    /** Serialized verification key bytes */
+    keyBytes: Uint8Array;
+    /** Key hash for integrity check */
+    keyHash: string;
+    /** Number of public inputs expected */
+    publicInputCount: number;
+    /** Solana account address where key is stored (if deployed) */
+    accountAddress?: string;
+}
+/**
+ * Solana-serialized proof ready for on-chain verification
+ */
+interface SolanaSerializedProof {
+    /** Original proof type */
+    circuitType: NoirCircuitType;
+    /** Proof bytes in Solana-compatible format */
+    proofBytes: Uint8Array;
+    /** Public inputs as Field elements (32 bytes each) */
+    publicInputs: Uint8Array[];
+    /** Total serialized size in bytes */
+    totalSize: number;
+}
+/**
+ * Proof verification result from Solana
+ */
+interface SolanaVerificationResult {
+    /** Whether the proof is valid */
+    valid: boolean;
+    /** Transaction signature if submitted on-chain */
+    signature?: string;
+    /** Slot number of verification */
+    slot?: number;
+    /** Compute units used */
+    computeUnits?: number;
+    /** Error message if verification failed */
+    error?: string;
+}
+/**
+ * Solana instruction for proof verification
+ */
+interface SolanaVerifyInstruction {
+    /** Program ID to call */
+    programId: string;
+    /** Instruction data */
+    data: Uint8Array;
+    /** Account keys required */
+    keys: SolanaAccountMeta[];
+}
+/**
+ * Account metadata for Solana instruction
+ */
+interface SolanaAccountMeta {
+    /** Account public key */
+    pubkey: string;
+    /** Is signer */
+    isSigner: boolean;
+    /** Is writable */
+    isWritable: boolean;
+}
+/**
+ * Network configuration for Solana
+ */
+type SolanaNetwork = 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet';
+/**
+ * Solana Noir Verifier configuration
+ */
+interface SolanaNoirVerifierConfig {
     /**
-     * Serialize proof for Sunspot verifier
-     *
-     * Sunspot expects: proof_bytes || public_witness_bytes
-     * where public_witness contains the number of public inputs followed by the values
+     * Solana network to use
+     * @default 'devnet'
      */
-    serializeProofForSunspot(proof: ZKProof): Buffer;
+    network?: SolanaNetwork;
     /**
-     * Create a verify instruction for Solana
-     *
-     * Builds the instruction data and account metas needed for verification.
+     * Custom RPC endpoint URL
+     * If not provided, uses default for network
      */
-    createVerifyInstruction(proof: ZKProof): SolanaVerifyInstruction;
+    rpcUrl?: string;
     /**
-     * Get proof statistics
-     *
-     * Returns size and compute unit estimates for a proof.
+     * Verification program ID
+     * Uses native ZK Token Proof program by default
      */
-    getProofStatistics(proof: ZKProof): ProofStatistics;
+    programId?: string;
     /**
-     * Batch verify multiple proofs
-     *
-     * Verifies multiple proofs, optionally failing fast on first invalid.
+     * Enable verbose logging
+     * @default false
      */
-    batchVerify(request: BatchVerificationRequest): Promise<BatchVerificationResult>;
+    verbose?: boolean;
     /**
-     * Get verification key for a circuit type
+     * Commitment level for transactions
+     * @default 'confirmed'
      */
-    getVerificationKey(circuitType: NoirCircuitType): SolanaVerificationKey | undefined;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
     /**
-     * Destroy the verifier and free resources
+     * Maximum compute units for verification
+     * @default 400000
      */
-    destroy(): Promise<void>;
-    private ensureReady;
-    private loadCircuitArtifact;
-    private generateVKeyBytes;
-    private hashBytes;
-    private hexToBytes;
-    private circuitTypeToId;
+    maxComputeUnits?: number;
 }
 /**
- * Create a Solana Noir Verifier with default devnet configuration
+ * Default RPC URLs for each network
+ * Localnet is configurable via SOLANA_LOCALNET_RPC environment variable
  */
-declare function createDevnetVerifier(config?: Omit<SolanaNoirVerifierConfig, 'network'>): SolanaNoirVerifier;
+declare const DEFAULT_RPC_URLS: Record<SolanaNetwork, string>;
 /**
- * Create a Solana Noir Verifier with mainnet configuration
+ * Native Solana ZK proof program IDs
+ *
+ * Note: These are the native Solana programs for ZK proof verification.
+ * For custom Noir circuits, a dedicated verifier program would be needed.
  */
-declare function createMainnetVerifier(config?: Omit<SolanaNoirVerifierConfig, 'network'>): SolanaNoirVerifier;
-
+declare const SOLANA_ZK_PROGRAM_IDS: {
+    /** ZK Token Proof Program (native) */
+    readonly ZK_TOKEN_PROOF: "ZkTokenProof1111111111111111111111111111111";
+    /** ZK ElGamal Proof Program (native) */
+    readonly ZK_ELGAMAL_PROOF: "ZkE1Gama1Proof11111111111111111111111111111";
+    /** Custom SIP Noir Verifier (TBD - to be deployed) */
+    readonly SIP_NOIR_VERIFIER: "SIPNoirVerifier1111111111111111111111111";
+};
 /**
- * Jito Relayer for SIP Protocol
- *
- * Enables gas abstraction for Solana shielded transactions using Jito's MEV infrastructure.
- * The relayer submits transaction bundles on behalf of users, paying gas fees and breaking
- * the direct link between the user's wallet and the privacy transaction.
- *
- * ## Why Jito?
- *
- * 1. **Native Solana**: Jito is battle-tested MEV infrastructure on Solana
- * 2. **No Dedicated Server**: Uses Jito's network, no VPS maintenance needed
- * 3. **Bundle Guarantees**: Atomic execution, no partial failures
- * 4. **Lower Regulatory Risk**: Relayer only handles gas, not asset movement
- *
- * ## Architecture
- *
- * ```
- * ┌─────────────────────────────────────────────────────────────────────────────┐
- * │  GAS ABSTRACTION FLOW                                                       │
- * │                                                                             │
- * │  ┌─────────┐      ┌───────────────┐      ┌───────────┐      ┌──────────┐  │
- * │  │  User   │ ──▶  │ Sign TX       │ ──▶  │ Jito      │ ──▶  │ Solana   │  │
- * │  │  Wallet │      │ (no SOL fee)  │      │ Relayer   │      │ Network  │  │
- * │  └─────────┘      └───────────────┘      └───────────┘      └──────────┘  │
- * │                                                │                          │
- * │                                                ▼                          │
- * │                                          Relayer pays                     │
- * │                                          gas from tip                     │
- * └─────────────────────────────────────────────────────────────────────────────┘
- * ```
- *
- * ## Fee Model
- *
- * The relayer takes a small tip from the transaction (configurable, typically 0.1-0.5%)
- * to cover gas costs and operational overhead.
- *
- * @see https://jito-foundation.gitbook.io/mev/
- * @see https://jito-labs.github.io/jito-ts/
+ * Error codes for Solana Noir verification
  */
-
+declare enum SolanaNoirErrorCode {
+    /** Invalid proof format */
+    INVALID_PROOF_FORMAT = "INVALID_PROOF_FORMAT",
+    /** Invalid public inputs */
+    INVALID_PUBLIC_INPUTS = "INVALID_PUBLIC_INPUTS",
+    /** Verification failed on-chain */
+    VERIFICATION_FAILED = "VERIFICATION_FAILED",
+    /** Network error */
+    NETWORK_ERROR = "NETWORK_ERROR",
+    /** Insufficient compute units */
+    INSUFFICIENT_COMPUTE = "INSUFFICIENT_COMPUTE",
+    /** Verification key not found */
+    VKEY_NOT_FOUND = "VKEY_NOT_FOUND",
+    /** Unsupported circuit type */
+    UNSUPPORTED_CIRCUIT = "UNSUPPORTED_CIRCUIT",
+    /** Transaction failed */
+    TRANSACTION_FAILED = "TRANSACTION_FAILED"
+}
 /**
- * Jito Block Engine endpoints
- * @see https://jito-foundation.gitbook.io/mev/searcher-resources/block-engine
+ * Solana Noir verification error
  */
-declare const JITO_BLOCK_ENGINES: {
-    readonly mainnet: {
-        readonly amsterdam: "https://amsterdam.mainnet.block-engine.jito.wtf/api/v1";
-        readonly frankfurt: "https://frankfurt.mainnet.block-engine.jito.wtf/api/v1";
-        readonly ny: "https://ny.mainnet.block-engine.jito.wtf/api/v1";
-        readonly tokyo: "https://tokyo.mainnet.block-engine.jito.wtf/api/v1";
-    };
-};
+declare class SolanaNoirError extends Error {
+    readonly code: SolanaNoirErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: SolanaNoirErrorCode, details?: Record<string, unknown> | undefined);
+}
 /**
- * Jito tip accounts (one must receive the tip)
- * @see https://jito-foundation.gitbook.io/mev/searcher-resources/tip-accounts
+ * Maximum proof size in bytes
+ *
+ * UltraHonk proofs are typically ~2KB, but we allow up to 4KB for safety.
  */
-declare const JITO_TIP_ACCOUNTS: readonly ["96gYZGLnJYVFmbjzopPSU6QiEV5fGqZNyN9nmNhvrZU5", "HFqU5x63VTqvQss8hp11i4bVmkekGTo46ibhvdrPnSVX", "Cw8CFyM9FkoMi7K7Crf6HNQqf4uEMzpKw6QNghXLvLkY", "ADaUMid9yfUytqMBgopwjb2DTLSokTSzL1zt6iGPaS49", "DfXygSm4jCyNCybVYYK6DwvWqjKee8pbDmJGcLWNDXjh", "ADuUkR4vqLUMWXxW9gh6D6L8pMSawimctcNZ5pGwDcEt", "DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL", "3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT"];
+declare const MAX_PROOF_SIZE_BYTES = 4096;
 /**
- * Default configuration values
+ * Maximum number of public inputs
+ *
+ * Based on Solana transaction size limits and our circuit designs.
  */
-declare const JITO_DEFAULTS: {
-    /** Default tip in lamports (0.001 SOL) */
-    readonly tipLamports: 1000000;
-    /** Maximum bundle size */
-    readonly maxBundleSize: 5;
-    /** Bundle submission timeout (ms) */
-    readonly submissionTimeout: 30000;
-    /** Confirmation timeout (ms) */
-    readonly confirmationTimeout: 60000;
-    /** Default retry attempts */
-    readonly maxRetries: 3;
-};
+declare const MAX_PUBLIC_INPUTS = 32;
 /**
- * Jito relayer configuration
+ * Proof statistics for monitoring
  */
-interface JitoRelayerConfig {
-    /** Jito block engine endpoint */
-    blockEngineUrl?: string;
-    /** Solana RPC URL */
-    rpcUrl?: string;
-    /** Default tip amount in lamports */
-    defaultTipLamports?: number;
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Maximum retries for bundle submission */
-    maxRetries?: number;
-    /** Submission timeout in ms */
-    submissionTimeout?: number;
+interface ProofStatistics {
+    /** Circuit type */
+    circuitType: NoirCircuitType;
+    /** Proof size in bytes */
+    proofSize: number;
+    /** Public inputs size in bytes */
+    publicInputsSize: number;
+    /** Total serialized size */
+    totalSize: number;
+    /** Estimated compute units */
+    estimatedComputeUnits: number;
 }
 /**
- * Bundle submission request
+ * Batch verification request
  */
-interface JitoBundleRequest {
-    /** Transactions to include in bundle */
-    transactions: (Transaction | VersionedTransaction)[];
-    /** Tip amount in lamports */
-    tipLamports?: number;
-    /** Tip payer keypair */
-    tipPayer: Keypair;
-    /** Whether to wait for confirmation */
-    waitForConfirmation?: boolean;
+interface BatchVerificationRequest {
+    /** Proofs to verify */
+    proofs: ZKProof[];
+    /** Whether to fail fast on first invalid proof */
+    failFast?: boolean;
 }
 /**
- * Bundle submission result
+ * Batch verification result
  */
-interface JitoBundleResult {
-    /** Bundle UUID */
-    bundleId: string;
-    /** Transaction signatures in bundle */
-    signatures: string[];
-    /** Submission status */
-    status: 'submitted' | 'landed' | 'failed' | 'timeout';
-    /** Slot where bundle landed (if confirmed) */
-    slot?: number;
-    /** Error message if failed */
-    error?: string;
-    /** Actual tip paid in lamports */
-    tipPaid: number;
+interface BatchVerificationResult {
+    /** Overall success */
+    success: boolean;
+    /** Results for each proof */
+    results: SolanaVerificationResult[];
+    /** Total proofs verified */
+    totalVerified: number;
+    /** Number of valid proofs */
+    validCount: number;
+    /** Total compute units used */
+    totalComputeUnits: number;
 }
 /**
- * Relayed transaction request
+ * Check if a string is a valid circuit type
  */
-interface RelayedTransactionRequest {
-    /** Signed transaction to relay */
-    transaction: Transaction | VersionedTransaction;
-    /** Tip amount in lamports (paid by relayer, recovered from user) */
-    tipLamports?: number;
-    /** Whether to wait for confirmation */
-    waitForConfirmation?: boolean;
-}
+declare function isNoirCircuitType(value: string): value is NoirCircuitType;
 /**
- * Relayed transaction result
+ * Check if a proof has the expected structure for Solana verification
  */
-interface RelayedTransactionResult {
-    /** Transaction signature */
-    signature: string;
-    /** Bundle ID if submitted via Jito */
-    bundleId?: string;
-    /** Submission status */
-    status: 'submitted' | 'confirmed' | 'failed';
-    /** Slot where transaction landed */
-    slot?: number;
-    /** Error message if failed */
-    error?: string;
-    /** Whether relayer was used or fell back to direct submission */
-    relayed: boolean;
-}
+declare function isValidSolanaProof(proof: unknown): proof is ZKProof;
 /**
- * Jito relayer error codes
+ * Estimate compute units for verification
+ *
+ * Based on circuit complexity and proof size
  */
-declare enum JitoRelayerErrorCode {
-    BUNDLE_SUBMISSION_FAILED = "BUNDLE_SUBMISSION_FAILED",
-    BUNDLE_TIMEOUT = "BUNDLE_TIMEOUT",
-    BUNDLE_INVALID = "BUNDLE_INVALID",
-    INSUFFICIENT_TIP = "INSUFFICIENT_TIP",
-    CONNECTION_ERROR = "CONNECTION_ERROR",
-    RATE_LIMITED = "RATE_LIMITED",
-    INVALID_TRANSACTION = "INVALID_TRANSACTION"
-}
+declare function estimateComputeUnits(circuitType: NoirCircuitType): number;
+
 /**
- * Jito relayer error
+ * Solana Noir Verifier
+ *
+ * Verifies Noir ZK proofs on Solana blockchain.
+ *
+ * ## Overview
+ *
+ * This module enables verification of SIP Protocol's Noir proofs on Solana:
+ * - Funding Proofs: Prove sufficient balance without revealing amount
+ * - Validity Proofs: Prove intent authorization without revealing sender
+ * - Fulfillment Proofs: Prove correct execution without revealing path
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { SolanaNoirVerifier } from '@sip-protocol/sdk'
+ * import { NoirProofProvider } from '@sip-protocol/sdk'
+ *
+ * // Generate proof
+ * const provider = new NoirProofProvider()
+ * await provider.initialize()
+ * const { proof } = await provider.generateFundingProof(params)
+ *
+ * // Verify on Solana
+ * const verifier = new SolanaNoirVerifier({ network: 'devnet' })
+ * await verifier.initialize()
+ *
+ * // Off-chain verification (fast, no transaction)
+ * const isValid = await verifier.verifyOffChain(proof)
+ *
+ * // On-chain verification (submits transaction)
+ * const result = await verifier.verifyOnChain(proof, wallet)
+ * ```
+ *
+ * ## Architecture
+ *
+ * ```
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │  CLIENT SIDE                                                │
+ * │  ┌─────────────┐    ┌──────────────────┐                   │
+ * │  │ Noir Proof  │───►│ SolanaNoirVerifier│                  │
+ * │  │ Provider    │    │ - serialize()     │                  │
+ * │  └─────────────┘    │ - verifyOffChain()│                  │
+ * │                     │ - verifyOnChain() │                  │
+ * │                     └────────┬─────────┘                   │
+ * └──────────────────────────────┼─────────────────────────────┘
+ *                                │
+ *                                ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │  SOLANA BLOCKCHAIN                                          │
+ * │  ┌──────────────────────────────────────────────────────┐  │
+ * │  │ ZK Proof Verification Program                         │  │
+ * │  │ - Deserialize proof                                   │  │
+ * │  │ - Load verification key                               │  │
+ * │  │ - Execute pairing checks                              │  │
+ * │  │ - Return verification result                          │  │
+ * │  └──────────────────────────────────────────────────────┘  │
+ * └─────────────────────────────────────────────────────────────┘
+ * ```
+ *
+ * @module solana/noir-verifier
  */
-declare class JitoRelayerError extends Error {
-    readonly code: JitoRelayerErrorCode;
-    readonly details?: unknown | undefined;
-    constructor(code: JitoRelayerErrorCode, message: string, details?: unknown | undefined);
-}
+
 /**
- * Jito Relayer for gas abstraction
+ * Solana Noir Verifier
  *
- * Submits Solana transactions via Jito's MEV infrastructure,
- * enabling gas abstraction for privacy transactions.
+ * Enables verification of Noir ZK proofs on Solana blockchain.
  *
  * @example
  * ```typescript
- * import { JitoRelayer } from '@sip-protocol/sdk'
- *
- * const relayer = new JitoRelayer({
- *   blockEngineUrl: 'https://ny.mainnet.block-engine.jito.wtf/api/v1',
+ * const verifier = new SolanaNoirVerifier({
+ *   network: 'devnet',
+ *   verbose: true,
  * })
  *
- * // Submit a signed transaction via relayer
- * const result = await relayer.relayTransaction({
- *   transaction: signedTx,
- *   tipLamports: 10_000, // 0.00001 SOL tip
- * })
+ * await verifier.initialize()
  *
- * console.log('Transaction relayed:', result.signature)
+ * // Verify proof off-chain (no transaction)
+ * const valid = await verifier.verifyOffChain(proof)
+ *
+ * // Or verify on-chain (submits transaction)
+ * const result = await verifier.verifyOnChain(proof, wallet)
  * ```
  */
-declare class JitoRelayer {
-    private readonly connection;
-    private readonly blockEngineUrl;
-    private readonly defaultTipLamports;
-    private readonly debug;
-    private readonly maxRetries;
-    private readonly submissionTimeout;
-    constructor(config?: JitoRelayerConfig);
+declare class SolanaNoirVerifier {
+    private config;
+    private _isReady;
+    private verificationKeys;
+    private connection;
+    constructor(config?: SolanaNoirVerifierConfig);
     /**
-     * Submit a bundle of transactions to Jito
+     * Get the Solana connection
+     */
+    getConnection(): Connection;
+    /**
+     * Check if verifier is initialized
+     */
+    get isReady(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Readonly<SolanaNoirVerifierConfig>;
+    /**
+     * Get RPC URL being used
+     */
+    getRpcUrl(): string;
+    /**
+     * Initialize the verifier
      *
-     * @param request - Bundle request with transactions and tip
-     * @returns Bundle submission result
+     * Loads verification keys for all circuit types.
      */
-    submitBundle(request: JitoBundleRequest): Promise<JitoBundleResult>;
+    initialize(): Promise<void>;
     /**
-     * Relay a single transaction via Jito
+     * Generate verification key for a circuit type
      *
-     * This is the main method for gas abstraction - submit a transaction
-     * through the relayer instead of paying gas directly.
+     * Creates the cryptographic verification key needed to verify proofs.
+     */
+    generateVerificationKey(circuitType: NoirCircuitType): Promise<SolanaVerificationKey>;
+    /**
+     * Serialize a proof for Solana
      *
-     * @param request - Transaction to relay
-     * @returns Relay result
+     * Converts a Noir proof into a format suitable for Solana transaction.
      */
-    relayTransaction(request: RelayedTransactionRequest): Promise<RelayedTransactionResult>;
+    serializeProof(proof: ZKProof): SolanaSerializedProof;
     /**
-     * Check if Jito relayer is available
+     * Verify a proof off-chain
+     *
+     * Fast verification without submitting a transaction.
+     * Uses the local Noir backend for verification if @aztec/bb.js is available,
+     * otherwise falls back to mock verification.
+     *
+     * @param proof - The proof to verify
+     * @returns true if valid, false otherwise
+     *
+     * @remarks
+     * For production use, install @aztec/bb.js as a dependency:
+     * ```bash
+     * npm install @aztec/bb.js
+     * ```
      */
-    isAvailable(): Promise<boolean>;
+    verifyOffChain(proof: ZKProof): Promise<boolean>;
     /**
-     * Get current tip floor (minimum tip for inclusion)
+     * Try to import @aztec/bb.js dynamically
+     * Returns null if not available (allows graceful fallback)
      */
-    getTipFloor(): Promise<number>;
+    private tryImportBBJS;
     /**
-     * Get a random tip account
+     * Verify proof using the real Noir backend
      */
-    getRandomTipAccount(): PublicKey;
+    private verifyWithBackend;
     /**
-     * Create tip instruction
+     * Mock verification for testing and development
+     *
+     * WARNING: This does NOT provide cryptographic security.
+     * Only used when @aztec/bb.js is not available.
      */
-    private createTipInstruction;
+    private mockVerify;
     /**
-     * Prepare transactions for bundle submission
+     * Verify a proof on-chain
+     *
+     * Submits a transaction to Solana to verify the proof using the Sunspot verifier.
+     *
+     * @param proof - The proof to verify
+     * @param wallet - Wallet interface with signTransaction method
+     * @returns Verification result with transaction signature
      */
-    private prepareBundleTransactions;
+    verifyOnChain(proof: ZKProof, wallet: {
+        publicKey: {
+            toBase58(): string;
+        };
+        signTransaction: <T extends Transaction>(tx: T) => Promise<T>;
+    }): Promise<SolanaVerificationResult>;
     /**
-     * Send bundle to Jito block engine
+     * Create a Sunspot verifier instruction
+     *
+     * Sunspot verifiers expect instruction data in format: proof_bytes || public_witness_bytes
      */
-    private sendBundle;
+    createSunspotVerifyInstruction(proof: ZKProof, programId: string): TransactionInstruction;
     /**
-     * Wait for bundle confirmation
+     * Serialize proof for Sunspot verifier
+     *
+     * Sunspot expects: proof_bytes || public_witness_bytes
+     * where public_witness contains the number of public inputs followed by the values
      */
-    private waitForBundleConfirmation;
+    serializeProofForSunspot(proof: ZKProof): Buffer;
     /**
-     * Get bundle status from Jito
+     * Create a verify instruction for Solana
+     *
+     * Builds the instruction data and account metas needed for verification.
      */
-    private getBundleStatus;
+    createVerifyInstruction(proof: ZKProof): SolanaVerifyInstruction;
     /**
-     * Direct submission fallback
+     * Get proof statistics
+     *
+     * Returns size and compute unit estimates for a proof.
      */
-    private directSubmit;
+    getProofStatistics(proof: ZKProof): ProofStatistics;
     /**
-     * Log debug message
+     * Batch verify multiple proofs
+     *
+     * Verifies multiple proofs, optionally failing fast on first invalid.
      */
-    private log;
+    batchVerify(request: BatchVerificationRequest): Promise<BatchVerificationResult>;
     /**
-     * Sleep utility
+     * Get verification key for a circuit type
      */
-    private sleep;
+    getVerificationKey(circuitType: NoirCircuitType): SolanaVerificationKey | undefined;
+    /**
+     * Destroy the verifier and free resources
+     */
+    destroy(): Promise<void>;
+    private ensureReady;
+    private loadCircuitArtifact;
+    private generateVKeyBytes;
+    private hashBytes;
+    private hexToBytes;
+    private circuitTypeToId;
 }
 /**
- * Create a Jito relayer instance
- *
- * @param config - Relayer configuration
- * @returns Jito relayer instance
+ * Create a Solana Noir Verifier with default devnet configuration
  */
-declare function createJitoRelayer(config?: JitoRelayerConfig): JitoRelayer;
+declare function createDevnetVerifier(config?: Omit<SolanaNoirVerifierConfig, 'network'>): SolanaNoirVerifier;
 /**
- * Create a mainnet Jito relayer with NY block engine
+ * Create a Solana Noir Verifier with mainnet configuration
  */
-declare function createMainnetRelayer(rpcUrl?: string): JitoRelayer;
+declare function createMainnetVerifier(config?: Omit<SolanaNoirVerifierConfig, 'network'>): SolanaNoirVerifier;
 
 /**
  * NEAR Same-Chain Privacy Types
@@ -24769,4 +24978,4 @@ declare function calculateFeeForSwap(contract: NEARFeeContract, swapAmount: bigi
     netAmountUsd: number;
 }>;
 
-export { type CSPLServiceStatus as $, ATTESTATION_VERSION as A, BLS12_381_MODULUS as B, BN254_MODULUS as C, BUILTIN_TEMPLATES as D, type BackendCapabilities$1 as E, type BackendRegistrationOptions as F, type BalanceAttestationParams as G, BaseProofComposer as H, BaseWalletAdapter as I, type BatchVerificationRequest as J, type BatchVerificationResult as K, type BidReceipt as L, type BitcoinNetwork$1 as M, type BlockRange as N, type BridgeProvider as O, BrowserNoirProvider as P, type BrowserNoirProviderConfig as Q, CHAIN_NUMERIC_IDS as R, CIRCUIT_METADATA as S, COMPLIANCE_CIRCUIT_IDS as T, ETH_RPC_ENDPOINTS as U, SOLANA_RPC_ENDPOINTS as V, SUI_RPC_ENDPOINTS as W, CHAIN_PREFIXES as X, CSPLClient as Y, ZCASH_RPC_CONFIG as Z, type CSPLClientConfig as _, type AddressReuseResult as a, DEFAULT_VALIDITY_PERIOD_SECONDS as a$, CSPLTokenService as a0, type CSPLTokenServiceConfig as a1, type CSVExport as a2, type CacheEntry as a3, type CacheEntryMetadata as a4, type CacheEvent as a5, type CacheEventListener as a6, type CacheEventType as a7, type CacheKey as a8, type CacheKeyComponents as a9, type CosmosChainId as aA, type CosmosStealthResult as aB, CosmosStealthService as aC, type CreateBidParams as aD, type CreateIntentOptions as aE, type CreatePaymentOptions as aF, CrossSystemValidator as aG, CryptoError as aH, DEFAULT_AGGREGATOR_CONFIG as aI, DEFAULT_CHAIN_FEES as aJ, DEFAULT_CONVERSION_OPTIONS as aK, DEFAULT_FEE_TIERS as aL, DEFAULT_LRU_CONFIG as aM, DEFAULT_MANAGER_CONFIG as aN, DEFAULT_MOCK_CONFIG as aO, DEFAULT_MULTI_TIER_CONFIG as aP, DEFAULT_NETWORK_CONFIG as aQ, DEFAULT_ORCHESTRATOR_CONFIG as aR, DEFAULT_PERSISTENT_CONFIG as aS, DEFAULT_PIPELINE_CONFIG as aT, DEFAULT_PROXY_TIMEOUT as aU, DEFAULT_RANGE_API_ENDPOINT as aV, DEFAULT_RPC_URLS as aW, DEFAULT_SYNC_CONFIG as aX, DEFAULT_THRESHOLD as aY, DEFAULT_TOTAL_ORACLES as aZ, DEFAULT_TREASURY as a_, CacheKeyGenerator as aa, type CacheLookupResult as ab, type CacheWarmingConfig as ac, type CastVoteParams as ad, type ChainCharacteristics as ae, type ChainFamily as af, type ChainFeeConfig as ag, type ClusterResult as ah, type CommitmentPoint as ai, type CompatibilityEntry as aj, ComplianceManager as ak, type ComplianceProofConfig as al, ComplianceProofProvider as am, type ComplianceProofResult as an, type ComplianceProofType as ao, ComplianceReporter as ap, type CompositionPlan as aq, type CompositionRequest as ar, type CompositionState as as, type CompositionTemplate as at, ConditionalDisclosure as au, type ConversionErrorCode as av, type ConversionMetadata as aw, type ConversionOptions as ax, type ValidationError as ay, type ValidationResult as az, type AdvisorMessage as b, type GenerateAuditReportParams as b$, DEFAULT_WARMING_CONFIG as b0, type DecryptedTransaction as b1, DerivationPath as b2, type DeriveMultipleParams as b3, type DeriveViewingKeyParams as b4, type DerivedViewingKey as b5, type DetailedAggregationResult as b6, type DetailedVerificationResult as b7, type EIP1193ConnectInfo as b8, type EIP1193Event as b9, type ExportForRegulatorParams as bA, type ExportedViewingKey as bB, type FATFExport as bC, type FATFTransaction as bD, type FINCENExport as bE, type FINCENTransaction as bF, type FeeBreakdown as bG, type FeeCalculationInput as bH, type FeeCalculationResult as bI, FeeCalculator as bJ, type FeeCalculatorOptions as bK, type FeeCollectionEvent as bL, type FeeCollectionParams as bM, type FeeCollectionResult as bN, type FeeContractMethods as bO, type FeeContractState as bP, type FeeGovernanceProposal as bQ, type FeeModel as bR, type FeeStats as bS, type FeeTier as bT, type TreasuryConfig as bU, type FeeWaiver as bV, type FeeWaiverType as bW, type FieldCharacteristics as bX, FileCache as bY, type FindBestRouteParams as bZ, type FullAnalysisResult as b_, type EIP1193Provider as ba, type EIP1193ProviderRpcError as bb, type EIP1193RequestArguments as bc, type EIP712Domain as bd, type EIP712TypeDefinition as be, type EIP712TypedData as bf, type EIP712Types as bg, type EllipticCurve as bh, type EncryptedNote as bi, type EncryptedVote as bj, EncryptionNotImplementedError as bk, type EnhancedAccountData as bl, type EnhancedTransaction as bm, type EnhancedTransactionEvents as bn, type EnhancedTransactionType as bo, ErrorCode as bp, type EthereumAdapterConfig as bq, EthereumChainId as br, type EthereumChainIdType as bs, type EthereumChainMetadata as bt, type EthereumTokenMetadata as bu, type EthereumTransactionReceipt as bv, type EthereumTransactionRequest as bw, EthereumWalletAdapter as bx, type EthereumWalletName as by, type ExchangeExposureResult as bz, type AdvisorRecommendation as c, MAX_PROOF_SIZE_BYTES as c$, GenericProvider as c0, type GenericProviderConfig as c1, type GetTransactionHistoryOptions as c2, type Halo2NativeProof as c3, Halo2ProofConverter as c4, type HardwareAccount as c5, type HardwareConnectionStatus as c6, type HardwareDeviceInfo as c7, HardwareErrorCode as c8, type HardwareErrorCodeType as c9, InvalidProofError as cA, type InvalidationRule as cB, type InvalidationStrategy as cC, JITO_BLOCK_ENGINES as cD, JITO_DEFAULTS as cE, JITO_TIP_ACCOUNTS as cF, type JitoBundleRequest as cG, type JitoBundleResult as cH, JitoRelayer as cI, type JitoRelayerConfig as cJ, JitoRelayerError as cK, JitoRelayerErrorCode as cL, type Jurisdiction as cM, KNOWN_EXCHANGES as cN, KNOWN_ISSUERS as cO, type KimchiNativeProof as cP, KimchiProofConverter as cQ, type KnownExchange as cR, LRUCache as cS, type LRUCacheConfig as cT, type LatencyEstimate as cU, type LedgerConfig as cV, type LedgerModel as cW, LedgerWalletAdapter as cX, type LinkValidationResult as cY, type LogLevel as cZ, MAX_NEAR_AMOUNT as c_, type HardwareEthereumTx as ca, type HardwareSignRequest as cb, type HardwareSignature as cc, type HardwareTransport as cd, type HardwareWalletConfig as ce, HardwareWalletError as cf, type HardwareWalletType as cg, HeliusEnhanced as ch, type HeliusEnhancedConfig as ci, type HeliusEnhancedTransaction as cj, HeliusProvider as ck, type HeliusProviderConfig as cl, type HeliusWebhookPayload as cm, type HeliusWebhookTransaction as cn, type HistoryCompletenessParams as co, type ICacheKeyGenerator as cp, type ICompiledCircuitCache as cq, type ILRUCache as cr, type IMultiTierCache as cs, INITIAL_PROOF_CACHE_STATS as ct, type IPersistentCache as cu, type IProofCache as cv, type IVerificationKeyCache as cw, IndexedDBCache as cx, IntentBuilder as cy, IntentError as cz, type AdvisorResponse as d, NEAR_TOKEN_DECIMALS as d$, MAX_PUBLIC_INPUTS as d0, MEMO_PROGRAM_ID as d1, type MerkleProof as d2, type MobileBrowser as d3, type MobileDeviceInfo as d4, type MobilePlatform as d5, type MobileWASMCompatibility as d6, MockEthereumAdapter as d7, type MockEthereumAdapterConfig as d8, type MockHardwareConfig as d9, type NEARIntentsAdapterConfig as dA, NEARIntentsBackend as dB, type NEARNetwork as dC, type NEARPedersenCommitment as dD, type NEARPrivateTransferParams as dE, type NEARPrivateTransferResult as dF, type NEARScanParams as dG, type NEARScanResult as dH, type NEARStealthAddressResult as dI, type NEARStealthBalance as dJ, type NEARStealthMetaAddressResult as dK, type NEARTransactionData as dL, type NEARTransactionHistoryParams as dM, type NEARTransactionHistoryResult as dN, type NEARTransactionType as dO, type NEARViewingKey as dP, type NEARViewingKeyExport as dQ, type NEARViewingKeyStorage as dR, DEFAULT_GAS as dS, ED25519_ORDER as dT, NEAR_EXPLORER_URLS as dU, NEAR_FEE_CONTRACTS as dV, NEAR_IMPLICIT_ACCOUNT_LENGTH as dW, MAX_COMMITMENT_VALUE as dX, NEAR_RPC_ENDPOINTS as dY, SIP_MEMO_PREFIX$1 as dZ, NEAR_TOKEN_CONTRACTS as d_, MockLedgerAdapter as da, MockObliviousSyncProvider as db, MockProofProvider as dc, MockSolanaAdapter as dd, type MockSolanaAdapterConfig as de, MockSolver as df, type MockSolverConfig as dg, type MockSyncProviderConfig as dh, MockTrezorAdapter as di, MockWalletAdapter as dj, MultiTierCache as dk, type MultiTierCacheConfig as dl, type NEARAnnouncement as dm, type NEARClaimParams as dn, type NEARClaimResult as dp, type NEARCommitmentPoint as dq, type NEARDetectedPayment as dr, type NEAREncryptedPayload as ds, type NEARExportFormat as dt, type NEARExportOptions as du, NEARFeeContract as dv, type NEARFeeContractOptions as dw, type NEARHistoricalTransaction as dx, type NEARHistoryPrivacyLevel as dy, NEARIntentsAdapter as dz, type AdvisorRole as e, PrivateNFT as e$, type NEP141TokenCommitment as e0, type NativeProofFormat as e1, type NativeTransfer as e2, NetworkError as e3, type NetworkPrivacyConfig as e4, type NftTransfer as e5, type NoirCircuitType as e6, type NoirNativeProof as e7, NoirProofConverter as e8, ONE_NEAR as e9, type ParsedProxyConfig as eA, PaymentBuilder as eB, type PdfExportOptions as eC, type PedersenCommitment as eD, type PersistentCacheConfig as eE, type PreparedSwap as eF, type PriceFeed as eG, PrivacyAdvisorAgent as eH, type PrivacyAdvisorConfig as eI, type PrivacyAdvisoryReport as eJ, type AvailabilityResult as eK, type PrivacyBackend as eL, type BackendCapabilities as eM, PrivacyBackendRegistry as eN, type BackendSelectionResult as eO, type BackendType as eP, type PrivacyConfig as eQ, type PrivacyDisplayOptions as eR, PrivacyLogger as eS, type PrivacyLoggerConfig as eT, type PrivacyRecommendation as eU, type PrivacyScore as eV, type PrivacyScoreBreakdown as eW, SmartRouter as eX, type SmartRouterConfig as eY, type TransactionResult as eZ, type TransferParams as e_, ONE_YOCTO as ea, ORACLE_DOMAIN as eb, type ObliviousNullifier as ec, type ObliviousSyncConfig as ed, ObliviousSyncError as ee, ObliviousSyncErrorCode as ef, type ObliviousSyncProvider as eg, type ObliviousSyncQuery as eh, type ObliviousSyncResponse as ei, OneClickClient as ej, type OracleAttestationMessage as ek, type OracleId as el, type OracleInfo as em, type OracleRegistry as en, type OracleRegistryConfig as eo, type OracleSignature as ep, type OracleStatus as eq, type OrchestratorConfig as er, type OrchestratorProgressCallback as es, type OrchestratorProgressEvent as et, type OrchestratorResult as eu, PALLAS_MODULUS as ev, PROXY_ENV_VAR as ew, PROXY_ENV_VARS as ex, type ParallelAggregationOptions as ey, type ParseTransactionsOptions as ez, type AdvisorStatus as f, type SameChainExecutor as f$, PrivateVoting as f0, type ProductionConfigError as f1, type ProductionConfigValidationResult as f2, type ProductionConfigWarning as f3, type ProductionQuote as f4, ProductionSafetyError as f5, ProofAggregator as f6, type AuditLogEntry as f7, type ProofCacheStats as f8, ProofConversionError as f9, type RiskLevel as fA, type Route as fB, type RouteWithQuote as fC, type RouterPriority as fD, SIP as fE, type SIPConfig as fF, type SIPEnhancedTransaction as fG, SIPError as fH, type SIPLogLevel as fI, type SIPLoggerConfig as fJ, SIPNativeBackend as fK, type SIPNativeBackendConfig as fL, type SIPProtectionComparison as fM, type SIPTransactionMetadata as fN, SIP_MEMO_PREFIX as fO, SOLANA_EXPLORER_URLS as fP, SOLANA_RPC_ENDPOINTS$1 as fQ, SOLANA_TOKEN_DECIMALS as fR, SOLANA_TOKEN_MINTS as fS, SOLANA_ZK_PROGRAM_IDS as fT, STABLECOIN_ADDRESSES as fU, STABLECOIN_DECIMALS as fV, STABLECOIN_INFO as fW, SUPPORTED_JURISDICTIONS as fX, SYSTEM_INFO as fY, type SameChainExecuteParams as fZ, type SameChainExecuteResult as f_, type ProofConverter as fa, type ProofDependency as fb, ProofError as fc, ProofNotImplementedError as fd, ProofOrchestrator as fe, type ProofProgressCallback as ff, type ProofStatistics as fg, type ProofSystemToNativeMap as fh, type ProviderConfig as fi, type ProviderType as fj, type ProxiedFetch as fk, type ProxyAgentOptions as fl, type ProxyCheckResult as fm, type ProxyConfig as fn, type ProxyType as fo, type QuoteComparison as fp, type RangeAPIConfig as fq, type RangeSASAttestation as fr, type ReceivedNote as fs, type RecursiveAggregationOptions as ft, type RegisteredBackend as fu, type RegulatoryExport as fv, type RegulatoryFormat as fw, type RelayedTransactionRequest as fx, type RelayedTransactionResult as fy, type RevealedVote as fz, type AdvisoryContext as g, SurveillanceAnalyzer as g$, type SameChainTransferParams as g0, type SameChainTransferResult as g1, type SanctionsClearParams as g2, type SealedBid as g3, SealedBidAuction as g4, SecurityError as g5, type SensitiveData as g6, type SequentialAggregationOptions as g7, type SerializedError as g8, type SettlementBackend as g9, type SolanaNoirVerifierConfig as gA, type SolanaPrivateTransferParams as gB, type SolanaPrivateTransferResult as gC, type SolanaPublicKey as gD, type SolanaRPCProvider as gE, type SolanaCluster as gF, type SolanaSameChainConfig as gG, SolanaSameChainExecutor as gH, type SolanaScanParams as gI, type SolanaScanResult as gJ, type SolanaSendOptions as gK, type SolanaSerializedProof as gL, type SolanaSignature as gM, type SolanaTransaction as gN, type SolanaUnsignedTransaction as gO, type SolanaVerificationKey as gP, type SolanaVerificationResult as gQ, type SolanaVerifyInstruction as gR, type SolanaVersionedTransaction as gS, SolanaWalletAdapter as gT, type SolanaWalletName as gU, type SolanaWalletProvider as gV, type StablecoinInfo as gW, type StealthCurve as gX, type StreamCallback as gY, type SuiStealthResult as gZ, SuiStealthService as g_, type SettlementBackendFactory as ga, type SettlementBackendName as gb, type SettlementBackendRegistry as gc, type Quote as gd, type QuoteParams as ge, SettlementRegistry as gf, SettlementRegistryError as gg, type SwapParams as gh, type SwapResult as gi, type SwapRoute as gj, type SwapRouteStep as gk, type ShieldedBalance as gl, type ShieldedSendParams as gm, type ShieldedSendResult as gn, type SignedOracleAttestation as go, SmartRouter$1 as gp, type SocialLinkResult as gq, type SolanaAdapterConfig as gr, type SolanaAnnouncement as gs, type SolanaClaimParams as gt, type SolanaClaimResult as gu, type SolanaCluster$1 as gv, type SolanaConnection as gw, SolanaNoirError as gx, SolanaNoirErrorCode as gy, SolanaNoirVerifier as gz, type AggregationProgressCallback as h, WalletError as h$, type SurveillanceAnalyzerConfig as h0, type SwapEvent as h1, type SwapRequest as h2, type SwapResult$1 as h3, SwapStatus as h4, type SwapStatusResponse as h5, type SyncCompletionEvent as h6, type SyncEventListener as h7, SyncManager as h8, type SyncManagerConfig as h9, type TrezorConfig as hA, type TrezorModel as hB, TrezorWalletAdapter as hC, type UnifiedOptimizationProfile as hD, type UnifiedOptimizationResult as hE, UnifiedProofConverter as hF, type UnlockResult as hG, UnsupportedVersionError as hH, type UnwrapParams as hI, type UnwrapResult as hJ, VESTA_MODULUS as hK, type ValidationCheck as hL, ValidationError$1 as hM, type ValidationOptions as hN, type ValidationReport as hO, type VerificationOrder as hP, VerificationPipeline as hQ, type VerificationPipelineConfig as hR, type VerificationProgressCallback as hS, type VerificationProgressEvent as hT, type VerificationResult as hU, type VerifyBidParams as hV, type VerifyOptions as hW, type ViewingKeyAccessParams as hX, type ViewingKeyDerivationResult as hY, type ViewingKeyScope as hZ, type WalletAdapter as h_, type SyncOptions as ha, type SyncProgressEvent as hb, type SyncRandomness as hc, type SyncServiceHealth as hd, type SystemInfo as he, type SystemVerificationStats as hf, TOR_CONTROL_PORT as hg, TOR_HOST as hh, TOR_PORTS as hi, type TapScript as hj, type TaprootOutput as hk, type TemporalPatternResult as hl, type ThresholdShares as hm, ThresholdViewingKey as hn, type TimeLockParams as ho, type TimeLockResult as hp, type TimeWindowedViewingKey as hq, type TokenAsset as hr, type TokenMetadata as hs, type TokenTransfer as ht, type ToolResult as hu, type ToolsConfig as hv, type TransactionData as hw, type TransactionSummary as hx, type TransportType as hy, Treasury as hz, type AggregationProgressEvent as i, computeTweakedKey as i$, type WalletSyncState as i0, type WarmingResult as i1, type WebhookHandler as i2, type WebhookHandlerConfig as i3, type WebhookProcessResult as i4, type WebhookRequest as i5, type WrapParams as i6, type WrapResult as i7, ZcashNativeBackend as i8, type ZcashNativeBackendConfig as i9, base58ToHex as iA, bnbOptimizations as iB, bpsToPercent as iC, bytesToHex as iD, hexToBytes as iE, cacheKeyGenerator as iF, calculateFeeForSwap as iG, calculatePrivacyScore as iH, calculateSIPComparison as iI, checkAptosStealthAddress as iJ, checkEd25519StealthAddress as iK, checkEd25519StealthAddressV1 as iL, checkMobileWASMCompatibility as iM, checkNEARStealthAddress as iN, checkProxyAvailability as iO, checkSecp256k1StealthAddressV1 as iP, checkStealthAddress as iQ, checkSuiStealthAddress as iR, claimStealthPayment as iS, commit as iT, commitNEAR as iU, commitNEP141Token as iV, commitZero as iW, compareCrossChainCosts as iX, computeAttestationHash as iY, computeNEARViewingKeyHash as iZ, computeNEARViewingKeyHashFromPrivate as i_, type ZcashQuote as ia, type ZcashQuoteParams as ib, ZcashRPCClient as ic, ZcashRPCError as id, type ZcashRpcConfig as ie, ZcashShieldedService as ig, type ZcashShieldedServiceConfig as ih, type ZcashSwapParams as ii, type ZcashSwapResult as ij, ZcashSwapService as ik, type ZcashSwapServiceConfig as il, type ZcashSwapSourceChain as im, type ZcashSwapSourceToken as io, type ZcashSwapStatus as ip, addBlindings as iq, addBlindingsNEAR as ir, addCommitments as is, addCommitmentsNEAR as it, addOracle as iu, analyzeAddressReuse as iv, analyzeTemporalPatterns as iw, aptosAddressToAuthKey as ix, assertNoLocalhost as iy, attachProofs as iz, type AggregationStepResult as j, createShieldedPayment as j$, configureLogger as j0, convertFromSIP as j1, convertToSIP as j2, createAnalyzeWalletTool as j3, createAnnouncementMemo$1 as j4, createCacheKeyGenerator as j5, createCommitment as j6, createCrossSystemValidator as j7, createDevnetVerifier as j8, createEthereumAdapter as j9, createAnnouncementMemo as jA, createNEARFeeContract as jB, createNEARIntentsAdapter as jC, createNEARIntentsBackend as jD, createNEARMemoryStorage as jE, createNetworkPrivacyClient as jF, createNoirConverter as jG, createOracleRegistry as jH, createPersistentCache as jI, createPrivacyAdvisor as jJ, createPrivacyAdvisorTools as jK, createPrivacyLogger as jL, createPrivateOwnership as jM, createPrivateVoting as jN, createProductionConfig as jO, createProductionSIP as jP, createProofAggregator as jQ, createProofOrchestrator as jR, createProvider as jS, createProxiedFetch as jT, createProxyAgent as jU, createQuickScoreTool as jV, createSIP as jW, createSIPComparisonTool as jX, createSameChainExecutor as jY, createSealedBidAuction as jZ, createShieldedIntent as j_, createExplainTool as ja, createFeeCalculator as jb, createFileCache as jc, createHalo2Converter as jd, createHeliusEnhanced as je, createIndexedDBCache as jf, createJitoRelayer as jg, createKeySpendOnlyOutput as jh, createKimchiConverter as ji, createLRUCache as jj, createLedgerAdapter as jk, createLogger as jl, createMainnetFeeContract as jm, createMainnetRelayer as jn, createMainnetVerifier as jo, createMockAttestation as jp, createMockEthereumAdapter as jq, createMockEthereumProvider as jr, createMockLedgerAdapter as js, createMockSolanaAdapter as jt, createMockSolanaConnection as ju, createMockSolanaProvider as jv, createMockSolver as jw, createMockSyncProvider as jx, createMockTrezorAdapter as jy, createMultiTierCache as jz, type AggregatorConfig as k, fetchAttestation as k$, createSmartRouter as k0, createSolanaAdapter as k1, createSurveillanceAnalyzer as k2, createSyncManager as k3, createSyncState as k4, createTaprootOutput as k5, createTestnetFeeContract as k6, createTimeWindowedKey as k7, createTrezorAdapter as k8, createUnifiedConverter as k9, deserializeAttestationMessage as kA, deserializeIntent as kB, deserializePayment as kC, detectChainFamily as kD, detectClusters as kE, detectEthereumWallets as kF, detectExchangeExposure as kG, detectMobileBrowser as kH, detectMobilePlatform as kI, detectSolanaWallets as kJ, detectTorPort as kK, ed25519PublicKeyToAptosAddress as kL, ed25519PublicKeyToImplicitAccount as kM, ed25519PublicKeyToNearAddress as kN, ed25519PublicKeyToSolanaAddress as kO, ed25519PublicKeyToSuiAddress as kP, encodeNEARStealthMetaAddress as kQ, encodeStealthMetaAddress as kR, encryptForNEARViewing as kS, encryptForViewing as kT, estimateComputeUnits as kU, estimateFee as kV, estimatePrivateTransferFee as kW, optimizations as kX, exportNEARViewingKey as kY, exportTransactions as kZ, featureNotSupportedError as k_, createVerificationPipeline as ka, createWalletFactory as kb, createWebhookHandler as kc, createZcashClient as kd, createZcashNativeBackend as ke, createZcashShieldedService as kf, createZcashSwapService as kg, decodeStealthMetaAddress as kh, decodeTaprootAddress as ki, decryptMemo as kj, decryptWithNEARViewing as kk, decryptWithViewing as kl, defaultRegistry as km, deriveAptosStealthPrivateKey as kn, deriveEd25519StealthPrivateKey as ko, deriveEd25519StealthPrivateKeyV1 as kp, deriveNEARChildViewingKey as kq, deriveNEARStealthPrivateKey as kr, deriveObliviousNullifier as ks, deriveOracleId as kt, deriveSecp256k1StealthPrivateKeyV1 as ku, deriveStealthPrivateKey as kv, deriveStealthPrivateKeyV1 as kw, deriveSuiStealthPrivateKey as kx, deriveTraditionalNullifier as ky, deriveViewingKey as kz, type AnalyzableTransaction as l, getSupportedSameChainChains as l$, fetchWalletAttestations as l0, formatFee as l1, formatStablecoinAmount as l2, fromHex as l3, fromStablecoinUnits as l4, fromYoctoNEAR as l5, generateAptosStealthAddress as l6, generateBlinding as l7, generateBlindingNEAR as l8, generateCosmosStealthAddress as l9, getDerivationPath as lA, getErrorMessage as lB, getEthereumProvider as lC, getGenerators as lD, getGeneratorsNEAR as lE, getIntentSummary as lF, getLogLevelName as lG, getMobileDeviceInfo as lH, getAccountExplorerUrl as lI, getExplorerUrl$1 as lJ, getTokenContract as lK, getNEARViewingPublicKey as lL, getNativeToken as lM, getOSVersion as lN, getPaymentSummary as lO, getPaymentTimeRemaining as lP, getPrivacyConfig as lQ, getPrivacyDescription as lR, getProductionUrl as lS, getProxyFromEnv as lT, getExplorerUrl as lU, getSolanaProvider as lV, getSolanaTokenDecimals as lW, getStablecoin as lX, getStablecoinInfo as lY, getStablecoinsForChain as lZ, getStealthBalance as l_, generateCosmosStealthMetaAddress as la, generateEd25519StealthAddress as lb, generateEd25519StealthMetaAddress as lc, generateIntentId as ld, generateNEARStealthAddress as le, generateNEARStealthMetaAddress as lf, generateNEARViewingKeyFromSpending as lg, generatePdfReport as lh, generateRandomBytes as li, generateRandomNEARViewingKey as lj, generateStealthAddress as lk, generateStealthMetaAddress as ll, generateSuiStealthAddress as lm, generateSyncRandomness as ln, generateViewingKey as lo, getActiveOracles as lp, getAsset as lq, getAvailableTransports as lr, getBrowserInfo as ls, getBrowserVersion as lt, getChainCharacteristics as lu, getChainNumericId as lv, getChainsForStablecoin as lw, getCurrentEpoch as lx, getCurveForChain as ly, getDefaultRpcEndpoint as lz, type AnyNativeProof as m, logger as m$, getSupportedStablecoins as m0, getTimeRemaining as m1, getTokenByAddress as m2, getTokenDecimals as m3, getTokenMint as m4, getTokensForChain as m5, getTransactionByHash as m6, getTransactionCount as m7, getTransactionHistory as m8, getTransactionSummary as m9, isSameChainSupported as mA, isSecurityError as mB, isStablecoin as mC, isStablecoinOnChain as mD, isSyncRandomnessValid as mE, isTablet as mF, isTorAvailable as mG, isValidAmount as mH, isValidAptosAddress as mI, isValidChainId as mJ, isValidCompressedPublicKey as mK, isValidCosmosAddress as mL, isValidEd25519PublicKey as mM, isValidHex as mN, isValidHexLength as mO, isValidAccountId as mP, isValidNearAccountId as mQ, isValidNearImplicitAddress as mR, isValidPrivacyLevel as mS, isValidPrivateKey as mT, isValidScalar as mU, isValidSlippage as mV, isValidSolanaAddress as mW, isValidSolanaProof as mX, isValidStealthMetaAddress as mY, isValidSuiAddress as mZ, isValidTaprootAddress as m_, getXOnlyPublicKey as ma, hasEnoughOracles as mb, hasErrorCode as mc, hasRequiredProofs as md, hasTokenAccount as me, hash as mf, hexToNumber as mg, implicitAccountToEd25519PublicKey as mh, importNEARViewingKey as mi, isBrowser as mj, isEd25519Chain as mk, isExpired as ml, isImplicitAccount as mm, isKnownToken as mn, isLevelEnabled as mo, isLocalhostAllowed as mp, isLocalhostUrl as mq, isNEARAnnouncementForViewingKey as mr, isNamedAccount as ms, isNoirCircuitType as mt, isNonNegativeAmount as mu, isNoteInWindow as mv, isPaymentExpired as mw, isPrivateWalletAdapter as mx, isProductionEnvironment as my, isSIPError as mz, type ApproveParams as n, validateCreateIntentParams as n$, maskAmount as n0, nearAddressToEd25519PublicKey as n1, normalizeAddress as n2, normalizeSuiAddress as n3, notConnectedError as n4, parseAnnouncement$1 as n5, parseAnnouncement as n6, parseNEARStealthMetaAddress as n7, parseProxyConfig as n8, parseStealthAddress as n9, signAttestationMessage as nA, silenceLogger as nB, solanaAddressToEd25519PublicKey as nC, optimizations$1 as nD, solanaPublicKeyToHex as nE, stealthKeyToCosmosAddress as nF, subtractBlindings as nG, subtractBlindingsNEAR as nH, subtractCommitments as nI, subtractCommitmentsNEAR as nJ, supportsSharedArrayBuffer as nK, supportsTouch as nL, supportsWASMBulkMemory as nM, supportsWASMSimd as nN, supportsWebBluetooth as nO, supportsWebHID as nP, supportsWebUSB as nQ, supportsWebWorkers as nR, taprootAddress as nS, toHex as nT, toStablecoinUnits as nU, toYoctoNEAR as nV, trackIntent as nW, trackPayment as nX, updateOracleStatus as nY, updateSyncState as nZ, validateAsset as n_, percentToBps as na, privacyLogger as nb, processWebhookTransaction as nc, proveOwnership as nd, publicKeyToEthAddress as ne, recommendCheapestChain as nf, recommendProfile as ng, redactAddress as nh, redactSensitiveData as ni, redactSignature as nj, registerWallet as nk, removeOracle as nl, rotateCircuit as nm, scanForPayments as nn, schnorrSign as no, schnorrSignHex as np, schnorrVerify as nq, schnorrVerifyHex as nr, secureWipe as ns, secureWipeAll as nt, selectOptimalConfig as nu, sendPrivateSPLTransfer as nv, serializeAttestationMessage as nw, serializeIntent as nx, serializePayment as ny, setLogLevel as nz, type ApproveResult as o, validateIntentInput as o0, validateIntentOutput as o1, validateNEARStealthAddress as o2, validateNEARStealthMetaAddress as o3, validateNEARViewingKey as o4, validateProductionConfig as o5, validateScalar as o6, validateViewingKey as o7, verifyAttestation as o8, verifyAttestationSignature as o9, verifyAuthToken as oa, verifyCommitment as ob, verifyNEP141TokenCommitment as oc, verifyOpening as od, verifyOpeningNEAR as oe, verifyOracleSignature as of, verifyOwnership as og, verifyWebhookSignature as oh, walletRegistry as oi, withSecureBuffer as oj, withSecureBufferSync as ok, wrapError as ol, type AptosStealthResult as p, AptosStealthService as q, type AttestationGatedConfig as r, AttestationGatedDisclosure as s, type AttestationRequest as t, type AttestationResult as u, AttestationSchema as v, type AttestationVerificationResult as w, type AuditReport as x, AuditorKeyDerivation as y, AuditorType as z };
+export { type CSPLServiceStatus as $, ATTESTATION_VERSION as A, BLS12_381_MODULUS as B, BN254_MODULUS as C, BUILTIN_TEMPLATES as D, type BackendCapabilities$1 as E, type BackendRegistrationOptions as F, type BalanceAttestationParams as G, BaseProofComposer as H, BaseWalletAdapter as I, type BatchVerificationRequest as J, type BatchVerificationResult as K, type BidReceipt as L, type BitcoinNetwork$1 as M, type BlockRange as N, type BridgeProvider as O, BrowserNoirProvider as P, type BrowserNoirProviderConfig as Q, CHAIN_NUMERIC_IDS as R, CIRCUIT_METADATA as S, COMPLIANCE_CIRCUIT_IDS as T, ETH_RPC_ENDPOINTS as U, SOLANA_RPC_ENDPOINTS as V, SUI_RPC_ENDPOINTS as W, CHAIN_PREFIXES as X, CSPLClient as Y, ZCASH_RPC_CONFIG as Z, type CSPLClientConfig as _, type AddressReuseResult as a, DEFAULT_VALIDITY_PERIOD_SECONDS as a$, CSPLTokenService as a0, type CSPLTokenServiceConfig as a1, type CSVExport as a2, type CacheEntry as a3, type CacheEntryMetadata as a4, type CacheEvent as a5, type CacheEventListener as a6, type CacheEventType as a7, type CacheKey as a8, type CacheKeyComponents as a9, type CosmosChainId as aA, type CosmosStealthResult as aB, CosmosStealthService as aC, type CreateBidParams as aD, type CreateIntentOptions as aE, type CreatePaymentOptions as aF, CrossSystemValidator as aG, CryptoError as aH, DEFAULT_AGGREGATOR_CONFIG as aI, DEFAULT_CHAIN_FEES as aJ, DEFAULT_CONVERSION_OPTIONS as aK, DEFAULT_FEE_TIERS as aL, DEFAULT_LRU_CONFIG as aM, DEFAULT_MANAGER_CONFIG as aN, DEFAULT_MOCK_CONFIG as aO, DEFAULT_MULTI_TIER_CONFIG as aP, DEFAULT_NETWORK_CONFIG as aQ, DEFAULT_ORCHESTRATOR_CONFIG as aR, DEFAULT_PERSISTENT_CONFIG as aS, DEFAULT_PIPELINE_CONFIG as aT, DEFAULT_PROXY_TIMEOUT as aU, DEFAULT_RANGE_API_ENDPOINT as aV, DEFAULT_RPC_URLS as aW, DEFAULT_SYNC_CONFIG as aX, DEFAULT_THRESHOLD as aY, DEFAULT_TOTAL_ORACLES as aZ, DEFAULT_TREASURY as a_, CacheKeyGenerator as aa, type CacheLookupResult as ab, type CacheWarmingConfig as ac, type CastVoteParams as ad, type ChainCharacteristics as ae, type ChainFamily as af, type ChainFeeConfig as ag, type ClusterResult as ah, type CommitmentPoint as ai, type CompatibilityEntry as aj, ComplianceManager as ak, type ComplianceProofConfig as al, ComplianceProofProvider as am, type ComplianceProofResult as an, type ComplianceProofType as ao, ComplianceReporter as ap, type CompositionPlan as aq, type CompositionRequest as ar, type CompositionState as as, type CompositionTemplate as at, ConditionalDisclosure as au, type ConversionErrorCode as av, type ConversionMetadata as aw, type ConversionOptions as ax, type ValidationError as ay, type ValidationResult as az, type AdvisorMessage as b, type FullAnalysisResult as b$, DEFAULT_WARMING_CONFIG as b0, type DecryptedTransaction as b1, DerivationPath as b2, type DeriveMultipleParams as b3, type DeriveStealthSignerParams as b4, type DeriveViewingKeyParams as b5, type DerivedViewingKey as b6, type DetailedAggregationResult as b7, type DetailedVerificationResult as b8, type EIP1193ConnectInfo as b9, type ExchangeExposureResult as bA, type ExportForRegulatorParams as bB, type ExportedViewingKey as bC, type FATFExport as bD, type FATFTransaction as bE, type FINCENExport as bF, type FINCENTransaction as bG, type FeeBreakdown as bH, type FeeCalculationInput as bI, type FeeCalculationResult as bJ, FeeCalculator as bK, type FeeCalculatorOptions as bL, type FeeCollectionEvent as bM, type FeeCollectionParams as bN, type FeeCollectionResult as bO, type FeeContractMethods as bP, type FeeContractState as bQ, type FeeGovernanceProposal as bR, type FeeModel as bS, type FeeStats as bT, type FeeTier as bU, type TreasuryConfig as bV, type FeeWaiver as bW, type FeeWaiverType as bX, type FieldCharacteristics as bY, FileCache as bZ, type FindBestRouteParams as b_, type EIP1193Event as ba, type EIP1193Provider as bb, type EIP1193ProviderRpcError as bc, type EIP1193RequestArguments as bd, type EIP712Domain as be, type EIP712TypeDefinition as bf, type EIP712TypedData as bg, type EIP712Types as bh, type EllipticCurve as bi, type EncryptedNote as bj, type EncryptedVote as bk, EncryptionNotImplementedError as bl, type EnhancedAccountData as bm, type EnhancedTransaction as bn, type EnhancedTransactionEvents as bo, type EnhancedTransactionType as bp, ErrorCode as bq, type EthereumAdapterConfig as br, EthereumChainId as bs, type EthereumChainIdType as bt, type EthereumChainMetadata as bu, type EthereumTokenMetadata as bv, type EthereumTransactionReceipt as bw, type EthereumTransactionRequest as bx, EthereumWalletAdapter as by, type EthereumWalletName as bz, type AdvisorRecommendation as c, LedgerWalletAdapter as c$, type GaslessCashoutBuild as c0, type GaslessCashoutParams as c1, type GaslessCashoutResult as c2, type GenerateAuditReportParams as c3, GenericProvider as c4, type GenericProviderConfig as c5, type GetTransactionHistoryOptions as c6, type Halo2NativeProof as c7, Halo2ProofConverter as c8, type HardwareAccount as c9, type IVerificationKeyCache as cA, IndexedDBCache as cB, IntentBuilder as cC, IntentError as cD, InvalidProofError as cE, type InvalidationRule as cF, type InvalidationStrategy as cG, JITO_BLOCK_ENGINES as cH, JITO_DEFAULTS as cI, JITO_TIP_ACCOUNTS as cJ, type JitoBundleRequest as cK, type JitoBundleResult as cL, JitoRelayer as cM, type JitoRelayerConfig as cN, JitoRelayerError as cO, JitoRelayerErrorCode as cP, type Jurisdiction as cQ, KNOWN_EXCHANGES as cR, KNOWN_ISSUERS as cS, type KimchiNativeProof as cT, KimchiProofConverter as cU, type KnownExchange as cV, LRUCache as cW, type LRUCacheConfig as cX, type LatencyEstimate as cY, type LedgerConfig as cZ, type LedgerModel as c_, type HardwareConnectionStatus as ca, type HardwareDeviceInfo as cb, HardwareErrorCode as cc, type HardwareErrorCodeType as cd, type HardwareEthereumTx as ce, type HardwareSignRequest as cf, type HardwareSignature as cg, type HardwareTransport as ch, type HardwareWalletConfig as ci, HardwareWalletError as cj, type HardwareWalletType as ck, HeliusEnhanced as cl, type HeliusEnhancedConfig as cm, type HeliusEnhancedTransaction as cn, HeliusProvider as co, type HeliusProviderConfig as cp, type HeliusWebhookPayload as cq, type HeliusWebhookTransaction as cr, type HistoryCompletenessParams as cs, type ICacheKeyGenerator as ct, type ICompiledCircuitCache as cu, type ILRUCache as cv, type IMultiTierCache as cw, INITIAL_PROOF_CACHE_STATS as cx, type IPersistentCache as cy, type IProofCache as cz, type AdvisorResponse as d, MAX_COMMITMENT_VALUE as d$, type LinkValidationResult as d0, type LogLevel as d1, MAX_NEAR_AMOUNT as d2, MAX_PROOF_SIZE_BYTES as d3, MAX_PUBLIC_INPUTS as d4, MEMO_PROGRAM_ID as d5, type MerkleProof as d6, type MobileBrowser as d7, type MobileDeviceInfo as d8, type MobilePlatform as d9, type NEARFeeContractOptions as dA, type NEARHistoricalTransaction as dB, type NEARHistoryPrivacyLevel as dC, NEARIntentsAdapter as dD, type NEARIntentsAdapterConfig as dE, NEARIntentsBackend as dF, type NEARNetwork as dG, type NEARPedersenCommitment as dH, type NEARPrivateTransferParams as dI, type NEARPrivateTransferResult as dJ, type NEARScanParams as dK, type NEARScanResult as dL, type NEARStealthAddressResult as dM, type NEARStealthBalance as dN, type NEARStealthMetaAddressResult as dO, type NEARTransactionData as dP, type NEARTransactionHistoryParams as dQ, type NEARTransactionHistoryResult as dR, type NEARTransactionType as dS, type NEARViewingKey as dT, type NEARViewingKeyExport as dU, type NEARViewingKeyStorage as dV, DEFAULT_GAS as dW, ED25519_ORDER as dX, NEAR_EXPLORER_URLS as dY, NEAR_FEE_CONTRACTS as dZ, NEAR_IMPLICIT_ACCOUNT_LENGTH as d_, type MobileWASMCompatibility as da, MockEthereumAdapter as db, type MockEthereumAdapterConfig as dc, type MockHardwareConfig as dd, MockLedgerAdapter as de, MockObliviousSyncProvider as df, MockProofProvider as dg, MockSolanaAdapter as dh, type MockSolanaAdapterConfig as di, MockSolver as dj, type MockSolverConfig as dk, type MockSyncProviderConfig as dl, MockTrezorAdapter as dm, MockWalletAdapter as dn, MultiTierCache as dp, type MultiTierCacheConfig as dq, type NEARAnnouncement as dr, type NEARClaimParams as ds, type NEARClaimResult as dt, type NEARCommitmentPoint as du, type NEARDetectedPayment as dv, type NEAREncryptedPayload as dw, type NEARExportFormat as dx, type NEARExportOptions as dy, NEARFeeContract as dz, type AdvisorRole as e, SmartRouter as e$, NEAR_RPC_ENDPOINTS as e0, SIP_MEMO_PREFIX$1 as e1, NEAR_TOKEN_CONTRACTS as e2, NEAR_TOKEN_DECIMALS as e3, type NEP141TokenCommitment as e4, type NativeProofFormat as e5, type NativeTransfer as e6, NetworkError as e7, type NetworkPrivacyConfig as e8, type NftTransfer as e9, PROXY_ENV_VAR as eA, PROXY_ENV_VARS as eB, type ParallelAggregationOptions as eC, type ParseTransactionsOptions as eD, type ParsedProxyConfig as eE, PaymentBuilder as eF, type PdfExportOptions as eG, type PedersenCommitment as eH, type PersistentCacheConfig as eI, type PreparedSwap as eJ, type PriceFeed as eK, PrivacyAdvisorAgent as eL, type PrivacyAdvisorConfig as eM, type PrivacyAdvisoryReport as eN, type AvailabilityResult as eO, type PrivacyBackend as eP, type BackendCapabilities as eQ, PrivacyBackendRegistry as eR, type BackendSelectionResult as eS, type BackendType as eT, type PrivacyConfig as eU, type PrivacyDisplayOptions as eV, PrivacyLogger as eW, type PrivacyLoggerConfig as eX, type PrivacyRecommendation as eY, type PrivacyScore as eZ, type PrivacyScoreBreakdown as e_, type NoirCircuitType as ea, type NoirNativeProof as eb, NoirProofConverter as ec, ONE_NEAR as ed, ONE_YOCTO as ee, ORACLE_DOMAIN as ef, type ObliviousNullifier as eg, type ObliviousSyncConfig as eh, ObliviousSyncError as ei, ObliviousSyncErrorCode as ej, type ObliviousSyncProvider as ek, type ObliviousSyncQuery as el, type ObliviousSyncResponse as em, OneClickClient as en, type OracleAttestationMessage as eo, type OracleId as ep, type OracleInfo as eq, type OracleRegistry as er, type OracleRegistryConfig as es, type OracleSignature as et, type OracleStatus as eu, type OrchestratorConfig as ev, type OrchestratorProgressCallback as ew, type OrchestratorProgressEvent as ex, type OrchestratorResult as ey, PALLAS_MODULUS as ez, type AdvisorStatus as f, STABLECOIN_ADDRESSES as f$, type SmartRouterConfig as f0, type TransactionResult as f1, type TransferParams as f2, PrivateNFT as f3, PrivateVoting as f4, type ProductionConfigError as f5, type ProductionConfigValidationResult as f6, type ProductionConfigWarning as f7, type ProductionQuote as f8, ProductionSafetyError as f9, type RegulatoryFormat as fA, type RelayedTransactionRequest as fB, type RelayedTransactionResult as fC, type RelayerFeeConfig as fD, type RevealedVote as fE, type RiskLevel as fF, type Route as fG, type RouteWithQuote as fH, type RouterPriority as fI, SIP as fJ, type SIPConfig as fK, type SIPEnhancedTransaction as fL, SIPError as fM, type SIPLogLevel as fN, type SIPLoggerConfig as fO, SIPNativeBackend as fP, type SIPNativeBackendConfig as fQ, type SIPProtectionComparison as fR, type SIPTransactionMetadata as fS, SIP_MEMO_PREFIX as fT, SIP_MEMO_PREFIX_ANY as fU, SIP_MEMO_PREFIX_V2 as fV, SOLANA_EXPLORER_URLS as fW, SOLANA_RPC_ENDPOINTS$1 as fX, SOLANA_TOKEN_DECIMALS as fY, SOLANA_TOKEN_MINTS as fZ, SOLANA_ZK_PROGRAM_IDS as f_, ProofAggregator as fa, type AuditLogEntry as fb, type ProofCacheStats as fc, ProofConversionError as fd, type ProofConverter as fe, type ProofDependency as ff, ProofError as fg, ProofNotImplementedError as fh, ProofOrchestrator as fi, type ProofProgressCallback as fj, type ProofStatistics as fk, type ProofSystemToNativeMap as fl, type ProviderConfig as fm, type ProviderType as fn, type ProxiedFetch as fo, type ProxyAgentOptions as fp, type ProxyCheckResult as fq, type ProxyConfig as fr, type ProxyType as fs, type QuoteComparison as ft, type RangeAPIConfig as fu, type RangeSASAttestation as fv, type ReceivedNote as fw, type RecursiveAggregationOptions as fx, type RegisteredBackend as fy, type RegulatoryExport as fz, type AdvisoryContext as g, type SolanaWalletName as g$, STABLECOIN_DECIMALS as g0, STABLECOIN_INFO as g1, SUPPORTED_JURISDICTIONS as g2, SYSTEM_INFO as g3, type SameChainExecuteParams as g4, type SameChainExecuteResult as g5, type SameChainExecutor as g6, type SameChainTransferParams as g7, type SameChainTransferResult as g8, type SanctionsClearParams as g9, type SolanaClaimParams as gA, type SolanaClaimResult as gB, type SolanaCluster$1 as gC, type SolanaConnection as gD, SolanaNoirError as gE, SolanaNoirErrorCode as gF, SolanaNoirVerifier as gG, type SolanaNoirVerifierConfig as gH, type SolanaPrivateTransferParams as gI, type SolanaPrivateTransferResult as gJ, type SolanaPublicKey as gK, type SolanaRPCProvider as gL, type SolanaCluster as gM, type SolanaSameChainConfig as gN, SolanaSameChainExecutor as gO, type SolanaScanParams as gP, type SolanaScanResult as gQ, type SolanaSendOptions as gR, type SolanaSerializedProof as gS, type SolanaSignature as gT, type SolanaTransaction as gU, type SolanaUnsignedTransaction as gV, type SolanaVerificationKey as gW, type SolanaVerificationResult as gX, type SolanaVerifyInstruction as gY, type SolanaVersionedTransaction as gZ, SolanaWalletAdapter as g_, type SealedBid as ga, SealedBidAuction as gb, SecurityError as gc, type SensitiveData as gd, type SequentialAggregationOptions as ge, type SerializedError as gf, type SettlementBackend as gg, type SettlementBackendFactory as gh, type SettlementBackendName as gi, type SettlementBackendRegistry as gj, type Quote as gk, type QuoteParams as gl, SettlementRegistry as gm, SettlementRegistryError as gn, type SwapParams as go, type SwapResult as gp, type SwapRoute as gq, type SwapRouteStep as gr, type ShieldedBalance as gs, type ShieldedSendParams as gt, type ShieldedSendResult as gu, type SignedOracleAttestation as gv, SmartRouter$1 as gw, type SocialLinkResult as gx, type SolanaAdapterConfig as gy, type SolanaAnnouncement as gz, type AggregationProgressCallback as h, type VerificationProgressCallback as h$, type SolanaWalletProvider as h0, type StablecoinInfo as h1, type StealthCurve as h2, type StealthSigner as h3, type StreamCallback as h4, type SubmitGaslessCashoutParams as h5, type SuiStealthResult as h6, SuiStealthService as h7, SurveillanceAnalyzer as h8, type SurveillanceAnalyzerConfig as h9, type TokenAsset as hA, type TokenMetadata as hB, type TokenTransfer as hC, type ToolResult as hD, type ToolsConfig as hE, type TransactionData as hF, type TransactionSummary as hG, type TransportType as hH, Treasury as hI, type TrezorConfig as hJ, type TrezorModel as hK, TrezorWalletAdapter as hL, type UnifiedOptimizationProfile as hM, type UnifiedOptimizationResult as hN, UnifiedProofConverter as hO, type UnlockResult as hP, UnsupportedVersionError as hQ, type UnwrapParams as hR, type UnwrapResult as hS, VESTA_MODULUS as hT, type ValidationCheck as hU, ValidationError$1 as hV, type ValidationOptions as hW, type ValidationReport as hX, type VerificationOrder as hY, VerificationPipeline as hZ, type VerificationPipelineConfig as h_, type SwapEvent as ha, type SwapRequest as hb, type SwapResult$1 as hc, SwapStatus as hd, type SwapStatusResponse as he, type SyncCompletionEvent as hf, type SyncEventListener as hg, SyncManager as hh, type SyncManagerConfig as hi, type SyncOptions as hj, type SyncProgressEvent as hk, type SyncRandomness as hl, type SyncServiceHealth as hm, type SystemInfo as hn, type SystemVerificationStats as ho, TOR_CONTROL_PORT as hp, TOR_HOST as hq, TOR_PORTS as hr, type TapScript as hs, type TaprootOutput as ht, type TemporalPatternResult as hu, type ThresholdShares as hv, ThresholdViewingKey as hw, type TimeLockParams as hx, type TimeLockResult as hy, type TimeWindowedViewingKey as hz, type AggregationProgressEvent as i, checkSuiStealthAddress as i$, type VerificationProgressEvent as i0, type VerificationResult as i1, type VerifyBidParams as i2, type VerifyOptions as i3, type ViewingKeyAccessParams as i4, type ViewingKeyDerivationResult as i5, type ViewingKeyScope as i6, type WalletAdapter as i7, WalletError as i8, type WalletSyncState as i9, addBlindingsNEAR as iA, addCommitments as iB, addCommitmentsNEAR as iC, addOracle as iD, analyzeAddressReuse as iE, analyzeTemporalPatterns as iF, aptosAddressToAuthKey as iG, assertNoLocalhost as iH, attachProofs as iI, base58ToHex as iJ, bnbOptimizations as iK, bpsToPercent as iL, bytesToHex as iM, hexToBytes as iN, buildGaslessCashout as iO, cacheKeyGenerator as iP, calculateFeeForSwap as iQ, calculatePrivacyScore as iR, calculateSIPComparison as iS, checkAptosStealthAddress as iT, checkEd25519StealthAddress as iU, checkEd25519StealthAddressV1 as iV, checkMobileWASMCompatibility as iW, checkNEARStealthAddress as iX, checkProxyAvailability as iY, checkSecp256k1StealthAddressV1 as iZ, checkStealthAddress as i_, type WarmingResult as ia, type WebhookHandler as ib, type WebhookHandlerConfig as ic, type WebhookProcessResult as id, type WebhookRequest as ie, type WrapParams as ig, type WrapResult as ih, ZcashNativeBackend as ii, type ZcashNativeBackendConfig as ij, type ZcashQuote as ik, type ZcashQuoteParams as il, ZcashRPCClient as im, ZcashRPCError as io, type ZcashRpcConfig as ip, ZcashShieldedService as iq, type ZcashShieldedServiceConfig as ir, type ZcashSwapParams as is, type ZcashSwapResult as it, ZcashSwapService as iu, type ZcashSwapServiceConfig as iv, type ZcashSwapSourceChain as iw, type ZcashSwapSourceToken as ix, type ZcashSwapStatus as iy, addBlindings as iz, type AggregationStepResult as j, createProofAggregator as j$, claimStealthPayment as j0, commit as j1, commitNEAR as j2, commitNEP141Token as j3, commitZero as j4, compareCrossChainCosts as j5, computeAttestationHash as j6, computeNEARViewingKeyHash as j7, computeNEARViewingKeyHashFromPrivate as j8, computeRelayerFee as j9, createMockAttestation as jA, createMockEthereumAdapter as jB, createMockEthereumProvider as jC, createMockLedgerAdapter as jD, createMockSolanaAdapter as jE, createMockSolanaConnection as jF, createMockSolanaProvider as jG, createMockSolver as jH, createMockSyncProvider as jI, createMockTrezorAdapter as jJ, createMultiTierCache as jK, createAnnouncementMemo as jL, createNEARFeeContract as jM, createNEARIntentsAdapter as jN, createNEARIntentsBackend as jO, createNEARMemoryStorage as jP, createNetworkPrivacyClient as jQ, createNoirConverter as jR, createOracleRegistry as jS, createPersistentCache as jT, createPrivacyAdvisor as jU, createPrivacyAdvisorTools as jV, createPrivacyLogger as jW, createPrivateOwnership as jX, createPrivateVoting as jY, createProductionConfig as jZ, createProductionSIP as j_, computeTweakedKey as ja, configureLogger as jb, convertFromSIP as jc, convertToSIP as jd, createAnalyzeWalletTool as je, createAnnouncementMemo$1 as jf, createCacheKeyGenerator as jg, createCommitment as jh, createCrossSystemValidator as ji, createDevnetVerifier as jj, createEthereumAdapter as jk, createExplainTool as jl, createFeeCalculator as jm, createFileCache as jn, createHalo2Converter as jo, createHeliusEnhanced as jp, createIndexedDBCache as jq, createJitoRelayer as jr, createKeySpendOnlyOutput as js, createKimchiConverter as jt, createLRUCache as ju, createLedgerAdapter as jv, createLogger as jw, createMainnetFeeContract as jx, createMainnetRelayer as jy, createMainnetVerifier as jz, type AggregatorConfig as k, ed25519PublicKeyToSuiAddress as k$, createProofOrchestrator as k0, createProvider as k1, createProxiedFetch as k2, createProxyAgent as k3, createQuickScoreTool as k4, createSIP as k5, createSIPComparisonTool as k6, createSameChainExecutor as k7, createSealedBidAuction as k8, createShieldedIntent as k9, deriveEd25519StealthPrivateKeyV1 as kA, deriveNEARChildViewingKey as kB, deriveNEARStealthPrivateKey as kC, deriveObliviousNullifier as kD, deriveOracleId as kE, deriveSecp256k1StealthPrivateKeyV1 as kF, deriveStealthPrivateKey as kG, deriveStealthPrivateKeyV1 as kH, deriveStealthSigner as kI, deriveSuiStealthPrivateKey as kJ, deriveTraditionalNullifier as kK, deriveViewingKey as kL, deserializeAttestationMessage as kM, deserializeIntent as kN, deserializePayment as kO, detectChainFamily as kP, detectClusters as kQ, detectEthereumWallets as kR, detectExchangeExposure as kS, detectMobileBrowser as kT, detectMobilePlatform as kU, detectSolanaWallets as kV, detectTorPort as kW, ed25519PublicKeyToAptosAddress as kX, ed25519PublicKeyToImplicitAccount as kY, ed25519PublicKeyToNearAddress as kZ, ed25519PublicKeyToSolanaAddress as k_, createShieldedPayment as ka, createSmartRouter as kb, createSolanaAdapter as kc, createSurveillanceAnalyzer as kd, createSyncManager as ke, createSyncState as kf, createTaprootOutput as kg, createTestnetFeeContract as kh, createTimeWindowedKey as ki, createTrezorAdapter as kj, createUnifiedConverter as kk, createVerificationPipeline as kl, createWalletFactory as km, createWebhookHandler as kn, createZcashClient as ko, createZcashNativeBackend as kp, createZcashShieldedService as kq, createZcashSwapService as kr, decodeStealthMetaAddress as ks, decodeTaprootAddress as kt, decryptMemo as ku, decryptWithNEARViewing as kv, decryptWithViewing as kw, defaultRegistry as kx, deriveAptosStealthPrivateKey as ky, deriveEd25519StealthPrivateKey as kz, type AnalyzableTransaction as l, getPaymentTimeRemaining as l$, encodeNEARStealthMetaAddress as l0, encodeStealthMetaAddress as l1, encryptForNEARViewing as l2, encryptForViewing as l3, estimateComputeUnits as l4, estimateFee as l5, estimatePrivateTransferFee as l6, optimizations as l7, exportNEARViewingKey as l8, exportTransactions as l9, generateViewingKey as lA, getActiveOracles as lB, getAsset as lC, getAvailableTransports as lD, getBrowserInfo as lE, getBrowserVersion as lF, getChainCharacteristics as lG, getChainNumericId as lH, getChainsForStablecoin as lI, getCurrentEpoch as lJ, getCurveForChain as lK, getDefaultRpcEndpoint as lL, getDerivationPath as lM, getErrorMessage as lN, getEthereumProvider as lO, getGenerators as lP, getGeneratorsNEAR as lQ, getIntentSummary as lR, getLogLevelName as lS, getMobileDeviceInfo as lT, getAccountExplorerUrl as lU, getExplorerUrl$1 as lV, getTokenContract as lW, getNEARViewingPublicKey as lX, getNativeToken as lY, getOSVersion as lZ, getPaymentSummary as l_, featureNotSupportedError as la, fetchAttestation as lb, fetchWalletAttestations as lc, formatFee as ld, formatStablecoinAmount as le, fromHex as lf, fromStablecoinUnits as lg, fromYoctoNEAR as lh, generateAptosStealthAddress as li, generateBlinding as lj, generateBlindingNEAR as lk, generateCosmosStealthAddress as ll, generateCosmosStealthMetaAddress as lm, generateEd25519StealthAddress as ln, generateEd25519StealthMetaAddress as lo, generateIntentId as lp, generateNEARStealthAddress as lq, generateNEARStealthMetaAddress as lr, generateNEARViewingKeyFromSpending as ls, generatePdfReport as lt, generateRandomBytes as lu, generateRandomNEARViewingKey as lv, generateStealthAddress as lw, generateStealthMetaAddress as lx, generateSuiStealthAddress as ly, generateSyncRandomness as lz, type AnyNativeProof as m, isValidAccountId as m$, getPrivacyConfig as m0, getPrivacyDescription as m1, getProductionUrl as m2, getProxyFromEnv as m3, getExplorerUrl as m4, getSolanaProvider as m5, getSolanaTokenDecimals as m6, getStablecoin as m7, getStablecoinInfo as m8, getStablecoinsForChain as m9, isLevelEnabled as mA, isLocalhostAllowed as mB, isLocalhostUrl as mC, isNEARAnnouncementForViewingKey as mD, isNamedAccount as mE, isNoirCircuitType as mF, isNonNegativeAmount as mG, isNoteInWindow as mH, isPaymentExpired as mI, isPrivateWalletAdapter as mJ, isProductionEnvironment as mK, isSIPError as mL, isSameChainSupported as mM, isSecurityError as mN, isStablecoin as mO, isStablecoinOnChain as mP, isSyncRandomnessValid as mQ, isTablet as mR, isTorAvailable as mS, isValidAmount as mT, isValidAptosAddress as mU, isValidChainId as mV, isValidCompressedPublicKey as mW, isValidCosmosAddress as mX, isValidEd25519PublicKey as mY, isValidHex as mZ, isValidHexLength as m_, getStealthBalance as ma, getSupportedSameChainChains as mb, getSupportedStablecoins as mc, getTimeRemaining as md, getTokenByAddress as me, getTokenDecimals as mf, getTokenMint as mg, getTokensForChain as mh, getTransactionByHash as mi, getTransactionCount as mj, getTransactionHistory as mk, getTransactionSummary as ml, getXOnlyPublicKey as mm, hasEnoughOracles as mn, hasErrorCode as mo, hasRequiredProofs as mp, hasTokenAccount as mq, hash as mr, hexToNumber as ms, implicitAccountToEd25519PublicKey as mt, importNEARViewingKey as mu, isBrowser as mv, isEd25519Chain as mw, isExpired as mx, isImplicitAccount as my, isKnownToken as mz, type ApproveParams as n, supportsWASMSimd as n$, isValidNearAccountId as n0, isValidNearImplicitAddress as n1, isValidPrivacyLevel as n2, isValidPrivateKey as n3, isValidScalar as n4, isValidSlippage as n5, isValidSolanaAddress as n6, isValidSolanaProof as n7, isValidStealthMetaAddress as n8, isValidSuiAddress as n9, schnorrSign as nA, schnorrSignHex as nB, schnorrVerify as nC, schnorrVerifyHex as nD, secureWipe as nE, secureWipeAll as nF, selectOptimalConfig as nG, sendPrivateSPLTransfer as nH, serializeAttestationMessage as nI, serializeIntent as nJ, serializePayment as nK, setLogLevel as nL, signAttestationMessage as nM, signEd25519WithScalar as nN, silenceLogger as nO, solanaAddressToEd25519PublicKey as nP, optimizations$1 as nQ, solanaPublicKeyToHex as nR, stealthKeyToCosmosAddress as nS, submitGaslessCashout as nT, subtractBlindings as nU, subtractBlindingsNEAR as nV, subtractCommitments as nW, subtractCommitmentsNEAR as nX, supportsSharedArrayBuffer as nY, supportsTouch as nZ, supportsWASMBulkMemory as n_, isValidTaprootAddress as na, logger as nb, maskAmount as nc, nearAddressToEd25519PublicKey as nd, normalizeAddress as ne, normalizeSuiAddress as nf, notConnectedError as ng, parseAnnouncement$1 as nh, parseAnnouncement as ni, parseNEARStealthMetaAddress as nj, parseProxyConfig as nk, parseStealthAddress as nl, percentToBps as nm, privacyLogger as nn, processWebhookTransaction as no, proveOwnership as np, publicKeyToEthAddress as nq, recommendCheapestChain as nr, recommendProfile as ns, redactAddress as nt, redactSensitiveData as nu, redactSignature as nv, registerWallet as nw, removeOracle as nx, rotateCircuit as ny, scanForPayments as nz, type ApproveResult as o, supportsWebBluetooth as o0, supportsWebHID as o1, supportsWebUSB as o2, supportsWebWorkers as o3, taprootAddress as o4, toHex as o5, toStablecoinUnits as o6, toYoctoNEAR as o7, trackIntent as o8, trackPayment as o9, updateOracleStatus as oa, updateSyncState as ob, validateAsset as oc, validateCreateIntentParams as od, validateIntentInput as oe, validateIntentOutput as of, validateNEARStealthAddress as og, validateNEARStealthMetaAddress as oh, validateNEARViewingKey as oi, validateProductionConfig as oj, validateScalar as ok, validateViewingKey as ol, verifyAttestation as om, verifyAttestationSignature as on, verifyAuthToken as oo, verifyCommitment as op, verifyNEP141TokenCommitment as oq, verifyOpening as or, verifyOpeningNEAR as os, verifyOracleSignature as ot, verifyOwnership as ou, verifyWebhookSignature as ov, walletRegistry as ow, withSecureBuffer as ox, withSecureBufferSync as oy, wrapError as oz, type AptosStealthResult as p, AptosStealthService as q, type AttestationGatedConfig as r, AttestationGatedDisclosure as s, type AttestationRequest as t, type AttestationResult as u, AttestationSchema as v, type AttestationVerificationResult as w, type AuditReport as x, AuditorKeyDerivation as y, AuditorType as z };