@sip-protocol/sdk 0.11.1 → 0.12.0

package/dist/{index-DH5XRHYV.d.mts → index-B_fGN4Fk.d.mts}

@@ -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.mjs';
@@ -15599,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 */
@@ -17164,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.
+ * 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.
  *
- * ## 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)
+ * @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
@@ -24779,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 SameChainExecuteParams 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, SIP_MEMO_PREFIX_ANY as fP, SIP_MEMO_PREFIX_V2 as fQ, SOLANA_EXPLORER_URLS as fR, SOLANA_RPC_ENDPOINTS$1 as fS, SOLANA_TOKEN_DECIMALS as fT, SOLANA_TOKEN_MINTS as fU, SOLANA_ZK_PROGRAM_IDS as fV, STABLECOIN_ADDRESSES as fW, STABLECOIN_DECIMALS as fX, STABLECOIN_INFO as fY, SUPPORTED_JURISDICTIONS as fZ, SYSTEM_INFO 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, type SuiStealthResult as g$, type SameChainExecuteResult as g0, type SameChainExecutor as g1, type SameChainTransferParams as g2, type SameChainTransferResult as g3, type SanctionsClearParams as g4, type SealedBid as g5, SealedBidAuction as g6, SecurityError as g7, type SensitiveData as g8, type SequentialAggregationOptions as g9, SolanaNoirErrorCode as gA, SolanaNoirVerifier as gB, type SolanaNoirVerifierConfig as gC, type SolanaPrivateTransferParams as gD, type SolanaPrivateTransferResult as gE, type SolanaPublicKey as gF, type SolanaRPCProvider as gG, type SolanaCluster as gH, type SolanaSameChainConfig as gI, SolanaSameChainExecutor as gJ, type SolanaScanParams as gK, type SolanaScanResult as gL, type SolanaSendOptions as gM, type SolanaSerializedProof as gN, type SolanaSignature as gO, type SolanaTransaction as gP, type SolanaUnsignedTransaction as gQ, type SolanaVerificationKey as gR, type SolanaVerificationResult as gS, type SolanaVerifyInstruction as gT, type SolanaVersionedTransaction as gU, SolanaWalletAdapter as gV, type SolanaWalletName as gW, type SolanaWalletProvider as gX, type StablecoinInfo as gY, type StealthCurve as gZ, type StreamCallback as g_, type SerializedError as ga, type SettlementBackend as gb, type SettlementBackendFactory as gc, type SettlementBackendName as gd, type SettlementBackendRegistry as ge, type Quote as gf, type QuoteParams as gg, SettlementRegistry as gh, SettlementRegistryError as gi, type SwapParams as gj, type SwapResult as gk, type SwapRoute as gl, type SwapRouteStep as gm, type ShieldedBalance as gn, type ShieldedSendParams as go, type ShieldedSendResult as gp, type SignedOracleAttestation as gq, SmartRouter$1 as gr, type SocialLinkResult as gs, type SolanaAdapterConfig as gt, type SolanaAnnouncement as gu, type SolanaClaimParams as gv, type SolanaClaimResult as gw, type SolanaCluster$1 as gx, type SolanaConnection as gy, SolanaNoirError as gz, type AggregationProgressCallback as h, type ViewingKeyScope as h$, SuiStealthService as h0, SurveillanceAnalyzer as h1, type SurveillanceAnalyzerConfig as h2, type SwapEvent as h3, type SwapRequest as h4, type SwapResult$1 as h5, SwapStatus as h6, type SwapStatusResponse as h7, type SyncCompletionEvent as h8, type SyncEventListener as h9, type TransportType as hA, Treasury as hB, type TrezorConfig as hC, type TrezorModel as hD, TrezorWalletAdapter as hE, type UnifiedOptimizationProfile as hF, type UnifiedOptimizationResult as hG, UnifiedProofConverter as hH, type UnlockResult as hI, UnsupportedVersionError as hJ, type UnwrapParams as hK, type UnwrapResult as hL, VESTA_MODULUS as hM, type ValidationCheck as hN, ValidationError$1 as hO, type ValidationOptions as hP, type ValidationReport as hQ, type VerificationOrder as hR, VerificationPipeline as hS, type VerificationPipelineConfig as hT, type VerificationProgressCallback as hU, type VerificationProgressEvent as hV, type VerificationResult as hW, type VerifyBidParams as hX, type VerifyOptions as hY, type ViewingKeyAccessParams as hZ, type ViewingKeyDerivationResult as h_, SyncManager as ha, type SyncManagerConfig as hb, type SyncOptions as hc, type SyncProgressEvent as hd, type SyncRandomness as he, type SyncServiceHealth as hf, type SystemInfo as hg, type SystemVerificationStats as hh, TOR_CONTROL_PORT as hi, TOR_HOST as hj, TOR_PORTS as hk, type TapScript as hl, type TaprootOutput as hm, type TemporalPatternResult as hn, type ThresholdShares as ho, ThresholdViewingKey as hp, type TimeLockParams as hq, type TimeLockResult as hr, type TimeWindowedViewingKey as hs, type TokenAsset as ht, type TokenMetadata as hu, type TokenTransfer as hv, type ToolResult as hw, type ToolsConfig as hx, type TransactionData as hy, type TransactionSummary as hz, type AggregationProgressEvent as i, computeNEARViewingKeyHash as i$, type WalletAdapter as i0, WalletError as i1, type WalletSyncState as i2, type WarmingResult as i3, type WebhookHandler as i4, type WebhookHandlerConfig as i5, type WebhookProcessResult as i6, type WebhookRequest as i7, type WrapParams as i8, type WrapResult as i9, assertNoLocalhost as iA, attachProofs as iB, base58ToHex as iC, bnbOptimizations as iD, bpsToPercent as iE, bytesToHex as iF, hexToBytes as iG, cacheKeyGenerator as iH, calculateFeeForSwap as iI, calculatePrivacyScore as iJ, calculateSIPComparison as iK, checkAptosStealthAddress as iL, checkEd25519StealthAddress as iM, checkEd25519StealthAddressV1 as iN, checkMobileWASMCompatibility as iO, checkNEARStealthAddress as iP, checkProxyAvailability as iQ, checkSecp256k1StealthAddressV1 as iR, checkStealthAddress as iS, checkSuiStealthAddress as iT, claimStealthPayment as iU, commit as iV, commitNEAR as iW, commitNEP141Token as iX, commitZero as iY, compareCrossChainCosts as iZ, computeAttestationHash as i_, ZcashNativeBackend as ia, type ZcashNativeBackendConfig as ib, type ZcashQuote as ic, type ZcashQuoteParams as id, ZcashRPCClient as ie, ZcashRPCError as ig, type ZcashRpcConfig as ih, ZcashShieldedService as ii, type ZcashShieldedServiceConfig as ij, type ZcashSwapParams as ik, type ZcashSwapResult as il, ZcashSwapService as im, type ZcashSwapServiceConfig as io, type ZcashSwapSourceChain as ip, type ZcashSwapSourceToken as iq, type ZcashSwapStatus as ir, addBlindings as is, addBlindingsNEAR as it, addCommitments as iu, addCommitmentsNEAR as iv, addOracle as iw, analyzeAddressReuse as ix, analyzeTemporalPatterns as iy, aptosAddressToAuthKey as iz, type AggregationStepResult as j, createSealedBidAuction as j$, computeNEARViewingKeyHashFromPrivate as j0, computeTweakedKey as j1, configureLogger as j2, convertFromSIP as j3, convertToSIP as j4, createAnalyzeWalletTool as j5, createAnnouncementMemo$1 as j6, createCacheKeyGenerator as j7, createCommitment as j8, createCrossSystemValidator as j9, createMockTrezorAdapter as jA, createMultiTierCache as jB, createAnnouncementMemo as jC, createNEARFeeContract as jD, createNEARIntentsAdapter as jE, createNEARIntentsBackend as jF, createNEARMemoryStorage as jG, createNetworkPrivacyClient as jH, createNoirConverter as jI, createOracleRegistry as jJ, createPersistentCache as jK, createPrivacyAdvisor as jL, createPrivacyAdvisorTools as jM, createPrivacyLogger as jN, createPrivateOwnership as jO, createPrivateVoting as jP, createProductionConfig as jQ, createProductionSIP as jR, createProofAggregator as jS, createProofOrchestrator as jT, createProvider as jU, createProxiedFetch as jV, createProxyAgent as jW, createQuickScoreTool as jX, createSIP as jY, createSIPComparisonTool as jZ, createSameChainExecutor as j_, createDevnetVerifier as ja, createEthereumAdapter as jb, createExplainTool as jc, createFeeCalculator as jd, createFileCache as je, createHalo2Converter as jf, createHeliusEnhanced as jg, createIndexedDBCache as jh, createJitoRelayer as ji, createKeySpendOnlyOutput as jj, createKimchiConverter as jk, createLRUCache as jl, createLedgerAdapter as jm, createLogger as jn, createMainnetFeeContract as jo, createMainnetRelayer as jp, createMainnetVerifier as jq, createMockAttestation as jr, createMockEthereumAdapter as js, createMockEthereumProvider as jt, createMockLedgerAdapter as ju, createMockSolanaAdapter as jv, createMockSolanaConnection as jw, createMockSolanaProvider as jx, createMockSolver as jy, createMockSyncProvider as jz, type AggregatorConfig as k, exportTransactions as k$, createShieldedIntent as k0, createShieldedPayment as k1, createSmartRouter as k2, createSolanaAdapter as k3, createSurveillanceAnalyzer as k4, createSyncManager as k5, createSyncState as k6, createTaprootOutput as k7, createTestnetFeeContract as k8, createTimeWindowedKey as k9, deriveTraditionalNullifier as kA, deriveViewingKey as kB, deserializeAttestationMessage as kC, deserializeIntent as kD, deserializePayment as kE, detectChainFamily as kF, detectClusters as kG, detectEthereumWallets as kH, detectExchangeExposure as kI, detectMobileBrowser as kJ, detectMobilePlatform as kK, detectSolanaWallets as kL, detectTorPort as kM, ed25519PublicKeyToAptosAddress as kN, ed25519PublicKeyToImplicitAccount as kO, ed25519PublicKeyToNearAddress as kP, ed25519PublicKeyToSolanaAddress as kQ, ed25519PublicKeyToSuiAddress as kR, encodeNEARStealthMetaAddress as kS, encodeStealthMetaAddress as kT, encryptForNEARViewing as kU, encryptForViewing as kV, estimateComputeUnits as kW, estimateFee as kX, estimatePrivateTransferFee as kY, optimizations as kZ, exportNEARViewingKey as k_, createTrezorAdapter as ka, createUnifiedConverter as kb, createVerificationPipeline as kc, createWalletFactory as kd, createWebhookHandler as ke, createZcashClient as kf, createZcashNativeBackend as kg, createZcashShieldedService as kh, createZcashSwapService as ki, decodeStealthMetaAddress as kj, decodeTaprootAddress as kk, decryptMemo as kl, decryptWithNEARViewing as km, decryptWithViewing as kn, defaultRegistry as ko, deriveAptosStealthPrivateKey as kp, deriveEd25519StealthPrivateKey as kq, deriveEd25519StealthPrivateKeyV1 as kr, deriveNEARChildViewingKey as ks, deriveNEARStealthPrivateKey as kt, deriveObliviousNullifier as ku, deriveOracleId as kv, deriveSecp256k1StealthPrivateKeyV1 as kw, deriveStealthPrivateKey as kx, deriveStealthPrivateKeyV1 as ky, deriveSuiStealthPrivateKey as kz, type AnalyzableTransaction as l, getStablecoinsForChain as l$, featureNotSupportedError as l0, fetchAttestation as l1, fetchWalletAttestations as l2, formatFee as l3, formatStablecoinAmount as l4, fromHex as l5, fromStablecoinUnits as l6, fromYoctoNEAR as l7, generateAptosStealthAddress as l8, generateBlinding as l9, getCurveForChain as lA, getDefaultRpcEndpoint as lB, getDerivationPath as lC, getErrorMessage as lD, getEthereumProvider as lE, getGenerators as lF, getGeneratorsNEAR as lG, getIntentSummary as lH, getLogLevelName as lI, getMobileDeviceInfo as lJ, getAccountExplorerUrl as lK, getExplorerUrl$1 as lL, getTokenContract as lM, getNEARViewingPublicKey as lN, getNativeToken as lO, getOSVersion as lP, getPaymentSummary as lQ, getPaymentTimeRemaining as lR, getPrivacyConfig as lS, getPrivacyDescription as lT, getProductionUrl as lU, getProxyFromEnv as lV, getExplorerUrl as lW, getSolanaProvider as lX, getSolanaTokenDecimals as lY, getStablecoin as lZ, getStablecoinInfo as l_, generateBlindingNEAR as la, generateCosmosStealthAddress as lb, generateCosmosStealthMetaAddress as lc, generateEd25519StealthAddress as ld, generateEd25519StealthMetaAddress as le, generateIntentId as lf, generateNEARStealthAddress as lg, generateNEARStealthMetaAddress as lh, generateNEARViewingKeyFromSpending as li, generatePdfReport as lj, generateRandomBytes as lk, generateRandomNEARViewingKey as ll, generateStealthAddress as lm, generateStealthMetaAddress as ln, generateSuiStealthAddress as lo, generateSyncRandomness as lp, generateViewingKey as lq, getActiveOracles as lr, getAsset as ls, getAvailableTransports as lt, getBrowserInfo as lu, getBrowserVersion as lv, getChainCharacteristics as lw, getChainNumericId as lx, getChainsForStablecoin as ly, getCurrentEpoch as lz, type AnyNativeProof as m, isValidSuiAddress as m$, getStealthBalance as m0, getSupportedSameChainChains as m1, getSupportedStablecoins as m2, getTimeRemaining as m3, getTokenByAddress as m4, getTokenDecimals as m5, getTokenMint as m6, getTokensForChain as m7, getTransactionByHash as m8, getTransactionCount as m9, isProductionEnvironment as mA, isSIPError as mB, isSameChainSupported as mC, isSecurityError as mD, isStablecoin as mE, isStablecoinOnChain as mF, isSyncRandomnessValid as mG, isTablet as mH, isTorAvailable as mI, isValidAmount as mJ, isValidAptosAddress as mK, isValidChainId as mL, isValidCompressedPublicKey as mM, isValidCosmosAddress as mN, isValidEd25519PublicKey as mO, isValidHex as mP, isValidHexLength as mQ, isValidAccountId as mR, isValidNearAccountId as mS, isValidNearImplicitAddress as mT, isValidPrivacyLevel as mU, isValidPrivateKey as mV, isValidScalar as mW, isValidSlippage as mX, isValidSolanaAddress as mY, isValidSolanaProof as mZ, isValidStealthMetaAddress as m_, getTransactionHistory as ma, getTransactionSummary as mb, getXOnlyPublicKey as mc, hasEnoughOracles as md, hasErrorCode as me, hasRequiredProofs as mf, hasTokenAccount as mg, hash as mh, hexToNumber as mi, implicitAccountToEd25519PublicKey as mj, importNEARViewingKey as mk, isBrowser as ml, isEd25519Chain as mm, isExpired as mn, isImplicitAccount as mo, isKnownToken as mp, isLevelEnabled as mq, isLocalhostAllowed as mr, isLocalhostUrl as ms, isNEARAnnouncementForViewingKey as mt, isNamedAccount as mu, isNoirCircuitType as mv, isNonNegativeAmount as mw, isNoteInWindow as mx, isPaymentExpired as my, isPrivateWalletAdapter as mz, type ApproveParams as n, updateSyncState as n$, isValidTaprootAddress as n0, logger as n1, maskAmount as n2, nearAddressToEd25519PublicKey as n3, normalizeAddress as n4, normalizeSuiAddress as n5, notConnectedError as n6, parseAnnouncement$1 as n7, parseAnnouncement as n8, parseNEARStealthMetaAddress as n9, serializePayment as nA, setLogLevel as nB, signAttestationMessage as nC, silenceLogger as nD, solanaAddressToEd25519PublicKey as nE, optimizations$1 as nF, solanaPublicKeyToHex as nG, stealthKeyToCosmosAddress as nH, subtractBlindings as nI, subtractBlindingsNEAR as nJ, subtractCommitments as nK, subtractCommitmentsNEAR as nL, supportsSharedArrayBuffer as nM, supportsTouch as nN, supportsWASMBulkMemory as nO, supportsWASMSimd as nP, supportsWebBluetooth as nQ, supportsWebHID as nR, supportsWebUSB as nS, supportsWebWorkers as nT, taprootAddress as nU, toHex as nV, toStablecoinUnits as nW, toYoctoNEAR as nX, trackIntent as nY, trackPayment as nZ, updateOracleStatus as n_, parseProxyConfig as na, parseStealthAddress as nb, percentToBps as nc, privacyLogger as nd, processWebhookTransaction as ne, proveOwnership as nf, publicKeyToEthAddress as ng, recommendCheapestChain as nh, recommendProfile as ni, redactAddress as nj, redactSensitiveData as nk, redactSignature as nl, registerWallet as nm, removeOracle as nn, rotateCircuit as no, scanForPayments as np, schnorrSign as nq, schnorrSignHex as nr, schnorrVerify as ns, schnorrVerifyHex as nt, secureWipe as nu, secureWipeAll as nv, selectOptimalConfig as nw, sendPrivateSPLTransfer as nx, serializeAttestationMessage as ny, serializeIntent as nz, type ApproveResult as o, validateAsset as o0, validateCreateIntentParams as o1, validateIntentInput as o2, validateIntentOutput as o3, validateNEARStealthAddress as o4, validateNEARStealthMetaAddress as o5, validateNEARViewingKey as o6, validateProductionConfig as o7, validateScalar as o8, validateViewingKey as o9, verifyAttestation as oa, verifyAttestationSignature as ob, verifyAuthToken as oc, verifyCommitment as od, verifyNEP141TokenCommitment as oe, verifyOpening as of, verifyOpeningNEAR as og, verifyOracleSignature as oh, verifyOwnership as oi, verifyWebhookSignature as oj, walletRegistry as ok, withSecureBuffer as ol, withSecureBufferSync as om, wrapError as on, 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 };