@permissionless-technologies/upp-sdk 0.1.0

package/dist/react/index.d.cts

@@ -0,0 +1,757 @@
+import { ay as NoteCreationResult, az as ShieldedNote, Q as TransferStage, J as SwapOrderEvent } from '../transfer-DKZuJnRM.cjs';
+export { A as ASPProof, aG as ASP_TREE_DEPTH, aE as IndexerConfig, aD as ProofSystemType, aF as SignTypedDataFn, aC as UPPAccountContextType, aB as UPPAccountProvider, Z as buildASPTree, a3 as computeMultiOriginASPRoot, a6 as computeSingleOriginASPRoot, af as generateASPProof, ah as generateMultiOriginASPProof, aj as generateSingleOriginASPProof, aA as useUPPAccount } from '../transfer-DKZuJnRM.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { CSSProperties } from 'react';
+import { P as Point } from '../merkle-mteVOlDf.cjs';
+import { Address, Hex, PublicClient } from 'viem';
+import '../keccak-m31-B_AqBbRF.cjs';
+import '@permissionless-technologies/upc-sdk';
+import '../types-CJSbxv4q.cjs';
+
+interface UPPPrivateButtonProps {
+    /** Additional inline styles for the outer button */
+    style?: CSSProperties;
+    /** Label when private account is not activated (default: "Private Account") */
+    label?: string;
+    /** Optional slot for app-level settings rendered in the account modal */
+    settingsSlot?: React.ReactNode;
+}
+/**
+ * Standalone private account pill button.
+ *
+ * Place alongside RainbowKit's `<ConnectButton />` — no RainbowKit dependency required.
+ * Only needs `UPPAccountProvider` in the component tree.
+ *
+ * Two states:
+ * - Not setup: dashed-border pill with shield icon + label → opens setup modal
+ * - Setup: emerald pill with UPPAvatar + chevron → opens account modal
+ */
+declare function UPPPrivateButton({ style: externalStyle, label, settingsSlot, }: UPPPrivateButtonProps): react_jsx_runtime.JSX.Element;
+
+interface UPPModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    /** Optional slot for app-level settings (e.g. proof system toggle) */
+    settingsSlot?: React.ReactNode;
+}
+declare function UPPModal({ isOpen, onClose, settingsSlot }: UPPModalProps): react.ReactPortal | null;
+
+interface UPPAvatarProps {
+    address: string;
+    size?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+declare function UPPAvatar({ address, size, className, style }: UPPAvatarProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Deterministic geometric avatar generation from an address string.
+ * Uses a simple hash to derive colors and shape parameters.
+ *
+ * No external dependencies — uses a basic string hash for portability
+ * (keccak256 from viem is async/heavy, not needed for visual identity).
+ */
+interface AvatarShape {
+    type: "circle" | "rect" | "triangle";
+    x: number;
+    y: number;
+    size: number;
+    color: string;
+    opacity: number;
+    rotation: number;
+}
+interface AvatarData {
+    background: string;
+    shapes: AvatarShape[];
+}
+/**
+ * Generate avatar data from an address string.
+ * Produces a background color and 3-4 geometric shapes.
+ */
+declare function generateAvatarData(address: string): AvatarData;
+/**
+ * Render avatar data to an SVG string (for non-React contexts).
+ */
+declare function renderAvatarSVG(data: AvatarData, size?: number): string;
+
+/**
+ * Hook return type
+ */
+interface UseUPPCryptoReturn {
+    /** Whether crypto libraries are ready */
+    isReady: boolean;
+    /** Initialize crypto (called automatically, but can be called manually) */
+    init: () => Promise<void>;
+    /** Poseidon hash */
+    poseidon: (inputs: bigint[]) => Promise<bigint>;
+    /** Generate random field element */
+    randomFieldElement: () => Promise<bigint>;
+    /** Compute shared secret (ECDH) */
+    computeSharedSecret: (privateKey: bigint, publicKey: Point) => Promise<Point>;
+    /** Get public key from private key */
+    privateToPublic: (privateKey: bigint) => Promise<Point>;
+    /** Add two points */
+    addPoints: (p1: Point, p2: Point) => Promise<Point>;
+    /** Multiply point by scalar */
+    mulPointScalar: (point: Point, scalar: bigint) => Promise<Point>;
+    /** Get BabyJubJub subgroup order */
+    getSubOrder: () => Promise<bigint>;
+}
+/**
+ * Hook for UPP crypto utilities
+ *
+ * Provides lazy-loaded cryptographic functions.
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isReady, poseidon, randomFieldElement } = useUPPCrypto()
+ *
+ *   if (!isReady) return <div>Loading crypto...</div>
+ *
+ *   // Use crypto functions
+ *   const hash = await poseidon([1n, 2n, 3n])
+ * }
+ * ```
+ */
+declare function useUPPCrypto(): UseUPPCryptoReturn;
+
+/**
+ * Shield configuration
+ */
+interface ShieldConfig {
+    /** UniversalPrivatePool contract address */
+    poolAddress: Address;
+    /** Token address to shield */
+    tokenAddress: Address;
+}
+/**
+ * Shield parameters
+ */
+interface ShieldParams {
+    /** Amount to shield (in wei/smallest unit) */
+    amount: bigint;
+    /** Origin address (the depositor/shielder's wallet address) */
+    originAddress: Address;
+}
+/**
+ * Shield build data - everything needed to call the contract
+ */
+interface ShieldBuildData {
+    /** Amount being shielded */
+    amount: bigint;
+    /** Token address */
+    token: Address;
+    /** Commitment hash (bytes32) */
+    commitment: Hex;
+    /** Encrypted note data */
+    encryptedNote: Hex;
+    /** Raw note data for local storage */
+    noteData: NoteCreationResult;
+}
+/**
+ * useShield return type
+ */
+interface UseShieldReturn {
+    /** Build shield transaction data */
+    build: (params: ShieldParams) => Promise<ShieldBuildData>;
+    /** Whether building is in progress */
+    isPending: boolean;
+    /** Current stage for UI feedback */
+    stage: 'creating_note' | null;
+    /** Error from last attempt */
+    error: Error | null;
+    /** Reset error state */
+    reset: () => void;
+}
+/**
+ * Hook for shielding tokens into UniversalPrivatePool
+ *
+ * @param config - Shield configuration (pool and token addresses)
+ * @returns Shield functions and state
+ *
+ * @example
+ * ```tsx
+ * function ShieldForm() {
+ *   const { address } = useAccount() // from wagmi
+ *   const { build, isPending, error } = useShield({
+ *     poolAddress: '0x...',
+ *     tokenAddress: '0x...',
+ *   })
+ *
+ *   const handleShield = async () => {
+ *     // 1. Build shield data (originAddress is the depositor's wallet)
+ *     const data = await build({
+ *       amount: parseUnits('100', 18),
+ *       originAddress: address!,
+ *     })
+ *
+ *     // 2. Approve token (using wagmi or viem)
+ *     await writeContract({
+ *       address: data.token,
+ *       abi: erc20Abi,
+ *       functionName: 'approve',
+ *       args: [poolAddress, data.amount],
+ *     })
+ *
+ *     // 3. Shield into pool
+ *     await writeContract({
+ *       address: poolAddress,
+ *       abi: UNIVERSAL_PRIVATE_POOL_ABI,
+ *       functionName: 'shield',
+ *       args: [data.token, data.amount, data.commitment, data.encryptedNote],
+ *     })
+ *
+ *     // 4. Track note locally
+ *     addNote({
+ *       amount: data.amount,
+ *       commitment: data.noteData.commitment,
+ *       // ... other note fields
+ *     })
+ *   }
+ *
+ *   return (
+ *     <button onClick={handleShield} disabled={isPending}>
+ *       {isPending ? 'Creating note...' : 'Shield'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useShield(config: ShieldConfig): UseShieldReturn;
+
+/**
+ * Pool transfer configuration
+ */
+interface PoolTransferConfig {
+    /** UniversalPrivatePool contract address */
+    poolAddress: Address;
+    /** Token address being transferred */
+    tokenAddress: Address;
+    /** viem PublicClient for reading chain data */
+    publicClient: PublicClient;
+    /** Circuit artifacts 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[];
+}
+/**
+ * Pool transfer parameters
+ */
+interface PoolTransferParams {
+    /** Amount to send (in wei) */
+    amount: bigint;
+    /** Recipient stealth address (0zk... format) */
+    recipient: string;
+}
+/**
+ * Pool transfer build data - everything needed to call the contract
+ */
+interface PoolTransferBuildData {
+    /** Circuit used: 'transfer' for UPP 1-in-2-out */
+    circuit: 'transfer';
+    /** Formatted proof as uint256[8] */
+    proof: bigint[];
+    /** Nullifier */
+    nullifier: Hex;
+    /** Merkle state root */
+    stateRoot: bigint;
+    /** ASP root */
+    aspRoot: bigint;
+    /** Token address */
+    token: Address;
+    /** Recipient output commitment */
+    outputCommitment1: Hex;
+    /** Change output commitment */
+    outputCommitment2: Hex;
+    /** Recipient encrypted note (packed format) */
+    encryptedNote1: Hex;
+    /** Change encrypted note (packed format) */
+    encryptedNote2: Hex;
+    /** Note that will be spent */
+    spentNote: ShieldedNote;
+    /** Raw note data for local tracking */
+    recipientNoteData: NoteCreationResult;
+    changeNoteData: NoteCreationResult;
+}
+/**
+ * usePoolTransfer return type
+ */
+interface UsePoolTransferReturn {
+    /** Build transfer transaction data */
+    build: (params: PoolTransferParams) => Promise<PoolTransferBuildData>;
+    /** Whether building is in progress */
+    isPending: boolean;
+    /** Current stage for UI feedback */
+    stage: TransferStage | null;
+    /** Error from last attempt */
+    error: Error | null;
+    /** Reset error state */
+    reset: () => void;
+}
+/**
+ * Hook for building private transfer transactions on UniversalPrivatePool
+ *
+ * Uses UPP transfer circuit (1-in-2-out) with ASP membership proof.
+ *
+ * NOTE: Transfer requires STARK circuits. Currently throws at proof generation.
+ */
+declare function usePoolTransfer(config: PoolTransferConfig): UsePoolTransferReturn;
+
+/**
+ * Withdraw configuration
+ */
+interface WithdrawConfig {
+    /** UniversalPrivatePool contract address */
+    poolAddress: Address;
+    /** Token address being withdrawn */
+    tokenAddress: Address;
+    /** viem PublicClient for reading chain data */
+    publicClient: PublicClient;
+    /** Circuit artifacts base URL (default: '/circuits/') */
+    circuitBaseUrl?: string;
+}
+/**
+ * Withdraw parameters
+ */
+interface WithdrawParams {
+    /** Amount to withdraw (in wei) */
+    amount: bigint;
+    /** Public recipient address for the withdrawn tokens */
+    recipient: Address;
+    /** ASP ID to use for compliance (default: 0) */
+    aspId?: bigint;
+    /** ASP root for compliance (default: 0 for ragequit) */
+    aspRoot?: bigint;
+    /** Enable ragequit mode (bypass ASP check, requires recipient = origin) */
+    isRagequit?: boolean;
+}
+/**
+ * Withdraw build data - everything needed to call the contract
+ */
+interface WithdrawBuildData {
+    /** Formatted proof as uint256[8] */
+    proof: bigint[];
+    /** Nullifier of the note being spent */
+    nullifier: Hex;
+    /** Merkle state root */
+    stateRoot: bigint;
+    /** ASP root */
+    aspRoot: bigint;
+    /** ASP ID */
+    aspId: bigint;
+    /** Token address */
+    token: Address;
+    /** Amount being withdrawn */
+    amount: bigint;
+    /** Public recipient address */
+    recipient: Address;
+    /** Whether this is a ragequit withdrawal */
+    isRagequit: boolean;
+    /** Note being spent */
+    spentNote: ShieldedNote;
+    /** Change note data (if any change remains) */
+    changeNoteData: NoteCreationResult | null;
+    /** Change output commitment (if any) */
+    changeCommitment: Hex | null;
+    /** Change encrypted note (if any) */
+    changeEncryptedNote: Hex | null;
+}
+/**
+ * useWithdraw return type
+ */
+interface UseWithdrawReturn {
+    /** Build withdraw transaction data */
+    build: (params: WithdrawParams) => Promise<WithdrawBuildData>;
+    /** Whether building is in progress */
+    isPending: boolean;
+    /** Current stage for UI feedback */
+    stage: TransferStage | null;
+    /** Error from last attempt */
+    error: Error | null;
+    /** Reset error state */
+    reset: () => void;
+}
+/**
+ * Hook for building withdrawal transactions from UniversalPrivatePool
+ *
+ * @param config - Withdraw configuration
+ * @returns Withdraw build functions and state
+ *
+ * @example
+ * ```tsx
+ * function WithdrawForm() {
+ *   const { address } = useAccount()
+ *   const { build, isPending, stage, error } = useWithdraw({
+ *     poolAddress: '0x...',
+ *     tokenAddress: '0x...',
+ *     publicClient,
+ *   })
+ *
+ *   const handleWithdraw = async () => {
+ *     // 1. Build withdrawal data
+ *     const data = await build({
+ *       amount: parseUnits('100', 18),
+ *       recipient: address,
+ *       isRagequit: true, // Emergency exit without ASP check
+ *     })
+ *
+ *     // 2. Submit to pool contract
+ *     await writeContract({
+ *       address: poolAddress,
+ *       abi: UNIVERSAL_PRIVATE_POOL_ABI,
+ *       functionName: 'withdraw',
+ *       args: [
+ *         data.proof,
+ *         data.nullifier,
+ *         data.stateRoot,
+ *         data.aspRoot,
+ *         data.aspId,
+ *         data.token,
+ *         data.amount,
+ *         data.recipient,
+ *         data.isRagequit,
+ *       ],
+ *     })
+ *
+ *     // 3. Track spent note locally
+ *     markNoteSpent(data.spentNote.commitment)
+ *     if (data.changeNoteData) {
+ *       addNote(/* change note *\/)
+ *     }
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {stage && <p>Stage: {stage}</p>}
+ *       <button onClick={handleWithdraw} disabled={isPending}>
+ *         {isPending ? 'Building proof...' : 'Withdraw'}
+ *       </button>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useWithdraw(config: WithdrawConfig): UseWithdrawReturn;
+
+interface PersonalASPConfig {
+    /** ASP Registry Hub contract address */
+    aspHubAddress: Address;
+    /** viem PublicClient for reading chain data */
+    publicClient: PublicClient;
+    /** User's wallet address */
+    userAddress?: Address;
+}
+interface PersonalASPInfo {
+    /** ASP ID (0 if not registered) */
+    aspId: bigint;
+    /** Current root (0 if not set) */
+    currentRoot: bigint;
+    /** Whether the ASP is registered */
+    isRegistered: boolean;
+    /** Whether the root is set to the user's origin */
+    isApproved: boolean;
+}
+interface UsePersonalASPReturn {
+    /** Personal ASP info */
+    aspInfo: PersonalASPInfo | null;
+    /** Whether loading initial state */
+    isLoading: boolean;
+    /** Error from last operation */
+    error: Error | null;
+    /** Check if a specific origin is approved in this ASP */
+    isOriginApproved: (origin: bigint) => Promise<boolean>;
+    /** Get the ASP ID for use in transactions */
+    getASPId: () => bigint | null;
+    /** Get the ASP root for a given origin (for single-origin tree) */
+    getASPRootForOrigin: (origin: bigint) => Promise<bigint>;
+    /** Refresh ASP info from contract */
+    refresh: () => Promise<void>;
+}
+/**
+ * Hook for managing a personal ASP
+ *
+ * @example
+ * ```tsx
+ * function ApproveButton() {
+ *   const { aspInfo, refresh } = usePersonalASP({
+ *     aspHubAddress: '0x...',
+ *     publicClient,
+ *     userAddress: address,
+ *   })
+ *
+ *   // Check if approved
+ *   if (aspInfo?.isApproved) {
+ *     return <span>Approved!</span>
+ *   }
+ *
+ *   return <button onClick={handleApprove}>Approve Yourself</button>
+ * }
+ * ```
+ */
+declare function usePersonalASP(config: PersonalASPConfig): UsePersonalASPReturn;
+/**
+ * Store a newly registered ASP ID
+ * Call this after successfully registering an ASP via contract
+ */
+declare function storePersonalASPId(chainId: number, address: Address, aspId: bigint): void;
+
+type SwapStage = 'idle' | 'preparing' | 'generating_proof' | 'submitting_tx' | 'confirming' | 'done' | 'error';
+interface SwapOrderBookConfig {
+    /** UniversalPrivatePool contract address */
+    poolAddress: Address;
+    /** viem PublicClient for reading chain data */
+    publicClient: PublicClient;
+    /** Token pair filter (optional) */
+    sellToken?: Address;
+    buyToken?: Address;
+    /** ASP filter: only show orders from these ASP IDs */
+    acceptableAspIds?: bigint[];
+    /** Polling interval for order book updates (ms, default: 15000) */
+    pollInterval?: number;
+    /** Start block for event scanning (default: 0) */
+    fromBlock?: bigint;
+}
+interface UseSwapOrderBookReturn {
+    /** Active swap orders */
+    orders: SwapOrderEvent[];
+    /** Whether the order book is loading */
+    isLoading: boolean;
+    /** Error if any */
+    error: string | null;
+    /** Manually refresh the order book */
+    refresh: () => Promise<void>;
+}
+interface SwapConfig {
+    /** UniversalPrivatePool contract address */
+    poolAddress: Address;
+    /** viem PublicClient for reading chain data */
+    publicClient: PublicClient;
+    /** Circuit artifacts base URL (default: '/circuits/') */
+    circuitBaseUrl?: string;
+    /** All approved origins in the ASP tree (enables multi-origin proofs) */
+    aspApprovedOrigins?: bigint[];
+}
+/**
+ * Build data returned by buildPlaceOrder — everything needed for the contract call
+ */
+interface PlaceOrderBuildData {
+    /** Formatted proof as uint256[8] */
+    proof: bigint[];
+    /** Nullifier (= orderId) */
+    nullifier: Hex;
+    /** Merkle state root */
+    stateRoot: bigint;
+    /** ASP root */
+    aspRoot: bigint;
+    /** ASP ID */
+    aspId: bigint;
+    /** Sell token address */
+    sellToken: Address;
+    /** Sell amount */
+    sellAmount: bigint;
+    /** Buy token address */
+    buyToken: Address;
+    /** Rate (1e18 fixed-point) */
+    rate: bigint;
+    /** Cancel key hash */
+    cancelKeyHash: Hex;
+    /** Cancel secret (store in localStorage!) */
+    cancelSecret: Hex;
+    /** Required filler ASP ID */
+    requiredFillerAspId: bigint;
+    /** Expiry (block number) */
+    expiry: bigint;
+    /** Note being spent */
+    spentNote: ShieldedNote;
+}
+/**
+ * Build data returned by buildFillOrder
+ */
+interface FillOrderBuildData {
+    /** Formatted proof as uint256[8] */
+    proof: bigint[];
+    /** Filler's nullifier */
+    nullifier: Hex;
+    /** Merkle state root */
+    stateRoot: bigint;
+    /** ASP root */
+    aspRoot: bigint;
+    /** ASP ID */
+    aspId: bigint;
+    /** Order being filled */
+    orderId: Hex;
+    /** Take amount (sellToken from order) */
+    takeAmount: bigint;
+    /** Filler's output commitment (receives sellToken) */
+    fillerOutputCommitment: Hex;
+    /** Encrypted note for filler's output */
+    fillerEncryptedNote: Hex;
+    /** Note being spent */
+    spentNote: ShieldedNote;
+    /** Filler's new note data */
+    fillerNoteData: NoteCreationResult;
+}
+/**
+ * Build data returned by buildClaimOrder
+ */
+interface ClaimOrderBuildData {
+    /** Order being claimed */
+    orderId: Hex;
+    /** Cancel secret */
+    cancelSecret: Hex;
+    /** Buy output commitment (receives accumulated buyToken) */
+    buyOutputCommitment: Hex;
+    /** Refund commitment (remaining sellToken) */
+    refundCommitment: Hex;
+    /** Encrypted buy output note */
+    buyEncryptedNote: Hex;
+    /** Encrypted refund note */
+    refundEncryptedNote: Hex;
+    /** Buy note data (null if no fills) */
+    buyNoteData: NoteCreationResult | null;
+    /** Refund note data (null if fully filled) */
+    refundNoteData: NoteCreationResult | null;
+}
+/**
+ * Build data returned by buildCancelOrder
+ */
+interface CancelOrderBuildData {
+    /** Order being cancelled */
+    orderId: Hex;
+    /** Cancel secret */
+    cancelSecret: Hex;
+    /** Refund commitment */
+    refundCommitment: Hex;
+    /** Encrypted refund note */
+    refundEncryptedNote: Hex;
+    /** Refund note data */
+    refundNoteData: NoteCreationResult;
+}
+interface SplitNoteParams {
+    /** Note to split */
+    note: ShieldedNote;
+    /** Desired amount for the first output (the rest becomes change) */
+    targetAmount: bigint;
+    /** ASP ID to use for the proof (defaults to DEMO_ASP_ID if not provided) */
+    aspId?: bigint;
+}
+interface SplitNoteBuildData {
+    /** Transfer proof for contract call */
+    proof: bigint[];
+    /** Nullifier */
+    nullifier: Hex;
+    /** Merkle state root */
+    stateRoot: bigint;
+    /** ASP root (for transfer circuit) */
+    aspRoot: bigint;
+    /** Token address */
+    token: Address;
+    /** Exact-amount output commitment */
+    outputCommitment1: Hex;
+    /** Change output commitment */
+    outputCommitment2: Hex;
+    /** Exact-amount encrypted note */
+    encryptedNote1: Hex;
+    /** Change encrypted note */
+    encryptedNote2: Hex;
+    /** The exact-amount note — use as noteOverride for buildPlaceOrder/buildFillOrder */
+    exactNote: ShieldedNote;
+    /** The change note */
+    changeNote: ShieldedNote;
+    /** Original note being spent */
+    spentNote: ShieldedNote;
+    /** Raw creation data for local tracking */
+    exactNoteData: NoteCreationResult;
+    /** Raw creation data for local tracking */
+    changeNoteData: NoteCreationResult;
+}
+interface UseSwapReturn {
+    /** Current operation stage */
+    stage: TransferStage | null;
+    /** Whether building is in progress */
+    isPending: boolean;
+    /** Error from last attempt */
+    error: Error | null;
+    /** Build a self-transfer to split a note into exact amount + change */
+    buildNoteSplit: (params: SplitNoteParams) => Promise<SplitNoteBuildData>;
+    /** Build place order data (returns everything needed for contract call) */
+    buildPlaceOrder: (params: PlaceOrderParams) => Promise<PlaceOrderBuildData>;
+    /** Build fill order data */
+    buildFillOrder: (params: FillOrderParams) => Promise<FillOrderBuildData>;
+    /** Build claim order data (no proof needed) */
+    buildClaimOrder: (params: ClaimOrderParams) => Promise<ClaimOrderBuildData>;
+    /** Build cancel order data (no proof needed) */
+    buildCancelOrder: (params: CancelOrderParams) => Promise<CancelOrderBuildData>;
+    /** Reset state */
+    reset: () => void;
+}
+interface PlaceOrderParams {
+    /** 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 */
+    expiryBlocks: bigint;
+    /** ASP ID — must be a registered personal ASP */
+    aspId: bigint;
+    /** Explicit note to spend (skips note selection). Used after auto-split. */
+    noteOverride?: ShieldedNote;
+}
+interface FillOrderParams {
+    /** Order to fill */
+    orderId: Hex;
+    /** How much sellToken to take */
+    takeAmount: bigint;
+    /** The order's rate */
+    rate: bigint;
+    /** The order's sellToken (filler receives this) */
+    sellToken: Address;
+    /** The order's buyToken (filler pays this) */
+    buyToken: Address;
+    /** ASP ID — must be a registered personal ASP */
+    aspId: bigint;
+    /** Explicit note to spend (skips note selection). Used after auto-split. */
+    noteOverride?: ShieldedNote;
+}
+interface ClaimOrderParams {
+    /** Order to claim */
+    orderId: Hex;
+    /** Cancel secret used when placing the order */
+    cancelSecret: Hex;
+    /** On-chain remaining sell amount */
+    remainingSellAmount: bigint;
+    /** On-chain accumulated buy amount */
+    accumulatedBuyAmount: bigint;
+    /** The order's sell token */
+    sellToken: Address;
+    /** The order's buy token */
+    buyToken: Address;
+}
+interface CancelOrderParams {
+    /** Order to cancel */
+    orderId: Hex;
+    /** Cancel secret used when placing the order */
+    cancelSecret: Hex;
+    /** The full sell amount (refunded on cancel) */
+    sellAmount: bigint;
+    /** The order's sell token */
+    sellToken: Address;
+}
+declare function useSwapOrderBook(config: SwapOrderBookConfig): UseSwapOrderBookReturn;
+/**
+ * Hook for swap operations with real proof generation.
+ * Mirrors useWithdraw — returns build functions that produce contract call data.
+ */
+declare function useSwap(config: SwapConfig): UseSwapReturn;
+
+export { type AvatarData, type AvatarShape, type CancelOrderBuildData, type CancelOrderParams, type ClaimOrderBuildData, type ClaimOrderParams, type FillOrderBuildData, type FillOrderParams, NoteCreationResult, type PersonalASPConfig, type PersonalASPInfo, type PlaceOrderBuildData, type PlaceOrderParams, type PoolTransferBuildData, type PoolTransferConfig, type PoolTransferParams, type ShieldBuildData, type ShieldConfig, type ShieldParams, ShieldedNote, type SplitNoteBuildData, type SplitNoteParams, type SwapConfig, type SwapOrderBookConfig, type SwapStage, TransferStage, UPPAvatar, type UPPAvatarProps, UPPModal, type UPPModalProps, UPPPrivateButton, type UPPPrivateButtonProps, type UsePersonalASPReturn, type UsePoolTransferReturn, type UseShieldReturn, type UseSwapOrderBookReturn, type UseSwapReturn, type UseWithdrawReturn, type WithdrawBuildData, type WithdrawConfig, type WithdrawParams, generateAvatarData, renderAvatarSVG, storePersonalASPId, usePersonalASP, usePoolTransfer, useShield, useSwap, useSwapOrderBook, useUPPCrypto, useWithdraw };