@continuumdao/ctm-mpc-defi 0.2.48 → 0.2.49

package/dist/index.d.ts

@@ -1,17 +1,849 @@
-export { C as ChainCategory, a as ChainSupportContext, E as EvmTokenKind, K as KeyGenSubset, b as KeyGenSubsetForPermit, M as MultisignBuildResult, c as MultisignCommonArgs, N as NearTokenKind, P as ParamDoc, d as ProtocolActionDescriptor, e as ProtocolModule, S as SolanaTokenKind, T as TokenRef } from './types-lIfv59N1.js';
+import { NodeReadAuth } from '@continuumdao/continuum-node-sdk';
 export { getClientIdFromKeyGenResult as firstClientIdFromKeyGen } from '@continuumdao/continuum-node-sdk';
-export { BuildPayloadSignEd25519MultisignBodyArgs, DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS, DEFI_PROTOCOLS_WITH_30MIN_EXPIRY, PAYLOAD_SIGN_ED25519_REQUEST_KIND, PayloadSignEd25519Delivery, buildPayloadSignEd25519MultisignBody, defiEvmTransport, defiMultisignExpiryUnixSeconds, getAaveGraphqlProxyUrl, getCoingeckoProxyUrl, getDefiEvmRpcTransportFactory, getEulerGraphqlProxyUrl, getEulerV3ApiProxyBase, getJsonViaOptionalProxy, getMapleGraphqlProxyUrl, getMorphoGraphqlProxyUrl, getMorphoMidnightRestProxyUrl, mergePurposeText, postJsonViaOptionalProxy, setAaveGraphqlProxyUrl, setCoingeckoProxyUrl, setDefiEvmRpcTransportFactory, setEulerGraphqlProxyUrl, setEulerV3ApiProxyBase, setMapleGraphqlProxyUrl, setMorphoGraphqlProxyUrl, setMorphoMidnightRestProxyUrl } from './core/index.js';
-export { C as ChainCategoryBuildInput, a as ChainCategoryModule, M as MultisignLeg, c as coreChainCategoryModule, f as finalizeMultisign } from './envelope-Cm-llShH.js';
-export { g as getActionsByChainCategory, a as getProtocolModule, b as getProtocolModules, r as registerProtocolModule } from './registry-BvsXh0-r.js';
-export { B as BuildEip712MultisignArgs, a as BuildEip712MultisignLeg, E as EIP712_SIGN_REQUEST_KIND, b as Eip712MultisignDelivery, c as Eip712TypedDataField, d as Eip712TypedDataPayload, e as buildEip712Multisign } from './eip712Multisign-6oNIlObj.js';
-export { E as EvmChainDetail, a as EvmProtocolContext, b as EvmTxStep, i as isEvmNativeToken, m as matchEvmTokenKind } from './types-RJpoU4Pc.js';
-export { E as EvmBatchMetaBuilder, a as EvmBuildBatchArgs, b as buildEvmMultisignBatch, e as evmChainCategoryModule } from './buildBatch-tsEUVn_a.js';
-export { COINGECKO_PLATFORM_BY_CHAIN_ID, ConditionalApproveStep, approveStepsToEvmTxSteps, buildConditionalErc20ApproveSteps, coingeckoPlatformForChainId, normalizeCurveRouterAmountString, normalizeHumanDecimalAmount, parseEvmChainIdToNumber, publicClientForRpc, resolveErc20Decimals, routerSwapGasLimitFromEstimate } from './chains/evm/index.js';
-export { SOLANA_CHAIN_CATEGORY, solanaChainCategoryModule } from './chains/solana/index.js';
-export { NEAR_CHAIN_CATEGORY, nearChainCategoryModule } from './chains/near/index.js';
-export { uniswapV4, uniswapV4ProtocolModule } from './protocols/evm/uniswap-v4/index.js';
-export { curveDao, curveDaoProtocolModule } from './protocols/evm/curve-dao/index.js';
-export { aerodromeProtocolModule } from './protocols/evm/aerodrome/index.js';
-export { pendleProtocolModule } from './protocols/evm/pendle/index.js';
-import 'viem';
-import 'abitype';
+import { http, Transport, TypedDataDomain, Address, PublicClient } from 'viem';
+
+/** Aligns with app NonEvmChainType + 'evm'. Extend as mpc-auth adds chains. */
+type ChainCategory = 'evm' | 'solana' | 'near' | 'sui' | 'ton' | 'stellar';
+type MultisignBuildResult = {
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+};
+type EvmTokenKind = 'native' | 'erc20' | 'erc721' | 'ctmerc20' | 'ctmrwa1';
+type SolanaTokenKind = 'native' | 'spl' | 'spl2022';
+type NearTokenKind = 'native' | 'nep141';
+type TokenRef = {
+    category: 'evm';
+    kind: EvmTokenKind;
+    address: `0x${string}`;
+} | {
+    category: 'solana';
+    kind: SolanaTokenKind;
+    mint: string;
+} | {
+    category: 'near';
+    kind: NearTokenKind;
+    contractId: string;
+};
+type ParamDoc = {
+    type: string;
+    required: boolean;
+    description: string;
+};
+type ProtocolActionDescriptor = {
+    id: string;
+    protocolId: string;
+    chainCategory: ChainCategory;
+    description: string;
+    commonParams: Array<'keyGen' | 'purposeText' | 'useCustomGas' | 'useCustomFees'>;
+    params: Record<string, ParamDoc>;
+};
+type ChainSupportContext = {
+    chainCategory: ChainCategory;
+    chainId: string | number;
+};
+interface ProtocolModule {
+    id: string;
+    chainCategory: ChainCategory;
+    isChainSupported(ctx: ChainSupportContext): boolean | Promise<boolean>;
+    isTokenSupported(token: TokenRef): boolean | Promise<boolean>;
+    actions: ProtocolActionDescriptor[];
+}
+interface MultisignCommonArgs {
+    keyGen: KeyGenSubset;
+    purposeText: string;
+    /** Optional Unix seconds (UTC) for POST /multiSignRequest expiryDate. */
+    expiryDate?: number;
+}
+type KeyGenSubset = {
+    pubkeyhex?: string;
+    keylist?: string[];
+    ClientKeys?: Record<string, string>;
+    groupId?: string;
+    GroupId?: string;
+};
+/** App-compatible alias used by multisign builders and Permit2 helpers. */
+type KeyGenSubsetForPermit = KeyGenSubset;
+
+/** Merge user purpose text with an optional batch / protocol suffix. */
+declare function mergePurposeText(purposeText: string | undefined, purposeSuffix?: string): string;
+
+interface MultisignLeg {
+    msgHash: string;
+    msgRaw: string;
+    destinationAddress: string;
+    signatureText: string;
+    audit: Record<string, unknown>;
+    feeSnapshot: Record<string, unknown>;
+    proposalTxParams?: Record<string, unknown>;
+    /** Payable value wei string for first leg only when relevant */
+    valueWei?: bigint;
+}
+interface ChainCategoryBuildInput {
+    keyGen: KeyGenSubset;
+    purposeText: string;
+    purposeSuffix?: string;
+    destinationChainID: string;
+    legs: MultisignLeg[];
+    extraJSON?: Record<string, unknown>;
+    /** Top-level destination address (first leg destination if omitted) */
+    destinationAddress?: string;
+    /** Unix seconds (UTC) for mpc-auth multiSignRequest expiryDate. */
+    expiryDate?: number;
+}
+interface ChainCategoryModule {
+    category: ChainCategory;
+    finalizeMultisign(input: ChainCategoryBuildInput): MultisignBuildResult;
+}
+/**
+ * Assemble mpc-auth `bodyForSign` from category-built legs.
+ * Supports single-tx and batch (messageHashes / messageRawBatch / proposalTxParams).
+ */
+declare function finalizeMultisign(input: ChainCategoryBuildInput): MultisignBuildResult;
+declare const coreChainCategoryModule: ChainCategoryModule;
+
+declare function registerProtocolModule(mod: ProtocolModule): void;
+declare function getProtocolModules(): readonly ProtocolModule[];
+declare function getProtocolModule(id: string): ProtocolModule | undefined;
+declare function getActionsByChainCategory(category: string): ProtocolModule['actions'];
+
+/**
+ * Optional browser → Next.js API proxy paths for DeFi upstream calls.
+ * Set once from continuumdao-node-app client bootstrap.
+ */
+declare function setAaveGraphqlProxyUrl(url: string | undefined): void;
+declare function getAaveGraphqlProxyUrl(): string | undefined;
+declare function setEulerGraphqlProxyUrl(url: string | undefined): void;
+declare function getEulerGraphqlProxyUrl(): string | undefined;
+declare function setEulerV3ApiProxyBase(url: string | undefined): void;
+declare function getEulerV3ApiProxyBase(): string | undefined;
+declare function setMapleGraphqlProxyUrl(url: string | undefined): void;
+declare function getMapleGraphqlProxyUrl(): string | undefined;
+declare function setMorphoGraphqlProxyUrl(url: string | undefined): void;
+declare function getMorphoGraphqlProxyUrl(): string | undefined;
+declare function setMorphoMidnightRestProxyUrl(url: string | undefined): void;
+declare function getMorphoMidnightRestProxyUrl(): string | undefined;
+declare function setCoingeckoProxyUrl(url: string | undefined): void;
+declare function getCoingeckoProxyUrl(): string | undefined;
+declare function postJsonViaOptionalProxy<T>(args: {
+    directUrl: string;
+    body: unknown;
+    proxyUrl?: string;
+    proxyEnvelope?: unknown;
+}): Promise<T>;
+declare function getJsonViaOptionalProxy<T>(args: {
+    directUrl: string;
+    /** When set, GET this URL instead of directUrl (same path semantics as caller built). */
+    proxyUrl?: string;
+}): Promise<T>;
+
+declare function setDefiEvmRpcTransportFactory(factory: ((rpcUrl: string) => Transport) | undefined): void;
+declare function getDefiEvmRpcTransportFactory(): ((rpcUrl: string) => Transport) | undefined;
+/** Same-origin proxy in the browser when the app has called {@link setDefiEvmRpcTransportFactory}. */
+declare function defiEvmTransport(rpcUrl: string, opts?: Parameters<typeof http>[1]): Transport;
+
+declare const EIP712_SIGN_REQUEST_KIND: "eip712";
+type Eip712TypedDataField = {
+    name: string;
+    type: string;
+};
+type Eip712TypedDataPayload = {
+    domain: TypedDataDomain;
+    types: Record<string, readonly Eip712TypedDataField[] | Eip712TypedDataField[]>;
+    primaryType: string;
+    message: Record<string, unknown>;
+};
+type Eip712MultisignDelivery = Record<string, unknown> & {
+    kind: string;
+};
+type BuildEip712MultisignLeg = {
+    typedData: Eip712TypedDataPayload;
+    delivery: Eip712MultisignDelivery;
+    audit?: Record<string, unknown>;
+};
+type BuildEip712MultisignArgs = {
+    keyGen: KeyGenSubset;
+    purposeText: string;
+    purposeSuffix?: string;
+    /** Chain id stored on the sign request (protocol context; may differ from EIP-712 domain chainId). */
+    destinationChainID: string;
+    destinationAddress: string;
+    legs: readonly BuildEip712MultisignLeg[];
+    expiryDate?: number;
+};
+/**
+ * Build an mpc-auth multiSignRequest body for one or more EIP-712 digests (no EVM tx broadcast).
+ * `extraJSON.eip712` is always an array. N=1 uses `msgHash`/`msgRaw`; N>=2 uses `messageHashes`/`messageRawBatch`.
+ */
+declare function buildEip712Multisign(args: BuildEip712MultisignArgs): MultisignBuildResult;
+
+declare const PAYLOAD_SIGN_ED25519_REQUEST_KIND: "payload_sign_ed25519";
+type PayloadSignEd25519Delivery = Record<string, unknown> & {
+    kind: string;
+};
+type BuildPayloadSignEd25519MultisignBodyArgs = {
+    keyGen: KeyGenSubset;
+    purposeText: string;
+    purposeSuffix?: string;
+    destinationChainID: string;
+    destinationAddress: string;
+    /** UTF-8 bytes to sign (Arcus canonical JSON). */
+    messageUtf8: string;
+    /** secp256k1 pub key hex for billing when signing with paired ed25519 KeyGen. */
+    billingKeyGenPubKey?: string;
+    delivery: PayloadSignEd25519Delivery;
+    audit?: Record<string, unknown>;
+    expiryDate?: number;
+    signatureText?: string;
+};
+/**
+ * Build mpc-auth multiSignRequest for Ed25519 FROST signing over variable-length UTF-8 (Arcus Scheme 1).
+ * `msgHash` is hex of the raw message bytes (not SHA-256); mpc-auth givre worker signs these bytes directly.
+ */
+declare function buildPayloadSignEd25519MultisignBody(args: BuildPayloadSignEd25519MultisignBodyArgs): MultisignBuildResult;
+
+/** Default MPC sign-request agreement window for fast-moving DeFi protocols (30 minutes). */
+declare const DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS: number;
+/** Protocol ids that default to 30-minute expiry when `expiryDate` is omitted on multisign MCP tools. */
+declare const DEFI_PROTOCOLS_WITH_30MIN_EXPIRY: Set<string>;
+declare function defiMultisignExpiryUnixSeconds(protocolId: string | undefined, explicitExpiryDate?: number | null): number | undefined;
+
+type EvmChainDetail = {
+    legacy?: boolean;
+    gasLimit?: number;
+    gasMultiplier?: number;
+    gasPrice?: number;
+    baseFee?: number;
+    priorityFee?: number;
+    baseFeeMultiplier?: number;
+};
+interface EvmProtocolContext extends MultisignCommonArgs {
+    chainCategory: 'evm';
+    chainId: number;
+    rpcUrl: string;
+    executorAddress: Address;
+    chainDetail: EvmChainDetail;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+}
+type EvmTxStep = {
+    to: Address;
+    data: `0x${string}`;
+    value: bigint;
+    /** Fallback when estimateGas reverts */
+    fallbackGas?: bigint;
+    /** When set, use routerSwapGasLimitFromEstimate instead of plain estimate */
+    routerSwap?: boolean;
+};
+declare function isEvmNativeToken(address: string): boolean;
+declare function matchEvmTokenKind(kind: EvmTokenKind, address: string): boolean;
+
+type EvmBatchMetaBuilder = (args: {
+    step: EvmTxStep;
+    index: number;
+    gasLimit: bigint;
+}) => Record<string, unknown>;
+type EvmBuildBatchArgs = {
+    context: EvmProtocolContext;
+    steps: EvmTxStep[];
+    purposeSuffix?: string;
+    buildBatchMeta: EvmBatchMetaBuilder;
+    /** First leg msgRaw without 0x prefix; defaults to first step calldata */
+    firstMsgRawNo0x?: string;
+    destinationAddress?: Address;
+    /** Top-level `value` on bodyForSign when the payable amount is not on the first leg */
+    payableValueWei?: bigint;
+    resolveGasLimit?: (args: {
+        step: EvmTxStep;
+        index: number;
+        estimatedGas: bigint;
+        publicClient: PublicClient;
+    }) => Promise<bigint> | bigint;
+    /** Override default `estimateGas` (e.g. trade-API gas, skip post-approve deposit estimate). */
+    estimateGasForStep?: (args: {
+        step: EvmTxStep;
+        index: number;
+        publicClient: PublicClient;
+        executor: Address;
+    }) => Promise<bigint> | bigint;
+};
+/**
+ * Build unsigned EVM txs, estimate gas, serialize, hash — then assemble mpc-auth body via core envelope.
+ */
+declare function buildEvmMultisignBatch(args: EvmBuildBatchArgs): Promise<MultisignBuildResult>;
+declare const evmChainCategoryModule: {
+    category: "evm";
+    finalizeMultisign: typeof finalizeMultisign;
+    buildEvmMultisignBatch: typeof buildEvmMultisignBatch;
+};
+
+/** Parse chain id for comparisons (decimal, 0x hex, CAIP-2 eip155:N, bigint). */
+declare function parseEvmChainIdToNumber(chainId: string | number | bigint | null | undefined): number;
+
+/**
+ * Canonical human decimal string for a token amount (truncate to token decimals via wei round-trip).
+ * Used by Curve router and multisign dialogs across protocols.
+ */
+declare function normalizeHumanDecimalAmount(raw: string, tokenDecimals: number): string;
+/** @deprecated Prefer normalizeHumanDecimalAmount; kept for Curve router parity. */
+declare const normalizeCurveRouterAmountString: typeof normalizeHumanDecimalAmount;
+
+declare function publicClientForRpc(chainId: number, rpcUrl: string): PublicClient;
+/**
+ * Resolve ERC-20 decimals: on-chain `decimals()` is authoritative; optional registry/API hints
+ * are validated and logged when they disagree (common when registry is stale).
+ */
+declare function resolveErc20Decimals(args: {
+    publicClient: PublicClient;
+    token: Address;
+    registryDecimals?: number;
+    apiDecimals?: number;
+}): Promise<number>;
+type ConditionalApproveStep = {
+    to: Address;
+    data: `0x${string}`;
+    value: bigint;
+    fallbackGas?: bigint;
+};
+/**
+ * Standard deposit-path approve batch: skip when allowance sufficient; reset-to-zero when needed.
+ */
+declare function buildConditionalErc20ApproveSteps(args: {
+    publicClient: PublicClient;
+    token: Address;
+    spender: Address;
+    owner: Address;
+    amountWei: bigint;
+    fallbackGas?: bigint;
+}): Promise<ConditionalApproveStep[]>;
+declare function approveStepsToEvmTxSteps(steps: ConditionalApproveStep[]): EvmTxStep[];
+
+/**
+ * CoinGecko asset platform id by mainnet chainId (contract + token_price endpoints).
+ * IDs from CoinGecko GET /asset_platforms (chain_identifier → id).
+ * Keep in sync with continuumdao-node-app `COINGECKO_PLATFORM_BY_CHAIN_ID`.
+ */
+declare const COINGECKO_PLATFORM_BY_CHAIN_ID: Record<string, string>;
+declare function coingeckoPlatformForChainId(chainId: string | number): string | undefined;
+
+/** Curve router swap gas: chain cap when set, else 12/10 estimate bump. */
+declare function routerSwapGasLimitFromEstimate(estimatedGas: bigint, chainGasLimit?: number | null): bigint;
+
+declare const solanaChainCategoryModule: {
+    category: "solana";
+};
+
+declare const SOLANA_CHAIN_CATEGORY: "solana";
+
+declare const nearChainCategoryModule: {
+    category: "near";
+};
+
+declare const NEAR_CHAIN_CATEGORY: "near";
+
+declare function isUniswapV4ChainSupported(chainId: string | number | bigint | null | undefined): boolean;
+type UniswapV4PositionManagerKind = 'standard' | 'permissioned';
+
+/** POST /v1/quote `type` (same as `uniswap_trade_quote.py` `--type`). */
+type UniswapQuoteTradeType = 'EXACT_INPUT' | 'EXACT_OUTPUT';
+interface UniswapTradeQuoteParams {
+    amount: string;
+    tokenIn: string;
+    tokenOut: string;
+    uniswapApiKey: string;
+    /**
+     * KeyGen id — used to resolve `swapper` from GET /getKeyGenResultById unless `swapper` is set.
+     * Required unless `swapper` is set.
+     */
+    keyGen?: string;
+    type: UniswapQuoteTradeType;
+    /**
+     * Slippage as percent, e.g. `0.5` for 0.5%. If omitted, the body uses
+     * `autoSlippage: "DEFAULT"` (same as the Python script when `--slippage` is not set).
+     */
+    slippage?: number | string;
+    /**
+     * Chain id for the input side (`tokenInChainId` in the HTTP body; Python `--chain-id`).
+     * You may set **`chainId` or `tokenInChainId`** (same meaning); if both are set, `chainId` wins.
+     * Same-chain quote: set one chain here and omit `tokenOutChainId` (or set both to the same id).
+     */
+    chainId?: string | number;
+    /**
+     * Same as `chainId` (input chain). If `chainId` is omitted, this must be set.
+     */
+    tokenInChainId?: string | number;
+    /**
+     * Output chain id; defaults to the input chain when omitted (Python: empty `--token-out-chain-id`).
+     */
+    tokenOutChainId?: string | number;
+    /**
+     * When `true`, sends `x-permit2-disabled: true` (Uniswap’s header for classic ERC-20 allowance; no permitData in the response).
+     * Omit or set `false` for the default Trade API routing (default).
+     */
+    permit2Disabled?: boolean;
+    /**
+     * MPC wallet (swapper) address. If omitted, `managementNodeUrl` is used with `keyGen`
+     * to call GET /getKeyGenResultById.
+     */
+    swapper?: `0x${string}` | string;
+    /**
+     * Management node base URL (MPC), required when `swapper` is not provided.
+     */
+    managementNodeUrl?: string;
+    /** For Browser HTTPS: Bearer on GET to /getKeyGenResultById. */
+    nodeReadAuth?: NodeReadAuth;
+    /** Trade API base without `/quote` (default: Uniswap gateway v1). */
+    baseUrl?: string;
+    /** `x-universal-router-version` (default `2.0`, aligned with Python / v4). */
+    universalRouterVersion?: string;
+    /**
+     * When true (default), call Trade API `/v1/permissions` before quoting.
+     * Permissioned tokens force UR 2.2.0. Quotes are still allowed when not allowlisted
+     * (Uniswap UX guidance); swap submit must assert allowlist.
+     */
+    checkPermissions?: boolean;
+    /** Skip the permissions preflight. */
+    skipPermissionCheck?: boolean;
+    /** Force UR 2.2.0 without calling permissions (tests / known permissioned tokens). */
+    forcePermissionedRouter?: boolean;
+    signal?: AbortSignal;
+    /** Override for tests. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * `POST` Uniswap Trade API `/v1/quote` — TypeScript version of
+ * `mpc-config/recipes/uniswapV4/uniswap_trade_quote.py` (core HTTP call + KeyGen → swapper).
+ *
+ * CORS: calling the Trade API from a browser may be blocked. Prefer a server / route
+ * handler, or use this in Node. KeyGen resolution uses a GET to your management node
+ * and follows the same read-auth pattern as the app.
+ */
+declare function uniswapTradeQuote(args: UniswapTradeQuoteParams): Promise<Record<string, unknown>>;
+
+type TransactionRequest = {
+    to: string;
+    from?: string;
+    data: string;
+    value: string;
+    /** Trade API or eth-style field name */
+    gasLimit?: string;
+    gas?: string;
+    chainId?: number;
+};
+type CreateSwapResponse = {
+    requestId?: string;
+    swap: TransactionRequest;
+    gasFee?: string;
+};
+/**
+ * `POST /v1/swap` — builds swap calldata (Universal Router) from a quote fetched with classic-allowance header `x-permit2-disabled: true`.
+ * @see https://api-docs.uniswap.org/api-reference/swapping/swap
+ */
+declare function uniswapCreateSwap(args: {
+    uniswapApiKey: string;
+    baseUrl?: string;
+    /** Full `POST /quote` JSON (must include classic `quote`). */
+    fullQuoteFromPermit: Record<string, unknown>;
+    universalRouterVersion?: string;
+    fetchImpl?: typeof fetch;
+    /**
+     * In the browser, direct `POST` to `trade-api.gateway.uniswap.org` is blocked by CORS.
+     * When true (default in browser), the request goes to same-origin `POST /api/uniswap/swap` which proxies server-side. Set `false` to force a direct call (e.g. tests, Node scripts).
+     */
+    useServerProxy?: boolean;
+    /**
+     * Universal Router swap deadline (unix seconds). Defaults to now + {@link UNISWAP_SWAP_DEFAULT_DEADLINE_SEC_OFFSET}.
+     * Omitting this caused short API defaults and `TransactionDeadlinePassed` after MPC delay.
+     */
+    swapTransactionDeadlineUnix?: number;
+}): Promise<CreateSwapResponse>;
+type ChainRow$1 = {
+    legacy?: boolean;
+    gasLimit?: number;
+    gasMultiplier?: number;
+    gasPrice?: number;
+    baseFee?: number;
+    priorityFee?: number;
+    baseFeeMultiplier?: number;
+};
+type UniswapV4SkipPermit2BatchArg = {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow$1;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    /** `0x0` = native (ETH) in; otherwise ERC-20. */
+    tokenIn: Address;
+    executorAddress: Address;
+    swap: TransactionRequest;
+    createSwapResponse: {
+        requestId?: string;
+        gasFee?: string;
+        swap: TransactionRequest;
+    };
+    fullQuoteSnapshot: Record<string, unknown>;
+    purposeText: string;
+    swapDeadlineUnix: number;
+    slippagePercent?: number;
+    /** When set, re-check Trade API permissions before building the sign request. */
+    uniswapApiKey?: string;
+    tokenOut?: string;
+    /** Skip allowlist assert (tests only). */
+    skipPermissionCheck?: boolean;
+};
+/**
+ * **Classic ERC-20 allowance** batch (on-chain approvals only), two shapes:
+ *
+ * - **`swap.to` == inner `router` (calldata arg)** — Universal Router is the tx target; tokens move via the **allowance hub**:
+ *   `ERC20→hub`, hub `approve(router)`, swap (3 txs).
+ *
+ * - **`swap.to` ≠ inner `router`** — Trade uses a **dispatcher** that calls `ERC20.transferFrom` with **`msg.sender` = `swap.to`**.
+ *   Approving only the hub is insufficient (`cast run` shows `transfer amount exceeds allowance`). Path:
+ *   `ERC20.approve(swap.to)`, swap (2 txs).
+ *
+ * Approved amount: `max(quote.input, calldata amount)`; with **EXACT_OUTPUT** trades, multiply by `(1 + slippage%)` from the quote modal (input can grow vs the quoted figure).
+ */
+declare function buildEvmMultisignBodyUniswapV4SkipPermit2Batch(args: UniswapV4SkipPermit2BatchArg): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+
+type UniswapLpExistingPool = {
+    token0Address: string;
+    token1Address: string;
+    /** V4 pool id (bytes32 hex); V3 pool contract address. */
+    poolReference: string;
+};
+type UniswapLpNewPool = {
+    token0Address: string;
+    token1Address: string;
+    fee: number;
+    tickSpacing: number;
+    hooks?: string;
+    initialPrice: string;
+};
+type UniswapLpIndependentToken = {
+    tokenAddress: string;
+    amount: string;
+};
+type UniswapLpPriceBounds = {
+    minPrice: string;
+    maxPrice: string;
+};
+type UniswapLpTickBounds = {
+    tickLower: number;
+    tickUpper: number;
+};
+declare function uniswapLpCreatePosition(args: {
+    uniswapApiKey: string;
+    walletAddress: string;
+    chainId: number;
+    existingPool?: UniswapLpExistingPool;
+    newPool?: UniswapLpNewPool;
+    independentToken: UniswapLpIndependentToken;
+    priceBounds?: UniswapLpPriceBounds;
+    tickBounds?: UniswapLpTickBounds;
+    slippageTolerance?: number;
+    deadline?: number;
+    simulateTransaction?: boolean;
+    batchPermitData?: Record<string, unknown>;
+    signature?: string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    useServerProxy?: boolean;
+}): Promise<Record<string, unknown>>;
+declare function uniswapLpIncreasePosition(args: {
+    uniswapApiKey: string;
+    walletAddress: string;
+    chainId: number;
+    token0Address: string;
+    token1Address: string;
+    nftTokenId: string | number;
+    independentToken: UniswapLpIndependentToken;
+    slippageTolerance?: number;
+    deadline?: number;
+    simulateTransaction?: boolean;
+    v4BatchPermitData?: Record<string, unknown>;
+    signature?: string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    useServerProxy?: boolean;
+}): Promise<Record<string, unknown>>;
+declare function uniswapLpDecreasePosition(args: {
+    uniswapApiKey: string;
+    walletAddress: string;
+    chainId: number;
+    token0Address: string;
+    token1Address: string;
+    nftTokenId: string | number;
+    liquidityPercentageToDecrease: number;
+    slippageTolerance?: number;
+    deadline?: number;
+    simulateTransaction?: boolean;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    useServerProxy?: boolean;
+}): Promise<Record<string, unknown>>;
+declare function uniswapLpClaimFees(args: {
+    uniswapApiKey: string;
+    walletAddress: string;
+    chainId: number;
+    tokenId: string | number;
+    simulateTransaction?: boolean;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+    useServerProxy?: boolean;
+}): Promise<Record<string, unknown>>;
+
+type UniswapLpAction = 'mint' | 'increase' | 'decrease' | 'collect';
+
+type ChainRow = {
+    legacy?: boolean;
+    gasLimit?: number;
+    gasMultiplier?: number;
+    gasPrice?: number;
+    baseFee?: number;
+    priorityFee?: number;
+    baseFeeMultiplier?: number;
+};
+type LiquidityMultisignCommon = {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: ChainRow;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    executorAddress: Address;
+    purposeText: string;
+    lpResponse: Record<string, unknown>;
+    action: UniswapLpAction;
+    /** Wrapped native token when pool uses native ETH as currency0/1. */
+    nativeWrapped?: Address;
+    nftTokenId?: string | number;
+    poolReference?: string;
+    /**
+     * `permissioned` → approve Permit2 then Permit2.approve(PermPosM) (Uniswap docs).
+     * Default `standard` keeps classic ERC-20 approve to Position Manager.
+     */
+    positionManagerKind?: UniswapV4PositionManagerKind;
+    /** Override Permit2 path; defaults true when positionManagerKind is permissioned. */
+    usePermit2Approvals?: boolean;
+};
+declare function buildEvmMultisignBodyUniswapV4MintLiquidityBatch(args: Omit<LiquidityMultisignCommon, 'action' | 'nftTokenId'> & {
+    poolReference?: string;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+declare function buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch(args: Omit<LiquidityMultisignCommon, 'action'> & {
+    nftTokenId: string | number;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+declare function buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch(args: Omit<LiquidityMultisignCommon, 'action'> & {
+    nftTokenId: string | number;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+declare function buildEvmMultisignBodyUniswapV4CollectFeesBatch(args: Omit<LiquidityMultisignCommon, 'action'> & {
+    nftTokenId: string | number;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+
+type UniswapV4PositionRow = {
+    tokenId: string;
+    positionManager: Address;
+    owner: Address;
+    name?: string;
+    symbol?: string;
+};
+type UniswapV4PositionScanProgress = {
+    latestBlock: string;
+    scanFromBlock: string;
+    scanningFromBlock: string;
+    scanningToBlock: string;
+    foundCount: number;
+    targetCount: number;
+};
+/**
+ * List v4 position NFT tokenIds owned by `walletAddress` via Position Manager Transfer logs.
+ * Uses small `eth_getLogs` chunks (default 200 blocks) and scans backward so wallets with
+ * few positions finish without walking full chain history.
+ */
+declare function listUniswapV4PositionsForWallet(args: {
+    chainId: number;
+    rpcUrl: string;
+    walletAddress: Address | string;
+    positionManagerAddress?: Address | string;
+    fromBlock?: bigint;
+    maxBlocksToScan?: bigint;
+    chunkSize?: bigint;
+    onProgress?: (progress: UniswapV4PositionScanProgress) => void;
+    signal?: AbortSignal;
+}): Promise<UniswapV4PositionRow[]>;
+
+type SwapExactInputArgs = {
+    keyGen: KeyGenSubsetForPermit;
+    purposeText: string;
+    chainId: number;
+    rpcUrl: string;
+    executorAddress: Address;
+    chainDetail: EvmChainDetail;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    tokenIn: Address;
+    uniswapApiKey: string;
+    fullQuote: Record<string, unknown>;
+    slippagePercent?: number;
+    swapTransactionDeadlineUnix?: number;
+    baseUrl?: string;
+};
+/** Quote then build swap multisign body for EXACT_INPUT (caller must have fetched quote first for EXACT_OUTPUT). */
+declare function swapFromQuote(args: SwapExactInputArgs & {
+    swap: Awaited<ReturnType<typeof uniswapCreateSwap>>;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+declare function quoteSwap(args: Parameters<typeof uniswapTradeQuote>[0]): Promise<Record<string, unknown>>;
+declare function createSwap(args: Parameters<typeof uniswapCreateSwap>[0]): Promise<Awaited<ReturnType<typeof uniswapCreateSwap>>>;
+declare function swapExactInput(args: SwapExactInputArgs & {
+    tradeType?: UniswapQuoteTradeType;
+}): Promise<{
+    bodyForSign: Record<string, unknown>;
+    messageToSign: string;
+}>;
+
+interface UniswapLimitOrderQuoteParams {
+    amount: string;
+    tokenIn: string;
+    tokenOut: string;
+    limitPrice: string;
+    uniswapApiKey: string;
+    type: UniswapQuoteTradeType;
+    orderDeadline: number;
+    keyGen?: string;
+    swapper?: string;
+    managementNodeUrl?: string;
+    nodeReadAuth?: NodeReadAuth;
+    chainId?: string | number;
+    tokenInChainId?: string | number;
+    tokenOutChainId?: string | number;
+    baseUrl?: string;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * POST /v1/limit_order_quote — UniswapX limit order quote (mainnet only).
+ */
+declare function uniswapLimitOrderQuote(args: UniswapLimitOrderQuoteParams): Promise<Record<string, unknown>>;
+declare function fetchUniswapXLimitOrders(args: {
+    swapper: string;
+    chainId?: number;
+    uniswapApiKey?: string;
+    baseUrl?: string;
+    limit?: number;
+    fetchImpl?: typeof fetch;
+}): Promise<Record<string, unknown>>;
+declare function uniswapFetchLimitOrdersMcp(args: {
+    chainId?: number;
+    swapper?: string;
+    keyGen?: string;
+    managementNodeUrl?: string;
+    uniswapApiKey?: string;
+    limit?: number;
+    baseUrl?: string;
+    nodeReadAuth?: NodeReadAuth;
+    fetchImpl?: typeof fetch;
+}): Promise<Record<string, unknown>>;
+
+type UniswapLimitOrderMultisignMcpArgs = {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    purposeText: string;
+    fullLimitQuote: Record<string, unknown>;
+    executorAddress: Address;
+    uniswapApiKey: string;
+    tradeApiBaseUrl?: string;
+    expiryDate?: number;
+};
+/** MCP handler: enrichMultisignContext supplies executorAddress + keyGen. */
+declare function buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp(args: UniswapLimitOrderMultisignMcpArgs): Promise<MultisignBuildResult>;
+
+declare const uniswapV4ProtocolModule: ProtocolModule;
+
+declare const uniswapV4: {
+    quoteSwap: typeof quoteSwap;
+    createSwap: typeof createSwap;
+    swapExactInput: typeof swapExactInput;
+    swapFromQuote: typeof swapFromQuote;
+    buildSwapMultisignBody: typeof buildEvmMultisignBodyUniswapV4SkipPermit2Batch;
+    limitOrderQuote: typeof uniswapLimitOrderQuote;
+    buildLimitOrderMultisignBody: typeof buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp;
+    fetchLimitOrders: typeof fetchUniswapXLimitOrders;
+    fetchLimitOrdersMcp: typeof uniswapFetchLimitOrdersMcp;
+    quote: typeof uniswapTradeQuote;
+    createLiquidityPosition: typeof uniswapLpCreatePosition;
+    increaseLiquidityPosition: typeof uniswapLpIncreasePosition;
+    decreaseLiquidityPosition: typeof uniswapLpDecreasePosition;
+    claimLiquidityFees: typeof uniswapLpClaimFees;
+    buildMintLiquidityMultisignBody: typeof buildEvmMultisignBodyUniswapV4MintLiquidityBatch;
+    buildIncreaseLiquidityMultisignBody: typeof buildEvmMultisignBodyUniswapV4IncreaseLiquidityBatch;
+    buildDecreaseLiquidityMultisignBody: typeof buildEvmMultisignBodyUniswapV4DecreaseLiquidityBatch;
+    buildCollectFeesMultisignBody: typeof buildEvmMultisignBodyUniswapV4CollectFeesBatch;
+    listPositions: typeof listUniswapV4PositionsForWallet;
+    isChainSupported: typeof isUniswapV4ChainSupported;
+};
+
+declare function isCurveApiChainSupported(chainId: string | number | bigint | null | undefined): boolean;
+
+/** Live `@curvefi/api` instance with pools already fetched, plus the routing graph. */
+type CurveFullSession = {
+    /** Same reference used for getCoinsData / router; pools already loaded. */
+    curve: any;
+    adj: Map<string, Set<string>>;
+    swappableNodeKeys: ReadonlySet<string>;
+    wrappedNative: string | undefined;
+};
+/**
+ * One init + `fetchAllCurvePools` + graph build. Reuse this session for the asset list and the
+ * Curve dialog to avoid duplicating the Curve API work.
+ */
+declare function loadFullCurveSessionForRpc(rpcUrl: string): Promise<CurveFullSession>;
+
+/**
+ * Build `POST /multiSignRequest` body: optional ERC-20 approve(s) to the Curve router, then
+ * `CurveRouterNG.exchange` via `@curvefi/api` `router.populateSwap`.
+ */
+declare function buildEvmMultisignBodyCurveDaoBatch(args: {
+    keyGen: KeyGenSubsetForPermit;
+    chainId: number;
+    rpcUrl: string;
+    chainDetail: EvmChainDetail;
+    useCustomGas: boolean;
+    customGasChainDetails?: Record<string, unknown> | null;
+    tokenIn: Address;
+    tokenOut: string;
+    amountHuman: string;
+    slippagePercent: number;
+    executorAddress: Address;
+    purposeText: string;
+}): Promise<MultisignBuildResult>;
+
+declare const curveDaoProtocolModule: ProtocolModule;
+
+declare const curveDao: {
+    buildSwapMultisignBody: typeof buildEvmMultisignBodyCurveDaoBatch;
+    isChainSupported: typeof isCurveApiChainSupported;
+    loadSession: typeof loadFullCurveSessionForRpc;
+};
+
+declare const aerodromeProtocolModule: ProtocolModule;
+
+declare const pendleProtocolModule: ProtocolModule;
+
+export { type BuildEip712MultisignArgs, type BuildEip712MultisignLeg, type BuildPayloadSignEd25519MultisignBodyArgs, COINGECKO_PLATFORM_BY_CHAIN_ID, type ChainCategory, type ChainCategoryBuildInput, type ChainCategoryModule, type ChainSupportContext, type ConditionalApproveStep, DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS, DEFI_PROTOCOLS_WITH_30MIN_EXPIRY, EIP712_SIGN_REQUEST_KIND, type Eip712MultisignDelivery, type Eip712TypedDataField, type Eip712TypedDataPayload, type EvmBatchMetaBuilder, type EvmBuildBatchArgs, type EvmChainDetail, type EvmProtocolContext, type EvmTokenKind, type EvmTxStep, type KeyGenSubset, type KeyGenSubsetForPermit, type MultisignBuildResult, type MultisignCommonArgs, type MultisignLeg, NEAR_CHAIN_CATEGORY, type NearTokenKind, PAYLOAD_SIGN_ED25519_REQUEST_KIND, type ParamDoc, type PayloadSignEd25519Delivery, type ProtocolActionDescriptor, type ProtocolModule, SOLANA_CHAIN_CATEGORY, type SolanaTokenKind, type TokenRef, aerodromeProtocolModule, approveStepsToEvmTxSteps, buildConditionalErc20ApproveSteps, buildEip712Multisign, buildEvmMultisignBatch, buildPayloadSignEd25519MultisignBody, coingeckoPlatformForChainId, coreChainCategoryModule, curveDao, curveDaoProtocolModule, defiEvmTransport, defiMultisignExpiryUnixSeconds, evmChainCategoryModule, finalizeMultisign, getAaveGraphqlProxyUrl, getActionsByChainCategory, getCoingeckoProxyUrl, getDefiEvmRpcTransportFactory, getEulerGraphqlProxyUrl, getEulerV3ApiProxyBase, getJsonViaOptionalProxy, getMapleGraphqlProxyUrl, getMorphoGraphqlProxyUrl, getMorphoMidnightRestProxyUrl, getProtocolModule, getProtocolModules, isEvmNativeToken, matchEvmTokenKind, mergePurposeText, nearChainCategoryModule, normalizeCurveRouterAmountString, normalizeHumanDecimalAmount, parseEvmChainIdToNumber, pendleProtocolModule, postJsonViaOptionalProxy, publicClientForRpc, registerProtocolModule, resolveErc20Decimals, routerSwapGasLimitFromEstimate, setAaveGraphqlProxyUrl, setCoingeckoProxyUrl, setDefiEvmRpcTransportFactory, setEulerGraphqlProxyUrl, setEulerV3ApiProxyBase, setMapleGraphqlProxyUrl, setMorphoGraphqlProxyUrl, setMorphoMidnightRestProxyUrl, solanaChainCategoryModule, uniswapV4, uniswapV4ProtocolModule };