@continuumdao/ctm-mpc-defi 0.1.3

package/dist/index.js

@@ -0,0 +1,2446 @@
+import { getAddress, zeroAddress, defineChain, createPublicClient, http, formatUnits, parseGwei, serializeTransaction, keccak256, encodeFunctionData, erc20Abi, parseAbi, parseUnits, decodeFunctionData, isAddress } from 'viem';
+
+// src/core/keygen.ts
+function firstClientIdFromKeyGen(data) {
+  const map = data?.ClientKeys;
+  if (!map || typeof map !== "object") return null;
+  for (const v of Object.values(map)) {
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  return null;
+}
+function requirePubKeyHex(keyGen) {
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  return ph;
+}
+function keyListFromKeyGen(keyGen) {
+  return keyGen.keylist ?? [];
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = purposeText.trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = firstClientIdFromKeyGen(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+var coreChainCategoryModule = {
+  category: "evm",
+  finalizeMultisign
+};
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+function getProtocolModules() {
+  return modules;
+}
+function getProtocolModule(id) {
+  return modules.find((m) => m.id === id);
+}
+function getActionsByChainCategory(category) {
+  return modules.filter((m) => m.chainCategory === category).flatMap((m) => m.actions);
+}
+
+// src/core/nodeRead.ts
+function nodeFetchWithReadAuth(url, init, auth) {
+  const method = (init?.method ?? "GET").toUpperCase();
+  const headers = new Headers(init?.headers);
+  if (auth.bearerOnGet && method === "GET" && auth.jwt && auth.jwt.trim()) {
+    headers.set("Authorization", `Bearer ${auth.jwt.trim()}`);
+  }
+  return fetch(url, { ...init, headers });
+}
+function isEvmNativeToken(address) {
+  try {
+    return getAddress(address) === zeroAddress;
+  } catch {
+    return address.toLowerCase() === zeroAddress;
+  }
+}
+function matchEvmTokenKind(kind, address) {
+  if (kind === "native") return isEvmNativeToken(address);
+  if (kind === "erc20" || kind === "ctmerc20" || kind === "ctmrwa1") {
+    return !isEvmNativeToken(address);
+  }
+  return true;
+}
+
+// src/chains/evm/txParams.ts
+function gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit) {
+  if (chainGasLimit == null || !Number.isFinite(chainGasLimit) || chainGasLimit <= 0) {
+    return estimatedGas;
+  }
+  const cfg = BigInt(Math.floor(chainGasLimit));
+  return cfg > estimatedGas ? cfg : estimatedGas;
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+function composeFeePayloadToTxParams(p, legacy) {
+  const gl = p.txGasLimit ?? p.txgaslimit;
+  if (gl == null || String(gl).trim() === "") return void 0;
+  const n = p.txNonce ?? p.txnonce;
+  let nonce = 0;
+  if (typeof n === "bigint") nonce = Number(n);
+  else if (typeof n === "number") nonce = n;
+  else if (n != null) nonce = parseInt(String(n), 10);
+  if (!Number.isFinite(nonce)) nonce = 0;
+  const gasLimit = String(gl);
+  if (legacy) {
+    const gp = p.txGasPrice ?? p.txgasprice;
+    return {
+      nonce,
+      gasLimit,
+      txType: "legacy",
+      gasPrice: gp != null ? String(gp) : "0"
+    };
+  }
+  return {
+    nonce,
+    gasLimit,
+    txType: "eip1559",
+    maxFeePerGas: String(p.txMaxFeePerGas ?? ""),
+    maxPriorityFeePerGas: String(p.txMaxPriorityFeePerGas ?? "")
+  };
+}
+function triggerTxParamsFromComposeBody(body) {
+  const existing = body.txParams;
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    const o = existing;
+    if (String(o.gasLimit ?? "").trim() !== "") {
+      return { ...o };
+    }
+  }
+  const pb = body.proposalTxParams;
+  if (Array.isArray(pb) && pb.length > 0 && typeof pb[0] === "object" && pb[0] !== null) {
+    const first = pb[0];
+    if (String(first.gasLimit ?? "").trim() !== "") {
+      return { ...first };
+    }
+  }
+  const fromSnapshot = composeFeePayloadToTxParams(
+    body,
+    body.txMaxFeePerGas == null && body.txMaxPriorityFeePerGas == null
+  );
+  if (fromSnapshot) return fromSnapshot;
+  return {
+    nonce: 0,
+    gasLimit: "",
+    txType: "legacy",
+    gasPrice: "0"
+  };
+}
+function proposalTxParamsToFeeSnapshot(params) {
+  if (params.txType === "legacy") {
+    return {
+      txNonce: params.nonce,
+      txGasLimit: params.gasLimit,
+      txGasPrice: params.gasPrice ?? "0"
+    };
+  }
+  return {
+    txNonce: params.nonce,
+    txGasLimit: params.gasLimit,
+    txMaxFeePerGas: params.maxFeePerGas ?? "",
+    txMaxPriorityFeePerGas: params.maxPriorityFeePerGas ?? ""
+  };
+}
+async function fetchChainFeeParams(rpcUrl, chainId) {
+  const url = rpcUrl.trim();
+  if (!url) return { isEip1559: false };
+  const chainIdNum = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
+  if (Number.isNaN(chainIdNum)) return { isEip1559: false };
+  const chain = defineChain({
+    id: chainIdNum,
+    name: "Discovery",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [url] } }
+  });
+  const publicClient = createPublicClient({
+    chain,
+    transport: http(url)
+  });
+  const getGasPriceGwei = async () => {
+    const gasPriceWei = await publicClient.getGasPrice();
+    return parseFloat(formatUnits(gasPriceWei, 9));
+  };
+  try {
+    const block = await publicClient.getBlock({ blockTag: "latest" });
+    const baseFeePerGas = block?.baseFeePerGas;
+    if (baseFeePerGas == null || baseFeePerGas === void 0) {
+      const gasPriceGwei2 = await getGasPriceGwei();
+      return { isEip1559: false, gasPriceGwei: gasPriceGwei2 };
+    }
+    const baseFeeGwei = parseFloat(formatUnits(baseFeePerGas, 9));
+    let priorityFeeGwei;
+    try {
+      const priorityWei = await publicClient.estimateMaxPriorityFeePerGas();
+      priorityFeeGwei = parseFloat(formatUnits(priorityWei, 9));
+    } catch {
+    }
+    const gasPriceGwei = await getGasPriceGwei();
+    return {
+      isEip1559: true,
+      baseFeeGwei,
+      priorityFeeGwei,
+      gasPriceGwei
+    };
+  } catch {
+    try {
+      const gasPriceWei = await publicClient.getGasPrice();
+      const gasPriceGwei = parseFloat(formatUnits(gasPriceWei, 9));
+      return { isEip1559: false, gasPriceGwei };
+    } catch {
+      return { isEip1559: false };
+    }
+  }
+}
+function finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, floor, baseWei) {
+  let maxP = maxPriorityFeePerGas;
+  let maxF = maxFeePerGas;
+  if (baseWei > 0n && maxF < baseWei + maxP) {
+    maxF = baseWei + maxP + parseGwei("0.001");
+  }
+  if (maxF < maxP) {
+    maxF = baseWei > 0n ? baseWei + maxP + parseGwei("0.001") : maxP * 2n;
+  }
+  return { maxFeePerGas: maxF, maxPriorityFeePerGas: maxP };
+}
+function alignEip1559FeesWithLatestBase(maxFeePerGas, maxPriorityFeePerGas, latestBlockBaseFeeWei) {
+  return finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, null, latestBlockBaseFeeWei);
+}
+function gweiToDecimalString(n) {
+  if (!Number.isFinite(n)) return "0";
+  if (n === 0) return "0";
+  const s = String(n);
+  if (s.indexOf("e") !== -1 || s.indexOf("E") !== -1) return n.toFixed(9).replace(/\.?0+$/, "") || "0";
+  return s;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = getAddress(executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    try {
+      estimatedGas = await publicClient.estimateGas({
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        account: executor
+      });
+    } catch {
+      estimatedGas = step.fallbackGas ?? 100000n;
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+var evmChainCategoryModule = {
+  category: "evm",
+  finalizeMultisign,
+  buildEvmMultisignBatch
+};
+
+// src/chains/evm/fees/customGas.ts
+function chainSnapshotForCustomGasExtraJSON(chainDetail) {
+  const lr = chainDetail.legacy;
+  const legacy = lr === true || typeof lr === "string" && lr.toLowerCase() === "true";
+  const push = (o, key, v) => {
+    if (v === void 0 || v === null) return;
+    if (typeof v === "string" && v.trim() === "") return;
+    o[key] = v;
+  };
+  const fields = {};
+  push(fields, "gasLimit", chainDetail.gasLimit);
+  if (legacy) {
+    push(fields, "gasMultiplier", chainDetail.gasMultiplier);
+    push(fields, "gasPrice", chainDetail.gasPrice);
+  } else {
+    push(fields, "gasMultiplier", chainDetail.gasMultiplier);
+    push(fields, "baseFee", chainDetail.baseFee);
+    push(fields, "priorityFee", chainDetail.priorityFee);
+    push(fields, "baseFeeMultiplier", chainDetail.baseFeeMultiplier);
+  }
+  push(fields, "legacy", legacy);
+  return fields;
+}
+
+// src/chains/evm/chainIdParse.ts
+function parseEvmChainIdToNumber(chainId) {
+  if (chainId == null) return Number.NaN;
+  if (typeof chainId === "bigint") {
+    const n = Number(chainId);
+    return Number.isSafeInteger(n) && n >= 0 ? n : Number.NaN;
+  }
+  if (typeof chainId === "number") {
+    return Number.isInteger(chainId) && chainId >= 0 ? chainId : Number.NaN;
+  }
+  const t = String(chainId).trim();
+  if (!t) return Number.NaN;
+  const low = t.toLowerCase();
+  if (low.startsWith("eip155:")) {
+    const rest = t.slice("eip155:".length).trim();
+    const n = Number.parseInt(rest, 10);
+    return Number.isNaN(n) || n < 0 ? Number.NaN : n;
+  }
+  if (low.startsWith("0x")) {
+    return Number.parseInt(t, 16);
+  }
+  return Number.parseInt(t, 10);
+}
+
+// src/chains/solana/types.ts
+var solanaChainCategoryModule = {
+  category: "solana"
+};
+
+// src/chains/solana/index.ts
+var SOLANA_CHAIN_CATEGORY = "solana";
+
+// src/chains/near/types.ts
+var nearChainCategoryModule = {
+  category: "near"
+};
+
+// src/chains/near/index.ts
+var NEAR_CHAIN_CATEGORY = "near";
+var PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+var UNIVERSAL_ROUTER_SPENDER = {
+  1: "0x66a9893cc07d91d95644aedd05d03f95e1dba8af",
+  5: "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+  11155111: "0x3a9d48ab9751398bbfa63ad67599bb04e4bdf98b",
+  137: "0x1095692a6237d83c6a72f3f5efedb9a670c49223",
+  80001: "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+  10: "0x851116d9223fabed8e56c0e6b8ad0c31d98b3507",
+  420: "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+  42161: "0xa51afafe0263b40edaef0df8781ea9aa03e381a3",
+  421613: "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+  42220: "0xcb695bc5D3Aa22cAD1E6DF07801b061a05A0233A",
+  44787: "0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD",
+  56: "0x1906c1d672b88cd1b9ac7593301ca990f94eae07",
+  43114: "0x94b75331ae8d42c1b61065089b7d48fe14aa73b7",
+  84531: "0xd0872d928672ae2ff74bdb2f5130ac12229cafaf",
+  8453: "0x6fF5693b99212da76ad316178a184ab56d299b43",
+  81457: "0xeabbcb3e8e415306207ef514f660a3f820025be3",
+  7777777: "0x3315ef7ca28db74abadc6c44570efdf06b04b020",
+  324: "0x28731BCC616B5f51dD52CF2e4dF0E78dD1136C06",
+  480: "0x8ac7bee993bb44dab564ea4bc9ea67bf9eb5e743",
+  1301: "0xf70536b3bcc1bd1a972dc186a2cf84cc6da6be5d",
+  130: "0xef740bf23acae26f6492b10de645d6b98dc8eaf3",
+  10143: "0x3ae6d8a282d67893e17aa70ebffb33ee5aa65893",
+  84532: "0x492e6456d9528771018deb9e87ef7750ef184104",
+  1868: "0x0e2850543f69f678257266e0907ff9a58b3f13de",
+  143: "0x0d97dc33264bfc1c226207428a79b26757fb9dc3",
+  59144: "0x661e93cca42afacb172121ef892830ca3b70f08d",
+  4217: "0x1febb76be10aaf3a1402f04e8e835f2c382f7914",
+  196: "0x5507749f2c558bb3e162c6e90c314c092e7372ff"
+};
+function isUniswapV4ChainSupported(chainId) {
+  if (chainId == null) return false;
+  const n = parseEvmChainIdToNumber(chainId);
+  if (Number.isNaN(n) || n < 0) return false;
+  const a = UNIVERSAL_ROUTER_SPENDER[n];
+  return typeof a === "string" && a.startsWith("0x");
+}
+function getUniswapUniversalRouterSpenderOrThrow(chainId) {
+  const raw = UNIVERSAL_ROUTER_SPENDER[chainId];
+  if (!raw || !raw.startsWith("0x")) {
+    throw new Error(
+      `No Uniswap Universal Router (spender) is configured for chainId ${chainId}. Add this chain to uniswap-v4/constants or use a chain supported by the Uniswap SDK.`
+    );
+  }
+  return getAddress(raw);
+}
+var MAX_UINT160 = (1n << 160n) - 1n;
+var MAX_UINT48 = (1n << 48n) - 1n;
+var UNISWAP_UNIVERSAL_ROUTER_DEFAULT_GAS_UNITS = 1500000n;
+var UNISWAP_TRADE_BASE_DEFAULT = "https://trade-api.gateway.uniswap.org/v1";
+var UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT = "2.0";
+var UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES = 30;
+var DEFAULT_TRADE_BASE = "https://trade-api.gateway.uniswap.org/v1";
+var UNISWAP_QUOTE_HEADERS_BASE = {
+  "Content-Type": "application/json",
+  "User-Agent": "ctm-mpc-defi uniswapTradeQuote/1.0 (TS)"
+};
+function parseUniswapChainId(value) {
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw new TypeError("chainId number must be a non-negative integer");
+    }
+    return value;
+  }
+  const t = value.trim();
+  if (t.toLowerCase().startsWith("0x")) {
+    return Number.parseInt(t, 16);
+  }
+  return Number.parseInt(t, 10);
+}
+function trimAddr(a) {
+  return a.trim();
+}
+function isUniswapTokenInAddressNative(tokenIn) {
+  const t = (tokenIn ?? "").toString().trim();
+  if (!t) return false;
+  try {
+    return getAddress(t) === zeroAddress;
+  } catch {
+    return t.toLowerCase() === "0x0000000000000000000000000000000000000000";
+  }
+}
+function isUniswapFullQuoteResponseNativeIn(stored) {
+  if (!stored) return false;
+  const q = stored.quote;
+  if (!q || typeof q !== "object" || Array.isArray(q)) return false;
+  const input = q.input;
+  if (!input) return false;
+  const raw = (input.address ?? input.token ?? "").toString().trim();
+  return isUniswapTokenInAddressNative(raw);
+}
+async function fetchEthereumAddressForKeyGen(managementNodeUrl, keyGenId, readAuth = { bearerOnGet: true, jwt: null }, init) {
+  const base = managementNodeUrl.trim().replace(/\/$/, "");
+  if (!base) {
+    throw new Error("managementNodeUrl is required to resolve keyGen");
+  }
+  const id = (keyGenId || "").trim();
+  if (!id) {
+    throw new Error("keyGen is required");
+  }
+  const url = `${base}/getKeyGenResultById?id=${encodeURIComponent(id)}`;
+  const res = await nodeFetchWithReadAuth(url, { ...init, method: "GET", cache: "no-store" }, readAuth);
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    throw new Error(
+      `getKeyGenResultById HTTP ${res.status}: ${t || res.statusText}`.trim()
+    );
+  }
+  const raw = await res.json();
+  const d = raw.Data ?? raw.data;
+  const eth = d?.ethereumaddress;
+  if (typeof eth !== "string" || !eth.trim()) {
+    throw new Error("getKeyGenResultById: ethereumaddress missing for this keyGen");
+  }
+  return eth.trim();
+}
+function resolveInputChainId(p) {
+  if (p.chainId !== void 0 && p.chainId !== null && String(p.chainId).trim() !== "") {
+    return p.chainId;
+  }
+  if (p.tokenInChainId !== void 0 && p.tokenInChainId !== null && String(p.tokenInChainId).trim() !== "") {
+    return p.tokenInChainId;
+  }
+  if (p.tokenOutChainId !== void 0 && p.tokenOutChainId !== null && String(p.tokenOutChainId).trim() !== "") {
+    return p.tokenOutChainId;
+  }
+  throw new Error("Set chainId, tokenInChainId, or tokenOutChainId (same-chain) for the input side");
+}
+function buildUniswapQuoteRequestBody(args) {
+  const cIn = parseUniswapChainId(resolveInputChainId(args));
+  const cOut = args.tokenOutChainId !== void 0 && args.tokenOutChainId !== null && String(args.tokenOutChainId).trim() !== "" ? parseUniswapChainId(args.tokenOutChainId) : cIn;
+  const body = {
+    type: args.type,
+    amount: String(args.amount).trim(),
+    tokenInChainId: cIn,
+    tokenOutChainId: cOut,
+    tokenIn: trimAddr(args.tokenIn),
+    tokenOut: trimAddr(args.tokenOut),
+    swapper: trimAddr(args.swapper)
+  };
+  if (args.slippage !== void 0 && args.slippage !== null && String(args.slippage).trim() !== "") {
+    const s = typeof args.slippage === "number" ? args.slippage : Number.parseFloat(String(args.slippage).trim());
+    if (Number.isNaN(s)) {
+      throw new TypeError("slippage must be a number or a numeric string");
+    }
+    body.slippageTolerance = s;
+  } else {
+    body.autoSlippage = "DEFAULT";
+  }
+  return body;
+}
+function errorMessageFromUniswapJsonBody(value) {
+  if (value == null) return null;
+  if (typeof value === "string") {
+    const t = value.trim();
+    return t || null;
+  }
+  if (typeof value !== "object") return null;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return null;
+    return errorMessageFromUniswapJsonBody(value[0]);
+  }
+  const o = value;
+  if (typeof o.detail === "string" && o.detail.trim()) {
+    const base = o.detail.trim();
+    const code = typeof o.errorCode === "string" && o.errorCode.trim() ? o.errorCode.trim() : "";
+    const req = typeof o.requestId === "string" && o.requestId.trim() ? o.requestId.trim() : "";
+    if (code) {
+      return req ? `${base} (${code}) [${req}]` : `${base} (${code})`;
+    }
+    return req ? `${base} [${req}]` : base;
+  }
+  if (typeof o.errorCode === "string" && o.errorCode.trim()) {
+    return o.errorCode.trim();
+  }
+  for (const k of ["message", "detail", "description", "title", "reason"]) {
+    const v = o[k];
+    if (typeof v === "string" && v.trim()) return v.trim();
+  }
+  if (typeof o.error === "string" && o.error.trim()) return o.error.trim();
+  if (o.error != null && typeof o.error === "object") {
+    const inner = errorMessageFromUniswapJsonBody(o.error);
+    if (inner) return inner;
+  }
+  if (Array.isArray(o.errors) && o.errors.length > 0) {
+    const inner = errorMessageFromUniswapJsonBody(o.errors[0]);
+    if (inner) return inner;
+  }
+  if (typeof o.code === "string" && o.code.trim()) return o.code.trim();
+  return null;
+}
+function bodyLooksLikeHtml(t) {
+  const s = t.slice(0, 256).trimStart();
+  return s.startsWith("<!") || s.toLowerCase().startsWith("<html");
+}
+function titleFromHtml(t) {
+  const m = t.match(/<title[^>]*>([^<]+)<\/title>/i);
+  if (!m?.[1]) return null;
+  const s = m[1].replace(/\s+/g, " ").trim();
+  return s || null;
+}
+function messageFromUniswapHttpResponseBody(text, status, statusText = "") {
+  const raw = (text ?? "").trim();
+  const st = (statusText ?? "").trim();
+  if (!raw) {
+    if (status > 0) {
+      return st ? `HTTP ${status} (${st})` : `HTTP ${status}`;
+    }
+    return "Empty response";
+  }
+  if (bodyLooksLikeHtml(raw)) {
+    const title = titleFromHtml(raw);
+    if (title) {
+      return status > 0 ? `HTTP ${status}: ${title}` : title;
+    }
+    return status > 0 ? "HTTP " + String(status) + ": response was not JSON (HTML or error page). Check API key, token pair, and network." : "Response was not JSON (HTML or error page).";
+  }
+  const forParse = raw.replace(/^\uFEFF/, "");
+  try {
+    const j = JSON.parse(forParse);
+    if (j && typeof j === "object") {
+      const msg = errorMessageFromUniswapJsonBody(j);
+      if (msg) {
+        if (status >= 400) {
+          return st ? `${msg} (HTTP ${status} ${st})` : `${msg} (HTTP ${status})`;
+        }
+        return msg;
+      }
+    }
+  } catch {
+  }
+  const oneLine = raw.replace(/\s+/g, " ").trim();
+  const short = oneLine.length > 500 ? `${oneLine.slice(0, 500)}\u2026` : oneLine;
+  if (status > 0) {
+    return st && !short ? `HTTP ${status} (${st})` : st ? `HTTP ${status}: ${short} (${st})` : `HTTP ${status}: ${short}`;
+  }
+  return short;
+}
+async function uniswapTradeQuote(args) {
+  const apiKey = (args.uniswapApiKey || "").trim();
+  if (!apiKey) {
+    throw new Error("uniswapApiKey (x-api-key) is required");
+  }
+  const keyGen = (args.keyGen || "").trim();
+  let swapper;
+  if ((args.swapper || "").trim()) {
+    swapper = trimAddr(args.swapper);
+  } else {
+    if (!keyGen) {
+      throw new Error("keyGen is required when swapper is not provided");
+    }
+    const mpc = (args.managementNodeUrl || "").trim();
+    if (!mpc) {
+      throw new Error("managementNodeUrl is required when swapper is not provided (to resolve keyGen)");
+    }
+    swapper = await fetchEthereumAddressForKeyGen(
+      mpc,
+      keyGen,
+      args.nodeReadAuth ?? { bearerOnGet: true, jwt: null }
+    );
+  }
+  const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : DEFAULT_TRADE_BASE;
+  const quoteUrl = `${base}/quote`;
+  const urv = args.universalRouterVersion && args.universalRouterVersion.trim() || "2.0";
+  const body = buildUniswapQuoteRequestBody({ ...args, swapper });
+  const nativeIn = isUniswapTokenInAddressNative(args.tokenIn);
+  const headers = {
+    ...UNISWAP_QUOTE_HEADERS_BASE,
+    "x-api-key": apiKey,
+    "x-universal-router-version": urv,
+    "x-permit2-disabled": args.permit2Disabled === true ? "true" : "false",
+    /** Native (0x0) as token in: Trade API needs this for classic routes and payable /swap. */
+    "x-erc20eth-enabled": nativeIn ? "true" : "false"
+  };
+  const fetchFn = args.fetchImpl ?? globalThis.fetch;
+  const res = await fetchFn(quoteUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: args.signal
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(messageFromUniswapHttpResponseBody(text, res.status, res.statusText));
+  }
+  const forParse = text.replace(/^\uFEFF/, "");
+  try {
+    return JSON.parse(forParse);
+  } catch {
+    throw new Error(
+      `Trade API: ${messageFromUniswapHttpResponseBody(text, res.status, res.statusText)}`
+    );
+  }
+}
+function parseUniswapQuoteClassicInOut(res) {
+  const inner = res.quote;
+  if (!inner || typeof inner !== "object" || Array.isArray(inner)) return null;
+  const q = inner;
+  const input = q.input;
+  const output = q.output;
+  const inAm = input?.amount;
+  const outAm = output?.amount;
+  if (typeof inAm !== "string" || !inAm || typeof outAm !== "string" || !outAm) return null;
+  try {
+    return { inputWei: BigInt(inAm), outputWei: BigInt(outAm) };
+  } catch {
+    return null;
+  }
+}
+function parseOptionalGasLimitString(raw) {
+  if (raw == null) return null;
+  const s = String(raw).trim();
+  if (!s) return null;
+  try {
+    if (/^0x[0-9a-fA-F]+$/.test(s)) return BigInt(s);
+    return BigInt(s);
+  } catch {
+    return null;
+  }
+}
+var DEFAULT_UNIVERSAL_ROUTER_GAS_FALLBACK = UNISWAP_UNIVERSAL_ROUTER_DEFAULT_GAS_UNITS;
+function swapTransactionDeadlineUnixFromExpiryMinutes(expiryMinutes, nowSec = Math.floor(Date.now() / 1e3)) {
+  const m = Number.isFinite(expiryMinutes) && expiryMinutes > 0 ? expiryMinutes : UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES;
+  return nowSec + Math.floor(m * 60);
+}
+function swapDeadlineUnixSeconds(args) {
+  const now = Math.floor(Date.now() / 1e3);
+  if (args.swapTransactionDeadlineUnix != null && Number.isFinite(args.swapTransactionDeadlineUnix) && args.swapTransactionDeadlineUnix > now) {
+    return Math.floor(args.swapTransactionDeadlineUnix);
+  }
+  return swapTransactionDeadlineUnixFromExpiryMinutes(UNISWAP_SWAP_DEFAULT_EXPIRY_MINUTES, now);
+}
+function getClassicQuoteFromStoredUniswapResponse(stored) {
+  if (!stored) return null;
+  const q = stored.quote;
+  return q != null && typeof q === "object" ? q : null;
+}
+async function uniswapCreateSwap(args) {
+  const deadline = swapDeadlineUnixSeconds(args);
+  const useProxy = args.useServerProxy !== false && typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
+  if (useProxy) {
+    const proxyPayload = {
+      uniswapApiKey: args.uniswapApiKey,
+      fullQuoteFromPermit: args.fullQuoteFromPermit,
+      universalRouterVersion: args.universalRouterVersion,
+      baseUrl: args.baseUrl,
+      swapTransactionDeadlineUnix: deadline
+    };
+    const res2 = await (args.fetchImpl ?? globalThis.fetch)("/api/uniswap/swap", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(proxyPayload),
+      credentials: "same-origin"
+    });
+    const text2 = await res2.text();
+    if (!res2.ok) {
+      let errMsg = res2.statusText;
+      try {
+        const j = JSON.parse(text2);
+        if (j && typeof j.error === "string" && j.error.trim()) errMsg = j.error.trim();
+      } catch {
+        if (text2.trim()) errMsg = text2.slice(0, 500);
+      }
+      throw new Error(`Uniswap swap proxy failed: ${errMsg}`);
+    }
+    const parsed2 = JSON.parse(text2);
+    if (!parsed2?.swap || typeof parsed2.swap !== "object") {
+      throw new Error("Uniswap /swap (proxy): missing `swap` in response.");
+    }
+    return parsed2;
+  }
+  const base = (args.baseUrl ?? UNISWAP_TRADE_BASE_DEFAULT).replace(/\/$/, "");
+  const url = `${base}/swap`;
+  const classic = getClassicQuoteFromStoredUniswapResponse(args.fullQuoteFromPermit);
+  if (!classic) {
+    throw new Error("Stored Uniswap quote is missing a classic `quote` object; cannot build swap calldata.");
+  }
+  const body = {
+    quote: classic,
+    deadline
+  };
+  const urv = (args.universalRouterVersion ?? UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT).trim() || "2.0";
+  const fn = args.fetchImpl ?? globalThis.fetch;
+  const nativeIn = isUniswapFullQuoteResponseNativeIn(args.fullQuoteFromPermit);
+  const res = await fn(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": args.uniswapApiKey.trim(),
+      "x-universal-router-version": urv,
+      "x-erc20eth-enabled": nativeIn ? "true" : "false",
+      "x-permit2-disabled": "true"
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(
+      `Uniswap POST /swap failed: ${messageFromUniswapHttpResponseBody(text, res.status, res.statusText)}`
+    );
+  }
+  const parsed = JSON.parse(text);
+  if (!parsed?.swap || typeof parsed.swap !== "object") {
+    throw new Error("Uniswap /swap: missing `swap` in response.");
+  }
+  return parsed;
+}
+var permit2ApproveRouterAbi = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint160" },
+      { name: "expiration", type: "uint48" }
+    ],
+    outputs: []
+  }
+];
+var uniswapDispatchExecuteAbi = [
+  {
+    name: "execute",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      { name: "router", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "commands", type: "bytes" },
+      { name: "inputs", type: "bytes[]" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+function parseSwapTxValueWei(swap) {
+  const raw = swap.value ?? swap.Value;
+  if (raw == null || raw === "") return 0n;
+  if (typeof raw === "bigint") return raw > 0n ? raw : 0n;
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    try {
+      return BigInt(Math.max(0, Math.trunc(raw)));
+    } catch {
+      return 0n;
+    }
+  }
+  const s = String(raw).trim();
+  if (!s) return 0n;
+  try {
+    if (/^0x[0-9a-fA-F]+$/.test(s)) return BigInt(s);
+    return BigInt(s.replace(/^0x/i, ""));
+  } catch {
+    return 0n;
+  }
+}
+function nativeEthInPayableValueWei(args) {
+  const fromApi = parseSwapTxValueWei(args.swap);
+  if (fromApi > 0n) return fromApi;
+  try {
+    const d = decodeFunctionData({ abi: uniswapDispatchExecuteAbi, data: args.dataHex });
+    if (d.functionName === "execute") {
+      const rawAmt = d.args[2];
+      const amount = typeof rawAmt === "bigint" ? rawAmt : BigInt(String(rawAmt));
+      if (amount > 0n) return amount;
+    }
+  } catch {
+  }
+  return args.quoteInputWei > 0n ? args.quoteInputWei : 0n;
+}
+function applySlippagePercentToApproveWei(baseWei, slippagePercent) {
+  if (baseWei <= 0n) return baseWei;
+  const s = slippagePercent == null ? NaN : Number(slippagePercent);
+  if (!Number.isFinite(s) || s <= 0) return baseWei;
+  const bps = Math.min(1e5, Math.round(s * 100));
+  if (bps <= 0) return baseWei;
+  return (baseWei * BigInt(1e4 + bps) + 9999n) / 10000n;
+}
+function permit2SpenderAndApproveWeiFromSwapCalldata(dataHex, tokenIn, quoteInputWei, chainId) {
+  const canonical = getUniswapUniversalRouterSpenderOrThrow(chainId);
+  try {
+    const d = decodeFunctionData({ abi: uniswapDispatchExecuteAbi, data: dataHex });
+    if (d.functionName !== "execute") {
+      return { permit2Spender: canonical, approveWei: quoteInputWei, calldataAmountWei: null };
+    }
+    const router = getAddress(d.args[0]);
+    const token = getAddress(d.args[1]);
+    const rawAmt = d.args[2];
+    const amount = typeof rawAmt === "bigint" ? rawAmt : BigInt(String(rawAmt));
+    if (token.toLowerCase() !== tokenIn.toLowerCase()) {
+      throw new Error(
+        `Swap calldata token ${token} does not match token in ${tokenIn}. Refresh quote and /swap.`
+      );
+    }
+    const calldataAmountWei = amount > 0n ? amount : null;
+    let approveWei = quoteInputWei;
+    if (calldataAmountWei != null && calldataAmountWei > approveWei) {
+      approveWei = calldataAmountWei;
+    }
+    return { permit2Spender: router, approveWei, calldataAmountWei };
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("does not match token")) throw e;
+    return { permit2Spender: canonical, approveWei: quoteInputWei, calldataAmountWei: null };
+  }
+}
+async function buildEvmMultisignBodyUniswapV4NativeInOnly(args, quoteInputWei) {
+  const ph = (args.keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = args.keyGen.keylist ?? [];
+  const clientId = firstClientIdFromKeyGen(args.keyGen);
+  const toRouter = getAddress(
+    (args.swap.to ?? "").trim().startsWith("0x") ? args.swap.to.trim() : `0x${args.swap.to.trim()}`
+  );
+  const dataHex = (() => {
+    const d = (args.swap.data ?? "0x").toString().trim();
+    return d.startsWith("0x") ? d : `0x${d}`;
+  })();
+  const valueWei = nativeEthInPayableValueWei({
+    swap: args.swap,
+    dataHex,
+    quoteInputWei
+  });
+  if (valueWei <= 0n) {
+    throw new Error(
+      "Native (ETH) in swap: could not determine payable value (no `swap.value`, no `execute` amount in calldata, and quote input is zero). Refresh the quote and request /swap again."
+    );
+  }
+  const ch = defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const feeParams = await fetchChainFeeParams(args.rpcUrl, args.chainId);
+  const legacy = Boolean(args.chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWeiNativeIn = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const useCustomGas = args.useCustomGas;
+  const chainGasLimitRouter = args.chainDetail?.gasLimit != null && Number.isFinite(Number(args.chainDetail.gasLimit)) && Number(args.chainDetail.gasLimit) > 0 ? Number(args.chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && args.chainDetail?.gasMultiplier != null ? Number(args.chainDetail.gasMultiplier) : void 0;
+  const nonce = await publicClient.getTransactionCount({ address: args.executorAddress, blockTag: "pending" });
+  const proposalTxParamsBatch = [];
+  const messageHashes = [];
+  const messageRawBatch = [];
+  const swapRecord = args.swap;
+  const fromTradeApi = parseOptionalGasLimitString(swapRecord.gasLimit) ?? parseOptionalGasLimitString(swapRecord.gas);
+  let gasBuildSource = "rpcEstimate";
+  let estimateGasError;
+  let baseGasUnits1;
+  if (fromTradeApi != null && fromTradeApi > 0n) {
+    baseGasUnits1 = fromTradeApi;
+    gasBuildSource = "tradeApi";
+  } else {
+    try {
+      baseGasUnits1 = await publicClient.estimateGas({
+        to: toRouter,
+        data: dataHex,
+        value: valueWei,
+        account: args.executorAddress
+      });
+      gasBuildSource = "rpcEstimate";
+    } catch (e) {
+      estimateGasError = e instanceof Error ? e.message : String(e);
+      const minRouterGas = 500000n;
+      if (useCustomGas) {
+        const cfg = args.chainDetail?.gasLimit != null ? parseOptionalGasLimitString(String(args.chainDetail.gasLimit)) : null;
+        if (cfg != null && cfg >= minRouterGas) {
+          baseGasUnits1 = cfg;
+        } else {
+          baseGasUnits1 = DEFAULT_UNIVERSAL_ROUTER_GAS_FALLBACK;
+        }
+      } else {
+        baseGasUnits1 = DEFAULT_UNIVERSAL_ROUTER_GAS_FALLBACK;
+      }
+      gasBuildSource = "estimateFailedFallback";
+    }
+  }
+  const gasLimit1 = routerSwapGasLimitFromEstimate(baseGasUnits1, chainGasLimitRouter);
+  const currentNonce0 = nonce;
+  let firstTxFeePayload = {};
+  if (legacy) {
+    let gasPriceWei1 = await publicClient.getGasPrice();
+    if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+      gasPriceWei1 = gasPriceWei1 * BigInt(100 + gasFeeMultiplier) / 100n;
+    }
+    if (useCustomGas && args.chainDetail?.gasPrice != null && args.chainDetail.gasPrice > 0) {
+      const configured = parseGwei(gweiToDecimalString(Number(args.chainDetail.gasPrice)));
+      if (configured > gasPriceWei1) gasPriceWei1 = configured;
+    }
+    firstTxFeePayload = { txNonce: nonce, txGasLimit: gasLimit1.toString(), txGasPrice: gasPriceWei1.toString() };
+    const ser0 = serializeTransaction({
+      type: "legacy",
+      to: toRouter,
+      data: dataHex,
+      value: valueWei,
+      gas: gasLimit1,
+      gasPrice: gasPriceWei1,
+      nonce: currentNonce0,
+      chainId: args.chainId
+    });
+    const h0 = keccak256(ser0);
+    messageHashes.push(h0.startsWith("0x") ? h0.slice(2) : h0);
+    messageRawBatch.push(ser0);
+    proposalTxParamsBatch.push({
+      nonce: currentNonce0,
+      gasLimit: gasLimit1.toString(),
+      txType: "legacy",
+      gasPrice: gasPriceWei1.toString()
+    });
+  } else {
+    const fetchedBase1 = feeParams.baseFeeGwei ?? 0;
+    const fetchedPriority1 = feeParams.priorityFeeGwei ?? 0;
+    const configuredBase1 = useCustomGas && args.chainDetail?.baseFee != null ? Number(args.chainDetail.baseFee) : 0;
+    const configuredPriority1 = useCustomGas && args.chainDetail?.priorityFee != null ? Number(args.chainDetail.priorityFee) : 0;
+    const effectiveBaseFeeGwei1 = Math.max(fetchedBase1, configuredBase1);
+    const effectivePriorityFeeGwei1 = Math.max(fetchedPriority1, configuredPriority1);
+    const baseFeeMultiplierPct1 = useCustomGas && args.chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(args.chainDetail.baseFeeMultiplier)) : 100;
+    const baseComponentGwei1 = effectiveBaseFeeGwei1 * baseFeeMultiplierPct1 / 100;
+    const maxFeePerGasGwei1 = baseComponentGwei1 + effectivePriorityFeeGwei1;
+    let maxPriorityFeePerGas1 = effectivePriorityFeeGwei1 > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei1)) : parseGwei("1");
+    let maxFeePerGas1 = parseGwei(gweiToDecimalString(maxFeePerGasGwei1));
+    if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+      maxPriorityFeePerGas1 = maxPriorityFeePerGas1 * BigInt(100 + gasFeeMultiplier) / 100n;
+      maxFeePerGas1 = maxFeePerGas1 * BigInt(100 + gasFeeMultiplier) / 100n;
+    }
+    ({ maxFeePerGas: maxFeePerGas1, maxPriorityFeePerGas: maxPriorityFeePerGas1 } = alignEip1559FeesWithLatestBase(maxFeePerGas1, maxPriorityFeePerGas1, latestBaseFeeWeiNativeIn));
+    firstTxFeePayload = {
+      txNonce: nonce,
+      txGasLimit: gasLimit1.toString(),
+      txMaxFeePerGas: maxFeePerGas1.toString(),
+      txMaxPriorityFeePerGas: maxPriorityFeePerGas1.toString()
+    };
+    const ser0 = serializeTransaction({
+      type: "eip1559",
+      to: toRouter,
+      data: dataHex,
+      value: valueWei,
+      gas: gasLimit1,
+      maxFeePerGas: maxFeePerGas1,
+      maxPriorityFeePerGas: maxPriorityFeePerGas1,
+      nonce: currentNonce0,
+      chainId: args.chainId
+    });
+    const h0 = keccak256(ser0);
+    messageHashes.push(h0.startsWith("0x") ? h0.slice(2) : h0);
+    messageRawBatch.push(ser0);
+    proposalTxParamsBatch.push({
+      nonce: currentNonce0,
+      gasLimit: gasLimit1.toString(),
+      txType: "eip1559",
+      maxFeePerGas: maxFeePerGas1.toString(),
+      maxPriorityFeePerGas: maxPriorityFeePerGas1.toString()
+    });
+  }
+  const dataNo0x = dataHex.startsWith("0x") ? dataHex.slice(2) : dataHex;
+  const audit = {
+    skipPermit2Batch: true,
+    inputKind: "native_eth",
+    noErc20Approve: true,
+    quoteInputWei: quoteInputWei.toString(),
+    swapValueWei: valueWei.toString(),
+    uniswapCreateSwap: {
+      requestId: args.createSwapResponse.requestId,
+      gasFee: args.createSwapResponse.gasFee,
+      gasBuildSwap: {
+        useCustomGas,
+        source: gasBuildSource,
+        baseGasUnits: baseGasUnits1.toString(),
+        ...estimateGasError != null && estimateGasError !== "" ? { estimateGasError } : {}
+      },
+      swap: {
+        to: args.createSwapResponse.swap.to,
+        value: args.createSwapResponse.swap.value,
+        dataNibbles: (() => {
+          const t = (args.createSwapResponse.swap.data ?? "").toString().trim();
+          return t.startsWith("0x") ? t.length - 2 : t.length;
+        })()
+      }
+    },
+    fullQuoteFromPermitSnapshot: args.fullQuoteSnapshot,
+    originalPurpose: args.purposeText
+  };
+  const batchMeta = [
+    {
+      destinationAddress: toRouter,
+      signatureText: JSON.stringify({
+        kind: "UniswapV4",
+        name: "UniversalRouter (payable, native in)",
+        note: "Single tx from Trade POST /swap; no ERC-20 approve. Calldata in messageHashes[0] / messageRawBatch[0]."
+      }),
+      evm: { type: "uniswap_v4_swap_tx", version: 1, chainId: String(args.chainId) },
+      uniswapV4: audit
+    }
+  ];
+  const extraPayload = { batchMeta };
+  if (useCustomGas) {
+    const snap = args.customGasChainDetails;
+    if (snap && typeof snap === "object" && !Array.isArray(snap) && Object.keys(snap).length > 0) {
+      extraPayload.customGasChainDetails = snap;
+    }
+  }
+  const extraJSON = JSON.stringify(extraPayload);
+  const firstSigText = batchMeta[0].signatureText;
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: dataNo0x,
+    messageHashes,
+    messageRawBatch,
+    destinationChainID: String(args.chainId),
+    destinationAddress: toRouter,
+    extraJSON,
+    signatureText: firstSigText,
+    purpose: (() => {
+      const t = args.purposeText.trim();
+      const batchDesc = "Uniswap V4: 1-tx batch \u2014 native gas token in (no ERC-20 approve) \u2014 single payable swap (Trade /swap).";
+      return (t ? `${t}
+
+` : "") + batchDesc;
+    })(),
+    ...firstTxFeePayload,
+    proposalTxParams: proposalTxParamsBatch
+  };
+  if (valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+async function buildEvmMultisignBodyUniswapV4SkipPermit2Batch(args) {
+  const ph = (args.keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = args.keyGen.keylist ?? [];
+  const clientId = firstClientIdFromKeyGen(args.keyGen);
+  const tokenIn = getAddress(args.tokenIn);
+  const parsedInOut = parseUniswapQuoteClassicInOut(args.fullQuoteSnapshot);
+  const quoteInputWei = parsedInOut?.inputWei;
+  if (quoteInputWei == null || quoteInputWei <= 0n) {
+    throw new Error(
+      "Could not read a positive input amount from the quote. Refresh the quote and ensure the Trade API returned classic quote.input.amount."
+    );
+  }
+  if (tokenIn === zeroAddress) {
+    return buildEvmMultisignBodyUniswapV4NativeInOnly(args, quoteInputWei);
+  }
+  const toRouter = getAddress(
+    (args.swap.to ?? "").trim().startsWith("0x") ? args.swap.to.trim() : `0x${args.swap.to.trim()}`
+  );
+  const dataHex = (() => {
+    const d = (args.swap.data ?? "0x").toString().trim();
+    return d.startsWith("0x") ? d : `0x${d}`;
+  })();
+  const canonicalUniversalRouter = getUniswapUniversalRouterSpenderOrThrow(args.chainId);
+  const { permit2Spender, approveWei: baseApproveWei, calldataAmountWei } = permit2SpenderAndApproveWeiFromSwapCalldata(
+    dataHex,
+    tokenIn,
+    quoteInputWei,
+    args.chainId
+  );
+  const approveAmountWei = applySlippagePercentToApproveWei(baseApproveWei, args.slippagePercent);
+  const usePermit2Triple = toRouter.toLowerCase() === permit2Spender.toLowerCase();
+  if (usePermit2Triple && approveAmountWei > MAX_UINT160) {
+    throw new Error("Approved transfer amount exceeds allowance-hub uint160 max; reduce trade size.");
+  }
+  let expiration48 = 0n;
+  if (usePermit2Triple) {
+    const deadlineSec = Math.floor(Number(args.swapDeadlineUnix));
+    if (!Number.isFinite(deadlineSec) || deadlineSec <= 0) {
+      throw new Error("Invalid swapDeadlineUnix for allowance-hub approve expiration.");
+    }
+    expiration48 = BigInt(deadlineSec);
+    if (expiration48 > MAX_UINT48) expiration48 = MAX_UINT48;
+  }
+  const erc20ApproveSpender = usePermit2Triple ? PERMIT2_ADDRESS : toRouter;
+  const approveData = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [erc20ApproveSpender, approveAmountWei]
+  });
+  const valueWei = (() => {
+    const v = args.swap.value;
+    if (v == null || v === "") return 0n;
+    try {
+      return BigInt(String(v).replace(/^0x/i, ""));
+    } catch {
+      return 0n;
+    }
+  })();
+  const ch = defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const feeParams = await fetchChainFeeParams(args.rpcUrl, args.chainId);
+  const legacy = Boolean(args.chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWeiSkipBatch = !legacy ? (await publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const useCustomGas = args.useCustomGas;
+  const gasLimitConfig = useCustomGas && args.chainDetail?.gasLimit != null ? Number(args.chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = args.chainDetail?.gasLimit != null && Number.isFinite(Number(args.chainDetail.gasLimit)) && Number(args.chainDetail.gasLimit) > 0 ? Number(args.chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && args.chainDetail?.gasMultiplier != null ? Number(args.chainDetail.gasMultiplier) : void 0;
+  const nonce = await publicClient.getTransactionCount({ address: args.executorAddress, blockTag: "pending" });
+  const proposalTxParamsBatch = [];
+  const messageHashes = [];
+  const messageRawBatch = [];
+  const approveMsgRawNo0x = approveData.startsWith("0x") ? approveData.slice(2) : approveData;
+  let firstTxFeePayload = {};
+  const approveGas = await publicClient.estimateGas({
+    to: tokenIn,
+    data: approveData,
+    value: 0n,
+    account: args.executorAddress
+  });
+  const gasLimit0 = useCustomGas ? gasLimitFromEstimateAndChainConfig(approveGas, gasLimitConfig) : approveGas;
+  const currentNonce0 = nonce;
+  if (legacy) {
+    let gasPriceWei = await publicClient.getGasPrice();
+    if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+      gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+    }
+    if (useCustomGas && args.chainDetail?.gasPrice != null && args.chainDetail.gasPrice > 0) {
+      const configured = parseGwei(gweiToDecimalString(Number(args.chainDetail.gasPrice)));
+      if (configured > gasPriceWei) gasPriceWei = configured;
+    }
+    firstTxFeePayload = { txNonce: nonce, txGasLimit: gasLimit0.toString(), txGasPrice: gasPriceWei.toString() };
+    const ser0 = serializeTransaction({
+      type: "legacy",
+      to: tokenIn,
+      data: approveData,
+      value: 0n,
+      gas: gasLimit0,
+      gasPrice: gasPriceWei,
+      nonce: currentNonce0,
+      chainId: args.chainId
+    });
+    const h0 = keccak256(ser0);
+    messageHashes.push(h0.startsWith("0x") ? h0.slice(2) : h0);
+    messageRawBatch.push(ser0);
+    proposalTxParamsBatch.push({
+      nonce: currentNonce0,
+      gasLimit: gasLimit0.toString(),
+      txType: "legacy",
+      gasPrice: gasPriceWei.toString()
+    });
+  } else {
+    const fetchedBase = feeParams.baseFeeGwei ?? 0;
+    const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+    const configuredBase = useCustomGas && args.chainDetail?.baseFee != null ? Number(args.chainDetail.baseFee) : 0;
+    const configuredPriority = useCustomGas && args.chainDetail?.priorityFee != null ? Number(args.chainDetail.priorityFee) : 0;
+    const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+    const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+    const baseFeeMultiplierPct = useCustomGas && args.chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(args.chainDetail.baseFeeMultiplier)) : 100;
+    const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+    const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+    let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+    let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+    if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+      maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+    }
+    ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      latestBaseFeeWeiSkipBatch
+    ));
+    firstTxFeePayload = {
+      txNonce: nonce,
+      txGasLimit: gasLimit0.toString(),
+      txMaxFeePerGas: maxFeePerGas.toString(),
+      txMaxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+    };
+    const ser0 = serializeTransaction({
+      type: "eip1559",
+      to: tokenIn,
+      data: approveData,
+      value: 0n,
+      gas: gasLimit0,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      nonce: currentNonce0,
+      chainId: args.chainId
+    });
+    const h0 = keccak256(ser0);
+    messageHashes.push(h0.startsWith("0x") ? h0.slice(2) : h0);
+    messageRawBatch.push(ser0);
+    proposalTxParamsBatch.push({
+      nonce: currentNonce0,
+      gasLimit: gasLimit0.toString(),
+      txType: "eip1559",
+      maxFeePerGas: maxFeePerGas.toString(),
+      maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+    });
+  }
+  if (usePermit2Triple) {
+    const permit2ApproveData = encodeFunctionData({
+      abi: permit2ApproveRouterAbi,
+      functionName: "approve",
+      args: [tokenIn, permit2Spender, approveAmountWei, Number(expiration48)]
+    });
+    const approveP2Gas = await publicClient.estimateGas({
+      to: PERMIT2_ADDRESS,
+      data: permit2ApproveData,
+      value: 0n,
+      account: args.executorAddress
+    });
+    const gasLimitP2 = useCustomGas ? gasLimitFromEstimateAndChainConfig(approveP2Gas, gasLimitConfig) : approveP2Gas;
+    const currentNonceP2 = nonce + 1;
+    if (legacy) {
+      let gasPriceWeiP2 = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWeiP2 = gasPriceWeiP2 * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && args.chainDetail?.gasPrice != null && args.chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(args.chainDetail.gasPrice)));
+        if (configured > gasPriceWeiP2) gasPriceWeiP2 = configured;
+      }
+      const serP2 = serializeTransaction({
+        type: "legacy",
+        to: PERMIT2_ADDRESS,
+        data: permit2ApproveData,
+        value: 0n,
+        gas: gasLimitP2,
+        gasPrice: gasPriceWeiP2,
+        nonce: currentNonceP2,
+        chainId: args.chainId
+      });
+      const hP2 = keccak256(serP2);
+      messageHashes.push(hP2.startsWith("0x") ? hP2.slice(2) : hP2);
+      messageRawBatch.push(serP2);
+      proposalTxParamsBatch.push({
+        nonce: currentNonceP2,
+        gasLimit: gasLimitP2.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWeiP2.toString()
+      });
+    } else {
+      const fetchedBaseP2 = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriorityP2 = feeParams.priorityFeeGwei ?? 0;
+      const configuredBaseP2 = useCustomGas && args.chainDetail?.baseFee != null ? Number(args.chainDetail.baseFee) : 0;
+      const configuredPriorityP2 = useCustomGas && args.chainDetail?.priorityFee != null ? Number(args.chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGweiP2 = Math.max(fetchedBaseP2, configuredBaseP2);
+      const effectivePriorityFeeGweiP2 = Math.max(fetchedPriorityP2, configuredPriorityP2);
+      const baseFeeMultiplierPctP2 = useCustomGas && args.chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(args.chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGweiP2 = effectiveBaseFeeGweiP2 * baseFeeMultiplierPctP2 / 100;
+      const maxFeePerGasGweiP2 = baseComponentGweiP2 + effectivePriorityFeeGweiP2;
+      let maxPriorityFeePerGasP2 = effectivePriorityFeeGweiP2 > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGweiP2)) : parseGwei("1");
+      let maxFeePerGasP2 = parseGwei(gweiToDecimalString(maxFeePerGasGweiP2));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGasP2 = maxPriorityFeePerGasP2 * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGasP2 = maxFeePerGasP2 * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas: maxFeePerGasP2, maxPriorityFeePerGas: maxPriorityFeePerGasP2 } = alignEip1559FeesWithLatestBase(maxFeePerGasP2, maxPriorityFeePerGasP2, latestBaseFeeWeiSkipBatch));
+      const serP2 = serializeTransaction({
+        type: "eip1559",
+        to: PERMIT2_ADDRESS,
+        data: permit2ApproveData,
+        value: 0n,
+        gas: gasLimitP2,
+        maxFeePerGas: maxFeePerGasP2,
+        maxPriorityFeePerGas: maxPriorityFeePerGasP2,
+        nonce: currentNonceP2,
+        chainId: args.chainId
+      });
+      const hP2 = keccak256(serP2);
+      messageHashes.push(hP2.startsWith("0x") ? hP2.slice(2) : hP2);
+      messageRawBatch.push(serP2);
+      proposalTxParamsBatch.push({
+        nonce: currentNonceP2,
+        gasLimit: gasLimitP2.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGasP2.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGasP2.toString()
+      });
+    }
+  }
+  const swapRecord = args.swap;
+  const fromTradeApi = parseOptionalGasLimitString(swapRecord.gasLimit) ?? parseOptionalGasLimitString(swapRecord.gas);
+  let gasBuildSource = "rpcEstimate";
+  let estimateGasError;
+  let baseGasUnits1;
+  if (fromTradeApi != null && fromTradeApi > 0n) {
+    baseGasUnits1 = fromTradeApi;
+    gasBuildSource = "tradeApi";
+  } else {
+    try {
+      baseGasUnits1 = await publicClient.estimateGas({
+        to: toRouter,
+        data: dataHex,
+        value: valueWei,
+        account: args.executorAddress
+      });
+      gasBuildSource = "rpcEstimate";
+    } catch (e) {
+      estimateGasError = e instanceof Error ? e.message : String(e);
+      const minRouterGas = 500000n;
+      if (useCustomGas) {
+        const cfg = args.chainDetail?.gasLimit != null ? parseOptionalGasLimitString(String(args.chainDetail.gasLimit)) : null;
+        if (cfg != null && cfg >= minRouterGas) {
+          baseGasUnits1 = cfg;
+        } else {
+          baseGasUnits1 = DEFAULT_UNIVERSAL_ROUTER_GAS_FALLBACK;
+        }
+      } else {
+        baseGasUnits1 = DEFAULT_UNIVERSAL_ROUTER_GAS_FALLBACK;
+      }
+      gasBuildSource = "estimateFailedFallback";
+    }
+  }
+  const gasLimit1 = routerSwapGasLimitFromEstimate(baseGasUnits1, chainGasLimitRouter);
+  const currentNonce1 = nonce + (usePermit2Triple ? 2 : 1);
+  if (legacy) {
+    let gasPriceWei1 = await publicClient.getGasPrice();
+    if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+      gasPriceWei1 = gasPriceWei1 * BigInt(100 + gasFeeMultiplier) / 100n;
+    }
+    if (useCustomGas && args.chainDetail?.gasPrice != null && args.chainDetail.gasPrice > 0) {
+      const configured = parseGwei(gweiToDecimalString(Number(args.chainDetail.gasPrice)));
+      if (configured > gasPriceWei1) gasPriceWei1 = configured;
+    }
+    const ser1 = serializeTransaction({
+      type: "legacy",
+      to: toRouter,
+      data: dataHex,
+      value: valueWei,
+      gas: gasLimit1,
+      gasPrice: gasPriceWei1,
+      nonce: currentNonce1,
+      chainId: args.chainId
+    });
+    const h1 = keccak256(ser1);
+    messageHashes.push(h1.startsWith("0x") ? h1.slice(2) : h1);
+    messageRawBatch.push(ser1);
+    proposalTxParamsBatch.push({
+      nonce: currentNonce1,
+      gasLimit: gasLimit1.toString(),
+      txType: "legacy",
+      gasPrice: gasPriceWei1.toString()
+    });
+  } else {
+    const fetchedBase1 = feeParams.baseFeeGwei ?? 0;
+    const fetchedPriority1 = feeParams.priorityFeeGwei ?? 0;
+    const configuredBase1 = useCustomGas && args.chainDetail?.baseFee != null ? Number(args.chainDetail.baseFee) : 0;
+    const configuredPriority1 = useCustomGas && args.chainDetail?.priorityFee != null ? Number(args.chainDetail.priorityFee) : 0;
+    const effectiveBaseFeeGwei1 = Math.max(fetchedBase1, configuredBase1);
+    const effectivePriorityFeeGwei1 = Math.max(fetchedPriority1, configuredPriority1);
+    const baseFeeMultiplierPct1 = useCustomGas && args.chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(args.chainDetail.baseFeeMultiplier)) : 100;
+    const baseComponentGwei1 = effectiveBaseFeeGwei1 * baseFeeMultiplierPct1 / 100;
+    const maxFeePerGasGwei1 = baseComponentGwei1 + effectivePriorityFeeGwei1;
+    let maxPriorityFeePerGas1 = effectivePriorityFeeGwei1 > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei1)) : parseGwei("1");
+    let maxFeePerGas1 = parseGwei(gweiToDecimalString(maxFeePerGasGwei1));
+    if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+      maxPriorityFeePerGas1 = maxPriorityFeePerGas1 * BigInt(100 + gasFeeMultiplier) / 100n;
+      maxFeePerGas1 = maxFeePerGas1 * BigInt(100 + gasFeeMultiplier) / 100n;
+    }
+    ({ maxFeePerGas: maxFeePerGas1, maxPriorityFeePerGas: maxPriorityFeePerGas1 } = alignEip1559FeesWithLatestBase(maxFeePerGas1, maxPriorityFeePerGas1, latestBaseFeeWeiSkipBatch));
+    const ser1 = serializeTransaction({
+      type: "eip1559",
+      to: toRouter,
+      data: dataHex,
+      value: valueWei,
+      gas: gasLimit1,
+      maxFeePerGas: maxFeePerGas1,
+      maxPriorityFeePerGas: maxPriorityFeePerGas1,
+      nonce: currentNonce1,
+      chainId: args.chainId
+    });
+    const h1 = keccak256(ser1);
+    messageHashes.push(h1.startsWith("0x") ? h1.slice(2) : h1);
+    messageRawBatch.push(ser1);
+    proposalTxParamsBatch.push({
+      nonce: currentNonce1,
+      gasLimit: gasLimit1.toString(),
+      txType: "eip1559",
+      maxFeePerGas: maxFeePerGas1.toString(),
+      maxPriorityFeePerGas: maxPriorityFeePerGas1.toString()
+    });
+  }
+  const swapMsgIndex = usePermit2Triple ? 2 : 1;
+  const audit = {
+    skipPermit2Batch: true,
+    approvalPath: usePermit2Triple ? "permit2_triple" : "dispatcher",
+    approveAmount: {
+      baseWeiBeforeSlippage: baseApproveWei.toString(),
+      finalWei: approveAmountWei.toString(),
+      slippagePercent: args.slippagePercent,
+      quoteInputWei: quoteInputWei.toString(),
+      ...calldataAmountWei != null ? { swapCalldataAmountWei: calldataAmountWei.toString() } : {}
+    },
+    uniswapCreateSwap: {
+      requestId: args.createSwapResponse.requestId,
+      gasFee: args.createSwapResponse.gasFee,
+      gasBuildSwap: {
+        useCustomGas,
+        source: gasBuildSource,
+        baseGasUnits: baseGasUnits1.toString(),
+        ...estimateGasError != null && estimateGasError !== "" ? { estimateGasError } : {}
+      },
+      swap: {
+        to: args.createSwapResponse.swap.to,
+        value: args.createSwapResponse.swap.value,
+        dataNibbles: (() => {
+          const d = args.createSwapResponse.swap.data ?? "";
+          const t = d.toString().trim();
+          return t.startsWith("0x") ? t.length - 2 : t.length;
+        })()
+      }
+    },
+    fullQuoteFromPermitSnapshot: args.fullQuoteSnapshot,
+    originalPurpose: args.purposeText,
+    innerRouterFromCalldata: permit2Spender,
+    swapToEqualsInnerRouter: usePermit2Triple,
+    ...usePermit2Triple ? {
+      permit2Erc20Approve: {
+        token: tokenIn,
+        spender: PERMIT2_ADDRESS,
+        amountWei: approveAmountWei.toString(),
+        note: "ERC-20 \u2192 allowance hub before hub approve(router)."
+      },
+      permit2ApproveUniversalRouter: {
+        permit2: PERMIT2_ADDRESS,
+        token: tokenIn,
+        spender: permit2Spender,
+        canonicalUniversalRouterFromAppMap: canonicalUniversalRouter,
+        spenderMatchesCanonicalMap: permit2Spender.toLowerCase() === canonicalUniversalRouter.toLowerCase(),
+        amountWei: approveAmountWei.toString(),
+        expiration: expiration48.toString(),
+        note: "Allowance-hub spender must match the router in swap calldata."
+      }
+    } : {
+      erc20ApproveDispatcher: {
+        token: tokenIn,
+        spender: toRouter,
+        amountWei: approveAmountWei.toString(),
+        note: "Dispatcher pulls via ERC20.transferFrom(user, universalRouter, amount); allowance must be on swap.to (see cast trace TRANSFER_FROM_FAILED when only the hub is approved)."
+      }
+    }
+  };
+  const batchMeta = [
+    {
+      destinationAddress: tokenIn,
+      signatureText: JSON.stringify({
+        kind: "UniswapV4",
+        name: "ERC20.approve",
+        to: usePermit2Triple ? "allowance hub" : "dispatcher(swap.to)",
+        function: "approve(address spender, uint256 amount)",
+        spender: erc20ApproveSpender,
+        amountWei: approveAmountWei.toString()
+      }),
+      evm: {
+        type: usePermit2Triple ? "uniswap_v4_skip_permit2_approve" : "uniswap_v4_skip_permit2_dispatcher_approve",
+        version: 1,
+        chainId: String(args.chainId),
+        ...usePermit2Triple ? { permit2: PERMIT2_ADDRESS } : { dispatcher: toRouter }
+      }
+    }
+  ];
+  if (usePermit2Triple) {
+    batchMeta.push({
+      destinationAddress: PERMIT2_ADDRESS,
+      signatureText: JSON.stringify({
+        kind: "UniswapV4",
+        name: "AllowanceHub.approve",
+        function: "approve(address token, address spender, uint160 amount, uint48 expiration)",
+        token: tokenIn,
+        spender: permit2Spender,
+        amountWei: approveAmountWei.toString(),
+        expiration: expiration48.toString()
+      }),
+      evm: {
+        type: "uniswap_v4_skip_permit2_permit2_approve",
+        version: 1,
+        chainId: String(args.chainId),
+        permit2: PERMIT2_ADDRESS,
+        permit2Spender
+      }
+    });
+  }
+  batchMeta.push({
+    destinationAddress: toRouter,
+    signatureText: JSON.stringify({
+      kind: "UniswapV4",
+      name: "UniversalRouter.execute",
+      note: `Calldata from Trade API POST /swap; signed tx hash in messageHashes[${swapMsgIndex}].`
+    }),
+    evm: { type: "uniswap_v4_swap_tx", version: 1, chainId: String(args.chainId) },
+    uniswapV4: audit
+  });
+  const extraPayload = { batchMeta };
+  if (useCustomGas) {
+    const snap = args.customGasChainDetails;
+    if (snap && typeof snap === "object" && !Array.isArray(snap) && Object.keys(snap).length > 0) {
+      extraPayload.customGasChainDetails = snap;
+    }
+  }
+  const extraJSON = JSON.stringify(extraPayload);
+  const firstSigText = batchMeta[0].signatureText;
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: approveMsgRawNo0x,
+    messageHashes,
+    messageRawBatch,
+    destinationChainID: String(args.chainId),
+    destinationAddress: tokenIn,
+    extraJSON,
+    signatureText: firstSigText,
+    purpose: (() => {
+      const t = args.purposeText.trim();
+      const batchDesc = usePermit2Triple ? "Uniswap V4: 3-tx batch (classic allowance) \u2014 (1) ERC-20 approve allowance hub, (2) hub approve(Universal Router), (3) swap (Trade /swap)." : "Uniswap V4: 2-tx batch (classic allowance, dispatcher) \u2014 (1) ERC-20 approve swap.to (dispatcher pulls tokens), (2) swap (Trade /swap).";
+      return (t ? `${t}
+
+` : "") + batchDesc;
+    })(),
+    ...firstTxFeePayload,
+    proposalTxParams: proposalTxParamsBatch
+  };
+  if (valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+
+// src/protocols/evm/uniswap-v4/swap.ts
+async function swapFromQuote(args) {
+  const deadline = args.swapTransactionDeadlineUnix ?? swapTransactionDeadlineUnixFromExpiryMinutes(30);
+  return buildEvmMultisignBodyUniswapV4SkipPermit2Batch({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    tokenIn: args.tokenIn,
+    executorAddress: args.executorAddress,
+    swap: args.swap.swap,
+    createSwapResponse: args.swap,
+    fullQuoteSnapshot: args.fullQuote,
+    purposeText: args.purposeText,
+    swapDeadlineUnix: deadline,
+    slippagePercent: args.slippagePercent
+  });
+}
+async function quoteSwap(args) {
+  return uniswapTradeQuote(args);
+}
+async function createSwap(args) {
+  return uniswapCreateSwap(args);
+}
+async function swapExactInput(args) {
+  const swap = await uniswapCreateSwap({
+    uniswapApiKey: args.uniswapApiKey,
+    fullQuoteFromPermit: args.fullQuote,
+    baseUrl: args.baseUrl,
+    swapTransactionDeadlineUnix: args.swapTransactionDeadlineUnix,
+    useServerProxy: false
+  });
+  return swapFromQuote({ ...args, swap });
+}
+
+// src/protocols/evm/uniswap-v4/index.ts
+var UNISWAP_V4_PROTOCOL_ID = "uniswap-v4";
+var uniswapV4ProtocolModule = {
+  id: UNISWAP_V4_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return isUniswapV4ChainSupported(ctx.chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "uniswap-v4.swap-exact-input",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Swap ERC-20 or native token via Uniswap V4 Universal Router (classic allowance path)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenIn: { type: "address", required: true, description: "Input token (0x0 for native)" },
+        tokenOut: { type: "address", required: true, description: "Output token address" },
+        amount: { type: "string", required: true, description: "Human or wei amount per trade type" },
+        slippagePercent: { type: "number", required: true, description: "Slippage tolerance percent" },
+        swapTransactionDeadlineUnix: {
+          type: "number",
+          required: false,
+          description: "On-chain swap deadline (unix seconds)"
+        },
+        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API key" }
+      }
+    },
+    {
+      id: "uniswap-v4.quote",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Fetch Uniswap Trade API quote",
+      commonParams: ["keyGen"],
+      params: {
+        tokenIn: { type: "address", required: true, description: "Input token" },
+        tokenOut: { type: "address", required: true, description: "Output token" },
+        amount: { type: "string", required: true, description: "Amount for quote" },
+        type: { type: "EXACT_INPUT | EXACT_OUTPUT", required: true, description: "Trade type" }
+      }
+    }
+  ]
+};
+registerProtocolModule(uniswapV4ProtocolModule);
+var uniswapV4 = {
+  quoteSwap,
+  createSwap,
+  swapExactInput,
+  swapFromQuote,
+  buildSwapMultisignBody: buildEvmMultisignBodyUniswapV4SkipPermit2Batch,
+  quote: uniswapTradeQuote,
+  isChainSupported: isUniswapV4ChainSupported
+};
+
+// src/protocols/evm/curve-dao/support.ts
+var CURVE_FULL_NETWORK_CONSTANTS_CHAIN_IDS = /* @__PURE__ */ new Set([
+  1,
+  10,
+  56,
+  100,
+  137,
+  146,
+  196,
+  250,
+  252,
+  324,
+  999,
+  1284,
+  2222,
+  5e3,
+  8453,
+  42161,
+  42220,
+  43114,
+  1313161554
+]);
+function isCurveApiChainSupported(chainId) {
+  const n = parseEvmChainIdToNumber(chainId);
+  if (Number.isNaN(n) || n < 0) return false;
+  return CURVE_FULL_NETWORK_CONSTANTS_CHAIN_IDS.has(n);
+}
+var CURVE_NATIVE_PLACEHOLDER = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var ETH_PLACEHOLDER = CURVE_NATIVE_PLACEHOLDER;
+function normalizeAddr(a) {
+  return a.toLowerCase();
+}
+function toCurveRouterTokenId(tokenAddress, wrappedNative) {
+  const t = (tokenAddress ?? "").trim().toLowerCase();
+  if (t === ETH_PLACEHOLDER) return ETH_PLACEHOLDER;
+  if (!isAddress((tokenAddress ?? "").trim())) return normalizeAddr((tokenAddress ?? "").trim());
+  try {
+    const a = getAddress((tokenAddress ?? "").trim());
+    if (wrappedNative && a.toLowerCase() === wrappedNative.toLowerCase()) {
+      return ETH_PLACEHOLDER;
+    }
+    return a.toLowerCase();
+  } catch {
+    return normalizeAddr((tokenAddress ?? "").trim());
+  }
+}
+function addEdge(adj, a, b) {
+  if (a === b) return;
+  if (!adj.has(a)) adj.set(a, /* @__PURE__ */ new Set());
+  if (!adj.has(b)) adj.set(b, /* @__PURE__ */ new Set());
+  adj.get(a).add(b);
+  adj.get(b).add(a);
+}
+function buildCurveLiquidityGraphFromApi(curve) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const id of curve.getPoolList()) {
+    try {
+      const pool = curve.getPool(id);
+      const w = (pool.wrappedCoinAddresses ?? []).map(normalizeAddr);
+      const u = (pool.underlyingCoinAddresses ?? []).map(normalizeAddr);
+      const all = [.../* @__PURE__ */ new Set([...w, ...u])];
+      for (let i = 0; i < all.length; i++) {
+        for (let j = i + 1; j < all.length; j++) {
+          addEdge(adj, all[i], all[j]);
+        }
+      }
+    } catch {
+    }
+  }
+  return adj;
+}
+function addNativeWethBridge(adj, wrappedNative) {
+  if (!wrappedNative) return;
+  const w = wrappedNative.toLowerCase();
+  const a = ETH_PLACEHOLDER;
+  const b = w;
+  if (a === b) return;
+  if (!adj.has(a)) adj.set(a, /* @__PURE__ */ new Set());
+  if (!adj.has(b)) adj.set(b, /* @__PURE__ */ new Set());
+  adj.get(a).add(b);
+  adj.get(b).add(a);
+}
+function swappableCurveGraphNodeKeys(adj) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [k, neigh] of adj) {
+    if (neigh.size > 0) out.add(k);
+  }
+  return out;
+}
+
+// src/protocols/evm/curve-dao/apiSession.ts
+async function fetchAllCurvePools(curve) {
+  const run = (p) => p.catch(() => void 0);
+  await Promise.all([
+    run(curve.factory.fetchPools()),
+    run(curve.crvUSDFactory.fetchPools()),
+    run(curve.EYWAFactory.fetchPools()),
+    run(curve.cryptoFactory.fetchPools()),
+    run(curve.twocryptoFactory.fetchPools()),
+    run(curve.tricryptoFactory.fetchPools()),
+    run(curve.stableNgFactory.fetchPools())
+  ]);
+}
+async function loadFullCurveSessionForRpc(rpcUrl) {
+  const url = (rpcUrl ?? "").trim();
+  if (!url) return null;
+  try {
+    const { default: curve } = await import('@curvefi/api');
+    await curve.init("JsonRpc", { url }, {});
+    const wrapped = curve.getNetworkConstants().NATIVE_COIN?.wrappedAddress;
+    if (!curve.hasRouter || !curve.hasRouter()) {
+      return {
+        curve,
+        adj: /* @__PURE__ */ new Map(),
+        swappableNodeKeys: /* @__PURE__ */ new Set(),
+        wrappedNative: wrapped
+      };
+    }
+    await fetchAllCurvePools(curve);
+    const adj = buildCurveLiquidityGraphFromApi(curve);
+    addNativeWethBridge(adj, wrapped);
+    return {
+      curve,
+      adj,
+      swappableNodeKeys: swappableCurveGraphNodeKeys(adj),
+      wrappedNative: wrapped
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/protocols/evm/curve-dao/executeHelpers.ts
+var CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS = 1200000n;
+var ETH_PLACEHOLDER2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+function txToViemStep(tx) {
+  if (!tx.to) throw new Error("Transaction missing `to`");
+  const to = getAddress((tx.to ?? "").trim());
+  const raw = (tx.data ?? "0x").toString();
+  const data = raw.startsWith("0x") ? raw : `0x${raw}`;
+  let value = 0n;
+  if (tx.value != null) {
+    if (typeof tx.value === "bigint") value = tx.value;
+    else value = BigInt(String(tx.value));
+  }
+  return { to, data, value };
+}
+async function buildEvmMultisignBodyCurveDaoBatch(args) {
+  const tokenIn = getAddress(args.tokenIn);
+  const executor = getAddress(args.executorAddress);
+  const session = await loadFullCurveSessionForRpc(args.rpcUrl);
+  if (!session?.curve?.router?.populateSwap) {
+    throw new Error("Curve router is not available (load session failed or chain has no router).");
+  }
+  const { curve, wrappedNative } = session;
+  const wn = wrappedNative;
+  const tokenInId = toCurveRouterTokenId(tokenIn, wn);
+  const outTrim = (args.tokenOut ?? "").trim();
+  const tokenOutId = toCurveRouterTokenId(
+    outTrim.toLowerCase() === ETH_PLACEHOLDER2 ? ETH_PLACEHOLDER2 : getAddress(outTrim),
+    wn
+  );
+  const isNativeIn = tokenInId.toLowerCase() === ETH_PLACEHOLDER2;
+  const slip = args.slippagePercent;
+  if (!Number.isFinite(slip) || slip <= 0 || slip >= 100) {
+    throw new Error("Slippage must be between 0 and 100 (exclusive).");
+  }
+  const swapPop = await curve.router.populateSwap(tokenInId, tokenOutId, args.amountHuman, slip);
+  const swapBase = txToViemStep(swapPop);
+  const rawTo = swapPop?.to;
+  if (rawTo == null || String(rawTo).trim() === "") {
+    throw new Error("Curve populateSwap did not return a destination address (router).");
+  }
+  const routerAddr = getAddress(String(rawTo).trim());
+  const ch = defineChain({
+    id: args.chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(args.rpcUrl) });
+  const erc20AllowanceAbi = parseAbi([
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function decimals() view returns (uint8)"
+  ]);
+  const erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+  const steps = [];
+  if (!isNativeIn) {
+    const decimalsN = await publicClient.readContract({
+      address: tokenIn,
+      abi: erc20AllowanceAbi,
+      functionName: "decimals"
+    });
+    const amountWei = parseUnits(args.amountHuman, Number(decimalsN));
+    const currentAllowance = await publicClient.readContract({
+      address: tokenIn,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [executor, routerAddr]
+    });
+    if (currentAllowance < amountWei) {
+      if (currentAllowance > 0n) {
+        const dataReset = encodeFunctionData({
+          abi: erc20ApproveAbi,
+          functionName: "approve",
+          args: [routerAddr, 0n]
+        });
+        steps.push({ to: tokenIn, data: dataReset, value: 0n, kind: "approve", fallbackGas: 80000n });
+      }
+      const dataApprove = encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [routerAddr, amountWei]
+      });
+      steps.push({ to: tokenIn, data: dataApprove, value: 0n, kind: "approve", fallbackGas: 80000n });
+    }
+  }
+  steps.push({
+    ...swapBase,
+    kind: "exchange",
+    routerSwap: true,
+    fallbackGas: CURVE_ROUTER_EXCHANGE_DEFAULT_GAS_UNITS
+  });
+  const chainGasLimitRouter = args.chainDetail?.gasLimit != null && Number.isFinite(Number(args.chainDetail.gasLimit)) && Number(args.chainDetail.gasLimit) > 0 ? Number(args.chainDetail.gasLimit) : void 0;
+  const gasLimitByIndex = /* @__PURE__ */ new Map();
+  const n = steps.length;
+  const purposeSuffix = n === 1 ? "Curve (DAO): 1-tx \u2014 CurveRouterNG.exchange (native in or allowance already set)." : `Curve (DAO): ${n}-tx batch \u2014 ERC-20 approve Curve router, then CurveRouterNG.exchange.`;
+  const firstDataNo0x = steps[0].data.startsWith("0x") ? steps[0].data.slice(2) : steps[0].data;
+  const payableValueWei = steps.filter((s) => s.kind === "exchange").reduce((a, s) => a + s.value, 0n);
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps,
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    payableValueWei: payableValueWei > 0n ? payableValueWei : void 0,
+    resolveGasLimit: async ({ step, index, estimatedGas }) => {
+      const s = step;
+      let gasLimitI;
+      if (s.kind === "exchange") {
+        gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+      } else {
+        gasLimitI = estimatedGas;
+      }
+      gasLimitByIndex.set(index, gasLimitI);
+      return gasLimitI;
+    },
+    buildBatchMeta: ({ step, index, gasLimit }) => {
+      const s = step;
+      const gl = gasLimitByIndex.get(index) ?? gasLimit;
+      if (s.kind === "approve") {
+        return {
+          signatureText: JSON.stringify({
+            kind: "CurveDao",
+            name: "ERC20.approve",
+            to: "Curve router",
+            function: "approve(address spender, uint256 amount)",
+            spender: routerAddr,
+            amountHuman: args.amountHuman,
+            note: "Allowance approved for this swap amount only (not unlimited)."
+          }),
+          evm: { type: "curve_dao_erc20_approve", version: 1, chainId: String(args.chainId) }
+        };
+      }
+      return {
+        signatureText: JSON.stringify({
+          kind: "CurveDao",
+          name: "CurveRouterNG.exchange",
+          note: "Calldata from @curvefi/api `router.populateSwap` (same on-chain as router `exchange`)."
+        }),
+        evm: { type: "curve_dao_router_exchange", version: 1, chainId: String(args.chainId) },
+        curveDao: {
+          slippagePercent: slip,
+          amountHuman: args.amountHuman,
+          tokenIn: tokenInId,
+          tokenOut: tokenOutId,
+          isNativeIn,
+          gasBuildExchange: { baseGasUnits: gl.toString() }
+        }
+      };
+    }
+  });
+}
+
+// src/protocols/evm/curve-dao/index.ts
+var CURVE_DAO_PROTOCOL_ID = "curve-dao";
+var curveDaoProtocolModule = {
+  id: CURVE_DAO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return isCurveApiChainSupported(ctx.chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "curve-dao.swap",
+      protocolId: CURVE_DAO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Swap via Curve Router NG (optional ERC-20 approve batch)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenIn: { type: "address", required: true, description: "ERC-20 token in (native uses WETH path in UI)" },
+        tokenOut: { type: "address", required: true, description: "Output token or 0xeeee\u2026 native placeholder" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount" },
+        slippagePercent: { type: "number", required: true, description: "Slippage percent (0\u2013100 exclusive)" }
+      }
+    }
+  ]
+};
+registerProtocolModule(curveDaoProtocolModule);
+var curveDao = {
+  buildSwapMultisignBody: buildEvmMultisignBodyCurveDaoBatch,
+  isChainSupported: isCurveApiChainSupported,
+  loadSession: loadFullCurveSessionForRpc
+};
+
+// src/agent/commonParamDocs.ts
+var EVM_COMMON_PARAM_DOCS = {
+  keyGen: {
+    type: "object",
+    required: true,
+    description: "MPC key slice: { pubkeyhex: string (required), keylist: string[], ClientKeys?: Record<string,string> }. Used for pubKey/keyList on POST /multiSignRequest."
+  },
+  purposeText: {
+    type: "string",
+    required: true,
+    description: "Human-readable purpose for the sign request. Stored in bodyForSign.purpose (may be appended with an automatic batch suffix)."
+  },
+  useCustomGas: {
+    type: "boolean",
+    required: true,
+    description: "When true, apply chain gas settings from chainDetail / customGasChainDetails instead of raw RPC estimates only."
+  },
+  chainId: {
+    type: "number",
+    required: true,
+    description: "EVM chain id (decimal). Becomes destinationChainID on the sign request."
+  },
+  rpcUrl: {
+    type: "string",
+    required: true,
+    description: "HTTPS JSON-RPC URL for gas estimation, nonce, and allowance reads."
+  },
+  executorAddress: {
+    type: "address",
+    required: true,
+    description: "MPC wallet address (from keyGen ethereumaddress) \u2014 tx sender for estimates and approvals."
+  },
+  chainDetail: {
+    type: "object",
+    required: true,
+    description: "Optional gas config: { legacy?, gasLimit?, gasMultiplier?, gasPrice?, baseFee?, priorityFee?, baseFeeMultiplier? }."
+  },
+  customGasChainDetails: {
+    type: "object",
+    required: false,
+    description: "Snapshot written to extraJSON.customGasChainDetails when useCustomGas is true."
+  }
+};
+var MULTISIGN_OUTPUT_DOC = {
+  description: "Unsigned mpc-auth multiSignRequest payload. The caller must sign messageToSign (MetaMask personal_sign or Ed25519) and POST { ...bodyForSign, clientSig, signedMessage: messageToSign } to /multiSignRequest.",
+  fields: {
+    bodyForSign: {
+      type: "object",
+      description: "POST body fields without clientSig: keyList, pubKey, msgHash, msgRaw, destinationChainID, purpose, extraJSON, proposalTxParams (batch), messageHashes/messageRawBatch when N>1 txs."
+    },
+    messageToSign: {
+      type: "string",
+      description: "JSON.stringify(bodyForSign) \u2014 exact string to sign before adding clientSig."
+    }
+  }
+};
+
+// src/agent/mcpTools.ts
+function paramProperties(params, includeCommon = []) {
+  const out = {};
+  for (const k of includeCommon) {
+    const d = EVM_COMMON_PARAM_DOCS[k];
+    if (d) out[k] = { type: d.type, description: d.description };
+  }
+  for (const [k, d] of Object.entries(params)) {
+    out[k] = { type: d.type, description: d.description };
+  }
+  return out;
+}
+function requiredKeys(params, includeCommon = []) {
+  const req = [];
+  for (const k of includeCommon) {
+    if (EVM_COMMON_PARAM_DOCS[k]?.required) req.push(k);
+  }
+  for (const [k, d] of Object.entries(params)) {
+    if (d.required) req.push(k);
+  }
+  return req;
+}
+var multisignOutputSchema = {
+  type: "object",
+  description: MULTISIGN_OUTPUT_DOC.description,
+  properties: {
+    bodyForSign: {
+      type: "object",
+      description: MULTISIGN_OUTPUT_DOC.fields.bodyForSign.description
+    },
+    messageToSign: {
+      type: "string",
+      description: MULTISIGN_OUTPUT_DOC.fields.messageToSign.description
+    }
+  },
+  required: ["bodyForSign", "messageToSign"]
+};
+var MCP_TOOL_DEFINITIONS = [
+  {
+    name: "ctm_uniswap_v4_quote",
+    actionId: "uniswap-v4.quote",
+    protocolId: "uniswap-v4",
+    chainCategory: "evm",
+    description: "Fetch a Uniswap V4 Trade API quote (POST /v1/quote). Returns classic quote JSON including quote.input/output amounts and routing. Does NOT create a sign request \u2014 use ctm_uniswap_v4_create_swap and ctm_uniswap_v4_build_swap_multisign after quoting. Requires uniswapApiKey and swapper (MPC executor address) or keyGen + managementNodeUrl to resolve swapper.",
+    prerequisites: ["Chain must be supported by Uniswap V4 (Universal Router map)."],
+    followUp: ["ctm_uniswap_v4_create_swap", "ctm_uniswap_v4_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapTradeQuote" },
+    inputSchema: {
+      type: "object",
+      properties: paramProperties({
+        type: { type: "string", required: true, description: "EXACT_INPUT or EXACT_OUTPUT" },
+        amount: { type: "string", required: true, description: "Amount in token-in base units (wei string for ERC-20)" },
+        tokenIn: { type: "address", required: true, description: "Input token; 0x0 for native ETH" },
+        tokenOut: { type: "address", required: true, description: "Output token address" },
+        chainId: { type: "number", required: true, description: "tokenInChainId / same-chain default" },
+        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API x-api-key" },
+        swapper: { type: "address", required: false, description: "MPC executor; omit if keyGen + managementNodeUrl provided" },
+        slippage: { type: "number", required: false, description: "Slippage percent; omit for API auto slippage" }
+      }),
+      required: requiredKeys({
+        type: { type: "string", required: true, description: "" },
+        amount: { type: "string", required: true, description: "" },
+        tokenIn: { type: "address", required: true, description: "" },
+        tokenOut: { type: "address", required: true, description: "" },
+        chainId: { type: "number", required: true, description: "" },
+        uniswapApiKey: { type: "string", required: true, description: "" }
+      })
+    },
+    outputSchema: {
+      type: "object",
+      description: "Full Uniswap POST /quote JSON (includes nested quote object with input/output amounts)."
+    }
+  },
+  {
+    name: "ctm_uniswap_v4_create_swap",
+    actionId: "uniswap-v4.create-swap",
+    protocolId: "uniswap-v4",
+    chainCategory: "evm",
+    description: "Call Uniswap Trade API POST /v1/swap to build Universal Router calldata from a prior quote. Returns { swap: { to, data, value, gasLimit? }, requestId? }. Does NOT produce a multiSignRequest \u2014 call ctm_uniswap_v4_build_swap_multisign next.",
+    prerequisites: ["ctm_uniswap_v4_quote output (fullQuoteFromPermit)"],
+    followUp: ["ctm_uniswap_v4_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "uniswapCreateSwap" },
+    inputSchema: {
+      type: "object",
+      properties: paramProperties({
+        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API key" },
+        fullQuoteFromPermit: { type: "object", required: true, description: "Full quote JSON from ctm_uniswap_v4_quote" },
+        swapTransactionDeadlineUnix: {
+          type: "number",
+          required: false,
+          description: "On-chain deadline unix seconds; default ~30 min from now"
+        },
+        useServerProxy: {
+          type: "boolean",
+          required: false,
+          description: "Set false in Node/agents; true only in browser via Next API route"
+        }
+      }),
+      required: requiredKeys({
+        uniswapApiKey: { type: "string", required: true, description: "" },
+        fullQuoteFromPermit: { type: "object", required: true, description: "" }
+      })
+    },
+    outputSchema: {
+      type: "object",
+      description: "{ swap: TransactionRequest, requestId?, gasFee? }"
+    }
+  },
+  {
+    name: "ctm_uniswap_v4_build_swap_multisign",
+    actionId: "uniswap-v4.swap-exact-input",
+    protocolId: "uniswap-v4",
+    chainCategory: "evm",
+    description: "Build mpc-auth multiSignRequest body for a Uniswap V4 swap. May batch 1\u20133 EVM txs: ERC-20 approve(s) to Permit2/router path + Universal Router swap (or 1 tx for native-in). Estimates gas, serializes unsigned txs, sets proposalTxParams. Output must be signed and POSTed to /multiSignRequest by the caller.",
+    prerequisites: [
+      "ctm_uniswap_v4_create_swap output",
+      "keyGen with pubkeyhex",
+      "executorAddress matching MPC wallet",
+      "RPC URL and chainDetail from node chain config"
+    ],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest with clientSig"],
+    handler: { importPath: "protocols/evm/uniswap-v4", exportName: "buildEvmMultisignBodyUniswapV4SkipPermit2Batch" },
+    inputSchema: {
+      type: "object",
+      properties: paramProperties(
+        {
+          tokenIn: { type: "address", required: true, description: "Token in; 0x0 for native ETH" },
+          swap: { type: "object", required: true, description: "swap field from create_swap response" },
+          createSwapResponse: { type: "object", required: true, description: "Full create_swap response" },
+          fullQuoteSnapshot: { type: "object", required: true, description: "Quote JSON used for the swap" },
+          swapDeadlineUnix: { type: "number", required: true, description: "Same deadline passed to create_swap" },
+          slippagePercent: { type: "number", required: false, description: "Extra approve headroom for EXACT_OUTPUT" }
+        },
+        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail", "customGasChainDetails"]
+      ),
+      required: requiredKeys(
+        {
+          tokenIn: { type: "address", required: true, description: "" },
+          swap: { type: "object", required: true, description: "" },
+          createSwapResponse: { type: "object", required: true, description: "" },
+          fullQuoteSnapshot: { type: "object", required: true, description: "" },
+          swapDeadlineUnix: { type: "number", required: true, description: "" }
+        },
+        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail"]
+      )
+    },
+    outputSchema: multisignOutputSchema
+  },
+  {
+    name: "ctm_curve_dao_build_swap_multisign",
+    actionId: "curve-dao.swap",
+    protocolId: "curve-dao",
+    chainCategory: "evm",
+    description: "Build mpc-auth multiSignRequest for a Curve Router NG swap via @curvefi/api populateSwap. Optionally batches ERC-20 approve txs when allowance is insufficient, then exchange. Requires JSON-RPC and Curve-supported chain.",
+    prerequisites: ["keyGen", "executorAddress", "tokenIn/tokenOut/amountHuman/slippage", "RPC URL"],
+    followUp: ["Sign messageToSign", "POST /multiSignRequest"],
+    handler: { importPath: "protocols/evm/curve-dao", exportName: "buildEvmMultisignBodyCurveDaoBatch" },
+    inputSchema: {
+      type: "object",
+      properties: paramProperties(
+        {
+          tokenIn: { type: "address", required: true, description: "ERC-20 sold (native in uses WETH path in UI)" },
+          tokenOut: { type: "string", required: true, description: "Output token or 0xeeee\u2026 native placeholder" },
+          amountHuman: { type: "string", required: true, description: "Human-readable amount of tokenIn" },
+          slippagePercent: { type: "number", required: true, description: "Slippage 0\u2013100 exclusive" }
+        },
+        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail", "customGasChainDetails"]
+      ),
+      required: requiredKeys(
+        {
+          tokenIn: { type: "address", required: true, description: "" },
+          tokenOut: { type: "string", required: true, description: "" },
+          amountHuman: { type: "string", required: true, description: "" },
+          slippagePercent: { type: "number", required: true, description: "" }
+        },
+        ["keyGen", "purposeText", "useCustomGas", "chainId", "rpcUrl", "executorAddress", "chainDetail"]
+      )
+    },
+    outputSchema: multisignOutputSchema
+  }
+];
+function getAgentCatalogForMcp() {
+  return {
+    tools: MCP_TOOL_DEFINITIONS,
+    protocols: getProtocolModules(),
+    commonParams: EVM_COMMON_PARAM_DOCS,
+    multisignOutput: MULTISIGN_OUTPUT_DOC,
+    workflow: {
+      evmSwapTypical: [
+        "1. Quote (protocol-specific API if needed)",
+        "2. Build protocol calldata (e.g. create_swap)",
+        "3. build_*_multisign \u2192 { bodyForSign, messageToSign }",
+        "4. Sign messageToSign (MetaMask or Ed25519)",
+        "5. POST /multiSignRequest with clientSig and signedMessage"
+      ]
+    }
+  };
+}
+
+// src/agent/catalog.ts
+registerProtocolModule(uniswapV4ProtocolModule);
+registerProtocolModule(curveDaoProtocolModule);
+function getAgentCatalog() {
+  return {
+    protocols: getProtocolModules(),
+    byCategory: {
+      evm: getActionsByChainCategory("evm"),
+      solana: getActionsByChainCategory("solana"),
+      near: getActionsByChainCategory("near")
+    },
+    uniswapV4: uniswapV4ProtocolModule,
+    curveDao: curveDaoProtocolModule,
+    /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
+    mcp: getAgentCatalogForMcp()
+  };
+}
+
+// src/index.ts
+registerProtocolModule(uniswapV4ProtocolModule);
+registerProtocolModule(curveDaoProtocolModule);
+
+export { NEAR_CHAIN_CATEGORY, SOLANA_CHAIN_CATEGORY, alignEip1559FeesWithLatestBase, buildEvmMultisignBatch, chainSnapshotForCustomGasExtraJSON, composeFeePayloadToTxParams, coreChainCategoryModule, curveDao, curveDaoProtocolModule, evmChainCategoryModule, fetchChainFeeParams, finalizeMultisign, firstClientIdFromKeyGen, gasLimitFromEstimateAndChainConfig, getActionsByChainCategory, getAgentCatalog, getProtocolModule, getProtocolModules, gweiToDecimalString, isEvmNativeToken, keyListFromKeyGen, matchEvmTokenKind, mergePurposeText, nearChainCategoryModule, nodeFetchWithReadAuth, parseEvmChainIdToNumber, proposalTxParamsToFeeSnapshot, registerProtocolModule, requirePubKeyHex, routerSwapGasLimitFromEstimate, solanaChainCategoryModule, triggerTxParamsFromComposeBody, uniswapV4, uniswapV4ProtocolModule };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map