@permissionless-technologies/upp-sdk 0.1.0

package/dist/transfer-BlmbO-Rd.d.ts

@@ -0,0 +1,1270 @@
+import { Address, Hex, PublicClient } from 'viem';
+import { d as buildMerkleTree, a as MerkleProof } from './merkle-mteVOlDf.js';
+import { a as M31Digest } from './keccak-m31-B_AqBbRF.js';
+import * as _permissionless_technologies_upc_sdk from '@permissionless-technologies/upc-sdk';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { M as MasterKeys, b as StarkMasterKeys } from './types-mLybMxNR.js';
+
+/**
+ * Core type definitions for UPP SDK
+ */
+
+/**
+ * Note version - increment when note structure changes
+ */
+declare const NOTE_VERSION = 5;
+/**
+ * A private note in the Universal Private Pool
+ */
+interface Note {
+    /** Note format version */
+    version: number;
+    /** Token amount (in wei) */
+    amount: bigint;
+    /** Random blinding factor */
+    blinding: bigint;
+    /** Current origin - who is responsible for these funds (updated on merge) */
+    origin: Address;
+    /** Sender - who sent this specific note (for payment attribution) */
+    sender: Address;
+    /** ERC20 token address */
+    token: Address;
+    /** Optional memo/message */
+    memo?: string;
+    /** Timestamp when note was created */
+    timestamp?: number;
+}
+/**
+ * Encrypted note data stored on-chain (post-quantum, hash-based)
+ */
+interface EncryptedNote {
+    /** AES-GCM encrypted note data */
+    ciphertext: Hex;
+    /** AES-GCM nonce */
+    nonce: Hex;
+}
+/**
+ * Stealth meta-address (hash-based, post-quantum)
+ * Published once, used by senders to encrypt notes to the recipient
+ */
+interface StealthMetaAddress {
+    /** Owner hash = Poseidon(spendingSecret) */
+    ownerHash: bigint;
+    /** Viewing hash = Poseidon(viewingSecret) */
+    viewingHash: bigint;
+}
+/**
+ * One-time address for a specific transaction (simplified for hash-based system)
+ */
+interface StealthAddress {
+    /** Owner hash for this note */
+    ownerHash: bigint;
+    /** Search tag for efficient scanning */
+    searchTag?: bigint;
+}
+/**
+ * On-chain merge record for audit trail
+ */
+interface MergeRecord {
+    /** Output commitment (the merged note) */
+    outputCommitment: Hex;
+    /** First input nullifier */
+    nullifier1: Hex;
+    /** Second input nullifier */
+    nullifier2: Hex;
+    /** Who performed the merge (new origin) */
+    merger: Address;
+    /** Token that was merged */
+    token: Address;
+    /** Block timestamp */
+    timestamp: number;
+}
+/**
+ * ASP (Association Set Provider) root
+ */
+interface ASPRoot {
+    /** Merkle root of approved addresses */
+    root: bigint;
+    /** IPFS hash for off-chain data */
+    ipfsHash: Hex;
+    /** When this root was published */
+    timestamp: number;
+    /** Number of addresses in the set */
+    leafCount: number;
+}
+/**
+ * Shield operation parameters
+ */
+interface ShieldParams {
+    /** ERC20 token to shield */
+    token: Address;
+    /** Amount to shield (in wei) */
+    amount: bigint;
+    /** Optional: recipient owner hash (defaults to self) */
+    recipientOwnerHash?: bigint;
+    /** Optional: memo to include in note */
+    memo?: string;
+}
+/**
+ * Transfer operation parameters
+ */
+interface TransferParams {
+    /** Note to spend */
+    note: Note;
+    /** Recipient stealth address */
+    recipient: StealthAddress;
+    /** Amount to send (remainder goes back to sender as change) */
+    amount: bigint;
+    /** Optional: memo to include */
+    memo?: string;
+}
+/**
+ * Merge operation parameters
+ */
+interface MergeParams {
+    /** Notes to merge (must be same token) */
+    notes: [Note, Note];
+    /** Optional: memo for the merged note */
+    memo?: string;
+}
+/**
+ * Withdraw operation parameters
+ */
+interface WithdrawParams {
+    /** Note to withdraw */
+    note: Note;
+    /** Amount to withdraw */
+    amount: bigint;
+    /** Recipient address for the tokens */
+    recipient: Address;
+    /** ASP ID to use for compliance check */
+    aspId?: number;
+    /** Use ragequit (origin withdrawing own funds) */
+    ragequit?: boolean;
+}
+/**
+ * Proof for ZK operations
+ */
+interface Proof {
+    /** Proof points */
+    proof: {
+        pi_a: [string, string];
+        pi_b: [[string, string], [string, string]];
+        pi_c: [string, string];
+    };
+    /** Public signals */
+    publicSignals: string[];
+}
+/**
+ * Note commitment (hash)
+ */
+type Commitment = Hex;
+/**
+ * Nullifier (spent note identifier)
+ */
+type Nullifier = Hex;
+
+/** STARK amount scaling: 1e15 wei per STARK unit (matches contract) */
+declare const STARK_AMOUNT_SCALE: bigint;
+/**
+ * A private STARK note in the Universal Private Pool.
+ *
+ * All field values are M31 elements (< 2^31 - 1).
+ * Commitment = keccak_m31(amount, ownerHash[0..4], blinding, origin, token).
+ */
+interface StarkNote {
+    /** Amount in STARK units (actual wei = amount * STARK_AMOUNT_SCALE) */
+    amount: bigint;
+    /** Owner hash = keccak_m31(starkSecret) — 4 M31 elements */
+    ownerHash: M31Digest;
+    /** Random blinding factor (M31) */
+    blinding: bigint;
+    /** Origin address encoded as M31 (lower 31 bits of address) */
+    origin: bigint;
+    /** Token address encoded as M31 (lower 31 bits of address) */
+    token: bigint;
+    /** The leaf index in the STARK Keccak Merkle tree (set after shielding) */
+    leafIndex?: number;
+    /** The commitment digest (set after computation) */
+    commitment?: M31Digest;
+    /** Optional memo */
+    memo?: string;
+    /** Timestamp when note was created */
+    timestamp?: number;
+}
+/**
+ * STARK stealth meta-address (M31/Keccak-based)
+ * Published once, used by senders to encrypt notes to the recipient
+ */
+interface StarkStealthMetaAddress {
+    /** Owner hash = keccak_m31(starkSecret) — 4 M31 elements */
+    ownerHash: M31Digest;
+    /** Viewing hash = keccak_m31(starkViewingSecret) — 4 M31 elements */
+    viewingHash: M31Digest;
+}
+/**
+ * STARK proof for ZK operations (serialized Circle STARK proof)
+ */
+interface StarkProof {
+    /** Raw serialized Stwo Circle STARK proof bytes */
+    proofBytes: Hex;
+    /** Public inputs seed (keccak256 of public parameters) */
+    publicInputsSeed: Hex;
+}
+
+/**
+ * ZK Proof Generation and Verification
+ *
+ * Uses snarkjs for Groth16 proof generation in the browser.
+ */
+
+/** State tree depth (32 levels = ~4B notes) */
+declare const STATE_TREE_DEPTH = 32;
+/** ASP tree depth (20 levels = ~1M addresses) */
+declare const ASP_TREE_DEPTH$1 = 20;
+/**
+ * Circuit types available in UPP (full protocol)
+ */
+type UPPCircuitType = 'transfer' | 'merge' | 'withdraw' | 'joinsplit' | 'merge_transfer_2x2' | 'merge_transfer_4x2';
+/**
+ * @deprecated Use UPPCircuitType instead
+ */
+type CircuitType = 'shield' | 'transfer' | 'merge' | 'withdraw';
+/**
+ * @deprecated Stealth circuits are being replaced by UPP circuits
+ */
+type StealthCircuitType = '1x2' | '2x2';
+/**
+ * Input signals for UPP transfer circuit (1-in-2-out)
+ *
+ * Matches transfer.circom: Transfer(32, 20)
+ * Public: stateRoot, aspRoot, nullifier, outputCommitment1, outputCommitment2, token
+ */
+interface UPPTransferCircuitInputs {
+    stateRoot: string;
+    aspRoot: string;
+    nullifier: string;
+    outputCommitment1: string;
+    outputCommitment2: string;
+    token: string;
+    inputAmount: string;
+    inputOneTimeSecret: string;
+    inputBlinding: string;
+    inputOrigin: string;
+    inputLeafIndex: string;
+    inputPathElements: string[];
+    inputPathIndices: string[];
+    aspPathElements: string[];
+    aspPathIndices: string[];
+    outputAmount1: string;
+    outputPubkeyX1: string;
+    outputPubkeyY1: string;
+    outputBlinding1: string;
+    outputAmount2: string;
+    outputPubkeyX2: string;
+    outputPubkeyY2: string;
+    outputBlinding2: string;
+}
+/**
+ * Input signals for UPP withdraw circuit
+ *
+ * Matches withdraw.circom with optional ASP check (ragequit support)
+ */
+interface UPPWithdrawCircuitInputs {
+    stateRoot: string;
+    aspRoot: string;
+    nullifier: string;
+    amount: string;
+    recipient: string;
+    token: string;
+    isRagequit: string;
+    inputAmount: string;
+    inputOneTimeSecret: string;
+    inputBlinding: string;
+    inputOrigin: string;
+    inputLeafIndex: string;
+    inputPathElements: string[];
+    inputPathIndices: string[];
+    aspPathElements: string[];
+    aspPathIndices: string[];
+}
+/**
+ * @deprecated Use UPPTransferCircuitInputs instead
+ */
+interface TransferCircuitInputs {
+    stateRoot: bigint;
+    aspRoot: bigint;
+    nullifier: bigint;
+    outputCommitment1: bigint;
+    outputCommitment2: bigint;
+    token: bigint;
+    amount: bigint;
+    blinding: bigint;
+    origin: bigint;
+    statePathElements: bigint[];
+    statePathIndices: bigint;
+    aspPathElements: bigint[];
+    outAmount1: bigint;
+    outBlinding1: bigint;
+    outOrigin1: bigint;
+    outAmount2: bigint;
+    outBlinding2: bigint;
+    outOrigin2: bigint;
+}
+/**
+ * Input signals for shield circuit
+ */
+interface ShieldCircuitInputs {
+    commitment: bigint;
+    token: bigint;
+    amount: bigint;
+    blinding: bigint;
+    origin: bigint;
+}
+/**
+ * Input signals for merge circuit
+ */
+interface MergeCircuitInputs {
+    stateRoot: bigint;
+    nullifier1: bigint;
+    nullifier2: bigint;
+    outputCommitment: bigint;
+    newOrigin: bigint;
+    token: bigint;
+    amount1: bigint;
+    blinding1: bigint;
+    origin1: bigint;
+    token1: bigint;
+    pathElements1: bigint[];
+    pathIndices1: bigint;
+    amount2: bigint;
+    blinding2: bigint;
+    origin2: bigint;
+    token2: bigint;
+    pathElements2: bigint[];
+    pathIndices2: bigint;
+    outputAmount: bigint;
+    outputBlinding: bigint;
+}
+/**
+ * Input signals for withdraw circuit
+ */
+interface WithdrawCircuitInputs {
+    stateRoot: bigint;
+    aspRoot: bigint;
+    nullifier: bigint;
+    withdrawAmount: bigint;
+    recipient: bigint;
+    token: bigint;
+    isRagequit: bigint;
+    amount: bigint;
+    blinding: bigint;
+    origin: bigint;
+    statePathElements: bigint[];
+    statePathIndices: bigint;
+    aspPathElements: bigint[];
+}
+/**
+ * Circuit inputs union type
+ */
+type CircuitInputs = ShieldCircuitInputs | TransferCircuitInputs | MergeCircuitInputs | WithdrawCircuitInputs;
+/**
+ * Circuit input for 1x2 stealth transfer (1-in-2-out)
+ */
+interface Stealth1x2CircuitInputs {
+    root: string;
+    nullifierHash: string;
+    publicAmount: string;
+    recipient: string;
+    extDataHash: string;
+    inputAmount: string;
+    inputOneTimeSecret: string;
+    inputBlinding: string;
+    inputLeafIndex: string;
+    inputPathElements: string[];
+    inputPathIndices: string[];
+    outputAmount1: string;
+    outputPubkeyX1: string;
+    outputPubkeyY1: string;
+    outputBlinding1: string;
+    outputAmount2: string;
+    outputPubkeyX2: string;
+    outputPubkeyY2: string;
+    outputBlinding2: string;
+}
+/**
+ * Circuit input for 2x2 stealth transfer (2-in-2-out)
+ */
+interface Stealth2x2CircuitInputs {
+    root: string;
+    nullifierHash1: string;
+    nullifierHash2: string;
+    publicAmount: string;
+    recipient: string;
+    extDataHash: string;
+    inputAmount1: string;
+    inputOneTimeSecret1: string;
+    inputBlinding1: string;
+    inputLeafIndex1: string;
+    inputPathElements1: string[];
+    inputPathIndices1: string[];
+    inputAmount2: string;
+    inputOneTimeSecret2: string;
+    inputBlinding2: string;
+    inputLeafIndex2: string;
+    inputPathElements2: string[];
+    inputPathIndices2: string[];
+    outputAmount1: string;
+    outputPubkeyX1: string;
+    outputPubkeyY1: string;
+    outputBlinding1: string;
+    outputAmount2: string;
+    outputPubkeyX2: string;
+    outputPubkeyY2: string;
+    outputBlinding2: string;
+}
+/**
+ * Stealth circuit inputs union
+ */
+type StealthCircuitInputs = Stealth1x2CircuitInputs | Stealth2x2CircuitInputs;
+/**
+ * Circuit artifact paths
+ */
+interface CircuitArtifacts {
+    wasm: string;
+    zkey: string;
+}
+/**
+ * Get circuit artifacts for a UPP circuit
+ *
+ * @param circuit - UPP circuit type
+ * @param baseUrl - Base URL for circuit files (default: '/circuits/')
+ */
+declare function getUPPCircuitArtifacts(circuit: UPPCircuitType, baseUrl?: string): CircuitArtifacts;
+/**
+ * @deprecated Use getUPPCircuitArtifacts instead
+ * Get circuit artifacts for a stealth circuit
+ *
+ * @param circuit - Circuit type ('1x2' or '2x2')
+ * @param baseUrl - Base URL for circuit files (default: '/circuits/')
+ */
+declare function getStealthCircuitArtifacts(circuit: StealthCircuitType, baseUrl?: string): CircuitArtifacts;
+/**
+ * UPP circuit inputs union type
+ */
+type UPPCircuitInputs = UPPTransferCircuitInputs | UPPWithdrawCircuitInputs;
+/**
+ * Generate a ZK proof for a UPP circuit
+ *
+ * @param circuitType - Which UPP circuit to use
+ * @param inputs - Circuit input signals
+ * @param baseUrl - Base URL for circuit artifacts (default: '/circuits/')
+ * @returns Generated proof and public signals
+ *
+ * @example
+ * ```ts
+ * const { proof, publicSignals } = await generateUPPProof('transfer', {
+ *   stateRoot: String(currentRoot),
+ *   aspRoot: String(aspRoot),
+ *   // ... other inputs
+ * })
+ * ```
+ */
+declare function generateUPPProof(circuitType: UPPCircuitType, inputs: UPPCircuitInputs, baseUrl?: string): Promise<ProofResult>;
+/**
+ * @deprecated Use generateUPPProof instead
+ * Generate a ZK proof for a circuit (UPP protocol circuits)
+ */
+declare function generateProof(_circuitType: CircuitType, _inputs: CircuitInputs): Promise<Proof>;
+/**
+ * Result from proof generation
+ */
+interface ProofResult {
+    proof: Proof;
+    publicSignals: string[];
+}
+/**
+ * Generate a ZK proof for stealth circuit (1x2 or 2x2)
+ *
+ * @param circuit - Circuit type ('1x2' or '2x2')
+ * @param inputs - Circuit input signals
+ * @param baseUrl - Base URL for circuit artifacts (default: '/circuits/')
+ * @returns Generated proof and public signals
+ *
+ * @example
+ * ```ts
+ * const { proof, publicSignals } = await generateStealthProof('1x2', {
+ *   root: String(merkleRoot),
+ *   nullifierHash: String(nullifier),
+ *   // ... other inputs
+ * })
+ * ```
+ */
+declare function generateStealthProof(circuit: StealthCircuitType, inputs: StealthCircuitInputs, baseUrl?: string): Promise<ProofResult>;
+/**
+ * Verify a ZK proof
+ *
+ * @param circuitType - Which circuit was used
+ * @param proof - The proof to verify
+ * @returns True if proof is valid
+ */
+declare function verifyProof(_circuitType: CircuitType, _proof: Proof): Promise<boolean>;
+/**
+ * Format proof for on-chain verification
+ *
+ * Converts snarkjs proof format to Solidity verifier format
+ */
+declare function formatProofForContract(proof: Proof): {
+    a: [bigint, bigint];
+    b: [[bigint, bigint], [bigint, bigint]];
+    c: [bigint, bigint];
+};
+
+/**
+ * Swap Module
+ *
+ * Core logic for building and interacting with the UPP in-pool swap order book.
+ * Framework-agnostic (no React). Reuses withdraw verifier for proofs.
+ */
+
+/**
+ * Swap order as stored on-chain
+ */
+interface SwapOrder {
+    /** Order ID (= maker's nullifier) */
+    orderId: Hex;
+    /** Token being sold */
+    sellToken: Address;
+    /** Original total sell amount */
+    sellAmount: bigint;
+    /** Remaining sell amount (decremented on each fill) */
+    remainingSellAmount: bigint;
+    /** Token the maker wants to receive */
+    buyToken: Address;
+    /** Price: buyToken per sellToken (1e18 fixed-point) */
+    rate: bigint;
+    /** Accumulated buy token amount from fills */
+    accumulatedBuyAmount: bigint;
+    /** Maker's ASP ID (public, filterable by takers) */
+    makerAspId: bigint;
+    /** Required filler ASP (0 = any) */
+    requiredFillerAspId: bigint;
+    /** Block number after which order expires */
+    expiry: bigint;
+    /** Whether the maker has claimed */
+    claimed: boolean;
+    /** Whether the order was cancelled */
+    cancelled: boolean;
+}
+/**
+ * Parameters to place a swap order
+ */
+interface SwapOrderParams {
+    /** Token to sell */
+    sellToken: Address;
+    /** Amount to sell */
+    sellAmount: bigint;
+    /** Token to buy */
+    buyToken: Address;
+    /** Price: buyToken per sellToken (1e18 fixed-point) */
+    rate: bigint;
+    /** Required filler ASP (0n = accept any) */
+    requiredFillerAspId?: bigint;
+    /** Number of blocks until expiry (from current block) */
+    expiryBlocks: bigint;
+}
+/**
+ * Parameters to fill a swap order
+ */
+interface SwapFillParams {
+    /** The order to fill */
+    orderId: Hex;
+    /** How much sellToken the filler wants (≤ remaining) */
+    takeAmount: bigint;
+}
+/**
+ * Swap order from event log
+ */
+interface SwapOrderEvent {
+    orderId: Hex;
+    sellToken: Address;
+    buyToken: Address;
+    sellAmount: bigint;
+    rate: bigint;
+    makerAspId: bigint;
+    requiredFillerAspId: bigint;
+    expiry: bigint;
+    blockNumber: bigint;
+    /** On-chain remaining sell amount (populated by useSwapOrderBook) */
+    remainingSellAmount?: bigint;
+    /** Whether the order has been claimed */
+    claimed?: boolean;
+    /** Whether the order has been cancelled */
+    cancelled?: boolean;
+}
+/**
+ * Swap fill from event log
+ */
+interface SwapFillEvent {
+    orderId: Hex;
+    fillerNullifier: Hex;
+    takeAmount: bigint;
+    giveAmount: bigint;
+    fillerAspId: bigint;
+    blockNumber: bigint;
+}
+/** 1e18 fixed-point precision for swap rates */
+declare const RATE_PRECISION: bigint;
+declare const SWAP_ORDER_PLACED_EVENT: {
+    readonly type: "event";
+    readonly name: "SwapOrderPlaced";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "sellToken";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "buyToken";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "sellAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "rate";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "makerAspId";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "requiredFillerAspId";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+};
+declare const SWAP_ORDER_FILLED_EVENT: {
+    readonly type: "event";
+    readonly name: "SwapOrderFilled";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "fillerNullifier";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "takeAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "giveAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "fillerAspId";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+};
+declare const SWAP_ORDER_CLAIMED_EVENT: {
+    readonly type: "event";
+    readonly name: "SwapOrderClaimed";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "accumulatedBuyAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "refundedSellAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+};
+declare const SWAP_ORDER_CANCELLED_EVENT: {
+    readonly type: "event";
+    readonly name: "SwapOrderCancelled";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "refundedSellAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+};
+declare const SWAP_EVENTS_ABI: readonly [{
+    readonly type: "event";
+    readonly name: "SwapOrderPlaced";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "sellToken";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "buyToken";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "sellAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "rate";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "makerAspId";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "requiredFillerAspId";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "expiry";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "SwapOrderFilled";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "fillerNullifier";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "takeAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "giveAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "fillerAspId";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "SwapOrderClaimed";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "accumulatedBuyAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "refundedSellAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "SwapOrderCancelled";
+    readonly inputs: readonly [{
+        readonly name: "orderId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "refundedSellAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}];
+/**
+ * Compute the giveAmount (buyToken) for a given takeAmount (sellToken) at a rate.
+ * giveAmount = (takeAmount * rate) / 1e18
+ */
+declare function computeGiveAmount(takeAmount: bigint, rate: bigint): bigint;
+/**
+ * Compute the maximum takeAmount for a given giveAmount and rate.
+ * takeAmount = (giveAmount * 1e18) / rate
+ */
+declare function computeTakeAmount(giveAmount: bigint, rate: bigint): bigint;
+/**
+ * Compute rate from a desired trade: I want `buyAmount` of buyToken for `sellAmount` of sellToken.
+ * rate = (buyAmount * 1e18) / sellAmount
+ */
+declare function computeRate(sellAmount: bigint, buyAmount: bigint): bigint;
+/**
+ * Format a rate for human display.
+ * Returns a string like "0.0005" for rate = 500000000000000n (0.0005e18)
+ */
+declare function formatRate(rate: bigint, decimals?: number): string;
+/**
+ * Generate a cancel key hash from a secret.
+ * The secret should be a random 32-byte value stored by the maker.
+ */
+declare function computeCancelKeyHash(cancelSecret: Hex): Hex;
+/**
+ * Generate a random cancel secret.
+ */
+declare function generateCancelSecret(): Hex;
+/**
+ * Filter orders by ASP: only show orders from makers on acceptable ASPs.
+ */
+declare function filterOrdersByASP(orders: SwapOrderEvent[], acceptableAspIds: bigint[]): SwapOrderEvent[];
+/**
+ * Filter orders by token pair.
+ */
+declare function filterOrdersByTokenPair(orders: SwapOrderEvent[], sellToken: Address, buyToken: Address): SwapOrderEvent[];
+/**
+ * Check if a filler's ASP is accepted by an order.
+ */
+declare function isFillerASPAccepted(order: SwapOrder | SwapOrderEvent, fillerAspId: bigint): boolean;
+/**
+ * Store a cancel secret in localStorage, scoped by wallet address.
+ * Must be called after placing a swap order.
+ */
+declare function storeCancelSecret(orderId: Hex, cancelSecret: Hex, account?: string): void;
+/**
+ * Retrieve a cancel secret from localStorage.
+ * Returns null if not found (e.g. order was placed by someone else).
+ */
+declare function getCancelSecret(orderId: Hex, account?: string): Hex | null;
+/**
+ * Remove a cancel secret from localStorage (after claim or cancel).
+ */
+declare function removeCancelSecret(orderId: Hex, account?: string): void;
+/**
+ * Get all order IDs for a specific wallet address.
+ * Falls back to all cancel secrets if no account provided (backward compat).
+ */
+declare function getOwnOrderIds(account?: string): Hex[];
+/**
+ * Check if an order is still active (not claimed, not cancelled, not expired).
+ */
+declare function isOrderActive(order: SwapOrder, currentBlock: bigint): boolean;
+/**
+ * Compute the total buyToken amount the maker would receive for a full fill.
+ */
+declare function computeTotalBuyAmount(sellAmount: bigint, rate: bigint): bigint;
+/**
+ * Compute fill percentage (0-100) for display.
+ */
+declare function computeFillPercentage(order: SwapOrder): number;
+
+/**
+ * ASP (Association Set Provider) Utilities
+ *
+ * Thin wrapper around @permissionless-technologies/upc-sdk.
+ * Provides pool-specific types (ASPProof with aspId) while delegating
+ * Merkle tree operations to the compliance SDK.
+ *
+ * In UPP, every transfer must prove the origin is in an approved ASP's allowlist.
+ */
+declare const ASP_TREE_DEPTH = 20;
+/**
+ * ASP Merkle proof structure (pool-specific: includes aspId)
+ */
+interface ASPProof {
+    /** ASP ID */
+    aspId: bigint;
+    /** ASP's published root */
+    aspRoot: bigint;
+    /** Path elements (siblings) - 20 levels */
+    aspPathElements: bigint[];
+    /** Path indices - 20 levels */
+    aspPathIndices: number[];
+}
+/**
+ * Compute the ASP root for a single-leaf tree
+ */
+declare function computeSingleOriginASPRoot(origin: bigint): Promise<bigint>;
+/**
+ * Generate ASP proof for a single-origin tree
+ */
+declare function generateSingleOriginASPProof(aspId: bigint, origin: bigint): Promise<ASPProof>;
+/**
+ * Verify an ASP proof locally (for debugging)
+ */
+declare function verifyASPProof(origin: bigint, proof: ASPProof): Promise<boolean>;
+/**
+ * Demo ASP configuration
+ */
+declare const DEMO_ASP_ID = 1n;
+declare const DEMO_ASP_NAME = "Demo ASP (Single-Origin)";
+/**
+ * Create a "universal approval" ASP root
+ */
+declare function createDemoASPRoot(origin: bigint): Promise<bigint>;
+/**
+ * Build an ASP Merkle tree from multiple origin addresses
+ */
+declare function buildASPTree(origins: bigint[]): _permissionless_technologies_upc_sdk.MerkleTree;
+/**
+ * Compute the Merkle root for a set of approved origins
+ */
+declare function computeMultiOriginASPRoot(origins: bigint[]): Promise<bigint>;
+/**
+ * Generate an ASP membership proof for one origin within a multi-origin tree
+ */
+declare function generateMultiOriginASPProof(aspId: bigint, origin: bigint, allOrigins: bigint[]): Promise<ASPProof>;
+/**
+ * Generate an ASP proof, automatically choosing single-origin or multi-origin
+ */
+declare function generateASPProof(aspId: bigint, origin: bigint, approvedOrigins?: bigint[]): Promise<ASPProof>;
+
+/** Which proof system created/guards a note */
+type ProofSystemType = 'snark' | 'stark';
+/**
+ * A shielded note (UTXO) - Post-quantum hash-based
+ *
+ * Commitment = Poseidon(amount, ownerHash, blinding, origin, token)
+ * where ownerHash = Poseidon(spendingSecret)
+ */
+interface ShieldedNote {
+    /** Amount of tokens */
+    amount: bigint;
+    /** Random blinding factor */
+    blinding: bigint;
+    /** Commitment hash (hex) */
+    commitment: string;
+    /** Spending secret for this note (hex) - proves ownership via hash preimage */
+    ownerSecret: string;
+    /** Owner hash = Poseidon(ownerSecret) - what's committed on-chain (hex) */
+    ownerHash: string;
+    /** Position in Merkle tree */
+    leafIndex: number;
+    /** Origin address (original depositor) as hex */
+    origin: string;
+    /** Token address as hex */
+    token: string;
+    /** Transaction hash */
+    txHash?: string;
+    /** Note status */
+    status: 'pending' | 'confirmed' | 'spent';
+    /** Timestamp */
+    timestamp: number;
+    /** Which proof system created this note (defaults to 'snark' for legacy notes) */
+    proofSystem?: ProofSystemType;
+}
+/**
+ * Note creation result
+ *
+ * Commitment = Poseidon(amount, pubkeyX, pubkeyY, blinding, origin, token)
+ * where (pubkeyX, pubkeyY) = BabyJubJub(ownerSecret)
+ */
+interface NoteCreationResult {
+    commitment: bigint;
+    /** The secret whose hash is in the commitment (BabyJubJub private key) */
+    ownerSecret: bigint;
+    /** Poseidon(ownerSecret) - used for search/display */
+    ownerHash: bigint;
+    /** BabyJubJub public key X coordinate - used in note commitment */
+    pubkeyX: bigint;
+    /** BabyJubJub public key Y coordinate - used in note commitment */
+    pubkeyY: bigint;
+    blinding: bigint;
+    encryptedNote: string;
+    searchTag: bigint;
+    amount: bigint;
+    origin: bigint;
+    token: bigint;
+}
+/**
+ * Indexer configuration for advanced usage
+ */
+interface IndexerConfig {
+    /** Enable IndexedDB storage (default: true if available) */
+    useIndexedDB?: boolean;
+    /** Custom storage prefix for multi-account support */
+    storagePrefix?: string;
+    /** Batch size for RPC scanning (default: 200, adapts on rate limits) */
+    batchSize?: number;
+    /** Sync interval for live sync in ms (default: 30000) */
+    liveSyncIntervalMs?: number;
+    /** Starting block for new accounts (skips blocks before account creation) */
+    fromBlock?: number;
+    /** Pool contract address (required for indexer) */
+    contractAddress?: Address;
+}
+/**
+ * Context type for UPP Account
+ */
+interface UPPAccountContextType {
+    /** SNARK master keys (null if not setup) */
+    masterKeys: MasterKeys | null;
+    /** STARK master keys (null if not setup) */
+    starkMasterKeys: StarkMasterKeys | null;
+    /** Connected wallet address */
+    ethAddress: string | null;
+    /** Owner hash (public identifier, hex) — SNARK */
+    ownerHash: string | null;
+    /** Stealth address (bech32m encoded, 0zk prefix) — SNARK */
+    stealthAddress: string | null;
+    /** STARK stealth address (bech32m encoded, 0zs prefix) */
+    starkStealthAddress: string | null;
+    /** All notes */
+    notes: ShieldedNote[];
+    /** Unspent notes */
+    unspentNotes: ShieldedNote[];
+    /** Total balance of unspent notes */
+    balance: bigint;
+    /** Whether account is set up */
+    isSetup: boolean;
+    /** Whether SDK is loading/initializing */
+    isLoading: boolean;
+    /** Whether crypto is ready */
+    cryptoReady: boolean;
+    /** Whether sync is in progress */
+    isSyncing: boolean;
+    /** Last synced block number */
+    lastSyncedBlock: number;
+    /** Set up a new account from wallet signature (low-level) */
+    setupAccount: (signature: Hex) => Promise<void>;
+    /** Connect private account via EIP-712 wallet signature (requires wagmi signTypedData) */
+    connect: (password?: string) => Promise<void>;
+    /** Whether a connect operation is in progress */
+    isConnecting: boolean;
+    /** Clear account and logout */
+    logout: () => void;
+    /** Alias for logout */
+    disconnect: () => void;
+    /** Add a note to the account */
+    addNote: (note: ShieldedNote) => void;
+    /** Mark a note as spent */
+    markNoteSpent: (commitment: string) => void;
+    /** Create note for self (e.g., shield or change output) */
+    createNoteForSelf: (amount: bigint, origin: bigint, token: bigint) => Promise<NoteCreationResult>;
+    /** Get owner hash */
+    getOwnerHash: () => bigint | null;
+    /** Select optimal circuit for a given amount */
+    selectOptimalCircuit: (requiredAmount: bigint, tokenAddress?: string) => {
+        circuit: '1x2' | '2x2' | null;
+        selectedNotes: ShieldedNote[];
+        error?: string;
+    };
+    /** Sync notes from blockchain (requires client to be passed in) */
+    syncNotes: (contractAddress: Address, client: any) => Promise<number>;
+    /** Start live sync (polls for new notes at interval) */
+    startLiveSync: (contractAddress: Address, client: any) => void;
+    /** Stop live sync */
+    stopLiveSync: () => void;
+    /** Whether live sync is active */
+    isLiveSyncing: boolean;
+}
+/**
+ * Function signature for EIP-712 typed data signing.
+ * Compatible with wagmi's signTypedDataAsync.
+ */
+type SignTypedDataFn = (args: {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+    };
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}) => Promise<Hex>;
+interface UPPAccountProviderProps {
+    children: ReactNode;
+    /** Ethereum address of connected wallet */
+    ethAddress?: string;
+    /** Chain ID */
+    chainId?: number;
+    /** Indexer configuration */
+    indexerConfig?: IndexerConfig;
+    /** EIP-712 signing function (from wagmi's useSignTypedData().signTypedDataAsync) */
+    signTypedData?: SignTypedDataFn;
+    /** Public client for chain fingerprint validation (e.g. from wagmi usePublicClient) */
+    publicClient?: any;
+    /** Active proof system — filters unspentNotes and balance to only show spendable notes */
+    activeProofSystem?: ProofSystemType;
+}
+declare function UPPAccountProvider({ children, ethAddress, chainId, indexerConfig, signTypedData, publicClient: publicClientProp, activeProofSystem, }: UPPAccountProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access UPP Account context
+ */
+declare function useUPPAccount(): UPPAccountContextType;
+
+/**
+ * Transfer Module
+ *
+ * Core logic for building and executing UPP transfers.
+ * This module is framework-agnostic (no React).
+ */
+
+/**
+ * Transfer stage for progress tracking
+ */
+type TransferStage = 'selecting_notes' | 'syncing_merkle' | 'creating_outputs' | 'generating_proof' | 'submitting_tx' | 'confirming';
+/**
+ * A shielded note with all data needed for spending
+ *
+ * Post-quantum: uses ownerSecret/ownerHash instead of BabyJubJub one-time keys.
+ * Ownership is proven via hash preimage: Poseidon(ownerSecret) == ownerHash.
+ */
+interface SpendableNote {
+    amount: bigint;
+    blinding: bigint;
+    commitment: string;
+    /** Owner secret (hash preimage for ownership proof) */
+    ownerSecret: string;
+    /** Owner hash = Poseidon(ownerSecret) - committed in the note */
+    ownerHash: string;
+    leafIndex: number;
+    /** Origin address (depositor) - required for UPP circuits */
+    origin: bigint;
+    /** Token address - required for UPP circuits */
+    token: bigint;
+}
+/**
+ * Merkle proof with associated note
+ */
+interface MerkleProofWithNote {
+    proof: MerkleProof;
+    note: SpendableNote;
+}
+/**
+ * Transfer context (dependencies)
+ */
+interface TransferContext {
+    /** viem PublicClient for RPC calls */
+    publicClient: PublicClient;
+    /** Contract address */
+    contractAddress: Address;
+    /** Chain ID */
+    chainId: number;
+    /** Circuit base URL (default: '/circuits/') */
+    circuitBaseUrl?: string;
+    /** ASP ID to use (default: DEMO_ASP_ID) */
+    aspId?: bigint;
+    /** All approved origins in the ASP tree (enables multi-origin proofs) */
+    aspApprovedOrigins?: bigint[];
+}
+/**
+ * Transfer result
+ */
+interface TransferBuildResult {
+    /** Circuit type used */
+    circuit: UPPCircuitType;
+    /** Formatted proof for contract */
+    proof: {
+        a: [bigint, bigint];
+        b: [[bigint, bigint], [bigint, bigint]];
+        c: [bigint, bigint];
+    };
+    /** Public signals from proof */
+    publicSignals: string[];
+    /** State tree root */
+    stateRoot: bigint;
+    /** ASP tree root */
+    aspRoot: bigint;
+    /** Nullifier hash */
+    nullifier: bigint;
+    /** Output commitment 1 */
+    outputCommitment1: bigint;
+    /** Output commitment 2 */
+    outputCommitment2: bigint;
+    /** Token address */
+    token: bigint;
+    /** Recipient output */
+    recipientOutput: NoteCreationResult;
+    /** Change output */
+    changeOutput: NoteCreationResult;
+    /** Notes that will be spent */
+    spentNotes: SpendableNote[];
+}
+/**
+ * Fetch all commitments from the contract and build a Merkle tree
+ *
+ * @param publicClient - viem PublicClient
+ * @param contractAddress - Contract address
+ * @returns Object with tree and leaves array
+ */
+declare function syncMerkleTree(publicClient: PublicClient, contractAddress: Address): Promise<{
+    tree: ReturnType<typeof buildMerkleTree>;
+    leaves: bigint[];
+}>;
+/**
+ * Get Merkle proofs for a set of notes
+ *
+ * @param notes - Notes to get proofs for
+ * @param leaves - All leaves in the tree
+ * @param tree - Merkle tree instance
+ * @returns Array of proofs with associated notes
+ */
+declare function getMerkleProofsForNotes(notes: SpendableNote[], leaves: bigint[], tree: ReturnType<typeof buildMerkleTree>): Promise<MerkleProofWithNote[]>;
+/**
+ * Compute nullifier for a UPP note
+ *
+ * Post-quantum nullifier: Poseidon(ownerSecret, leafIndex, commitment)
+ *
+ * @param ownerSecret - Owner secret (hash preimage)
+ * @param leafIndex - Leaf index in Merkle tree
+ * @param commitment - Note commitment
+ * @returns Nullifier as bigint
+ */
+declare function computeNullifier(ownerSecret: bigint, leafIndex: number, commitment: bigint): Promise<bigint>;
+/**
+ * Note with amount for circuit building
+ */
+interface NoteWithAmount extends NoteCreationResult {
+    amount: bigint;
+}
+/**
+ * Build circuit inputs for UPP transfer (1-in-2-out)
+ *
+ * @param noteProof - Merkle proof for input note
+ * @param aspProof - ASP membership proof for input note's origin
+ * @param recipientNote - Output note for recipient
+ * @param changeNote - Output note for change
+ * @returns UPP transfer circuit inputs
+ */
+declare function buildUPPTransferCircuitInputs(noteProof: MerkleProofWithNote, aspProof: ASPProof, recipientNote: NoteWithAmount, changeNote: NoteWithAmount): Promise<UPPTransferCircuitInputs>;
+/**
+ * Build a UPP transfer (proof + outputs)
+ *
+ * This prepares everything needed to submit the transaction.
+ * UPP transfer is 1-in-2-out with ASP membership proof.
+ *
+ * @param ctx - Transfer context
+ * @param selectedNote - Note to spend (UPP transfer uses exactly 1 input)
+ * @param recipientNote - Output note for recipient
+ * @param changeNote - Output note for change
+ * @param onStageChange - Optional callback for stage updates
+ * @returns Transfer build result with proof and outputs
+ */
+declare function buildTransfer(ctx: TransferContext, selectedNote: SpendableNote, recipientNote: NoteWithAmount, changeNote: NoteWithAmount, onStageChange?: (stage: TransferStage) => void): Promise<TransferBuildResult>;
+/**
+ * Format output for contract call (post-quantum)
+ */
+declare function formatOutputForContract(note: NoteCreationResult): {
+    commitment: Hex;
+    searchTag: bigint;
+    ownerHash: bigint;
+    encryptedNote: Hex;
+};
+
+export { buildUPPTransferCircuitInputs as $, type ASPProof as A, type StealthCircuitType as B, type CircuitArtifacts as C, DEMO_ASP_ID as D, type EncryptedNote as E, type StealthMetaAddress as F, type SwapFillEvent as G, type SwapFillParams as H, type SwapOrder as I, type SwapOrderEvent as J, type SwapOrderParams as K, type TransferContext as L, type MergeParams as M, NOTE_VERSION as N, type TransferParams as O, type Proof as P, type TransferStage as Q, RATE_PRECISION as R, STARK_AMOUNT_SCALE as S, type TransferBuildResult as T, type UPPCircuitInputs as U, type UPPCircuitType as V, type UPPTransferCircuitInputs as W, type UPPWithdrawCircuitInputs as X, type WithdrawParams as Y, buildASPTree as Z, buildTransfer as _, type ASPRoot as a, computeCancelKeyHash as a0, computeFillPercentage as a1, computeGiveAmount as a2, computeMultiOriginASPRoot as a3, computeNullifier as a4, computeRate as a5, computeSingleOriginASPRoot as a6, computeTakeAmount as a7, computeTotalBuyAmount as a8, createDemoASPRoot as a9, useUPPAccount as aA, UPPAccountProvider as aB, type UPPAccountContextType as aC, type ProofSystemType as aD, type IndexerConfig as aE, type SignTypedDataFn as aF, ASP_TREE_DEPTH as aG, filterOrdersByASP as aa, filterOrdersByTokenPair as ab, formatOutputForContract as ac, formatProofForContract as ad, formatRate as ae, generateASPProof as af, generateCancelSecret as ag, generateMultiOriginASPProof as ah, generateProof as ai, generateSingleOriginASPProof as aj, generateStealthProof as ak, generateUPPProof as al, getCancelSecret as am, getMerkleProofsForNotes as an, getOwnOrderIds as ao, getStealthCircuitArtifacts as ap, getUPPCircuitArtifacts as aq, isFillerASPAccepted as ar, isOrderActive as as, removeCancelSecret as at, storeCancelSecret as au, syncMerkleTree as av, verifyASPProof as aw, verifyProof as ax, type NoteCreationResult as ay, type ShieldedNote as az, ASP_TREE_DEPTH$1 as b, type CircuitType as c, type Commitment as d, DEMO_ASP_NAME as e, type MergeRecord as f, type MerkleProofWithNote as g, type Note as h, type NoteWithAmount as i, type Nullifier as j, type ProofResult as k, STATE_TREE_DEPTH as l, SWAP_EVENTS_ABI as m, SWAP_ORDER_CANCELLED_EVENT as n, SWAP_ORDER_CLAIMED_EVENT as o, SWAP_ORDER_FILLED_EVENT as p, SWAP_ORDER_PLACED_EVENT as q, type ShieldParams as r, type SpendableNote as s, type StarkNote as t, type StarkProof as u, type StarkStealthMetaAddress as v, type Stealth1x2CircuitInputs as w, type Stealth2x2CircuitInputs as x, type StealthAddress as y, type StealthCircuitInputs as z };