@continuumdao/ctm-mpc-defi 0.2.22 → 0.2.24

package/dist/agent/skills/gmx/SKILL.md

@@ -24,6 +24,36 @@ Perpetuals on Arbitrum (42161) and Avalanche (43114) via `@gmx-io/sdk` v2 **clas
 
 Set `orderType: "limit"` and `triggerPriceUsdHuman` on increase/decrease builders.
 
+## Take profit / stop loss (increase only)
+
+On **increase** (market or limit), pass optional native GMX bracket triggers. Each defaults to the full `sizeUsdHuman` position.
+
+- `takeProfitPriceUsdHuman` — take-profit trigger (USD index)
+- `stopLossPriceUsdHuman` — stop-loss trigger (USD index)
+- `patternFailureUsdHuman` — audit / trade-idea alias; used as stop-loss when `stopLossPriceUsdHuman` is omitted
+
+Example long limit with TP/SL on Arbitrum:
+
+```json
+{
+  "keyGenId": "<keygen-id>",
+  "chainId": 42161,
+  "purposeText": "GMX long ETH limit with bracket",
+  "useCustomGas": false,
+  "symbol": "ETH/USD [WETH-USDC]",
+  "direction": "long",
+  "orderType": "limit",
+  "triggerPriceUsdHuman": "2900",
+  "takeProfitPriceUsdHuman": "3100",
+  "stopLossPriceUsdHuman": "2850",
+  "sizeUsdHuman": "200",
+  "collateralAmountHuman": "50",
+  "collateralToken": "USDC"
+}
+```
+
+TP/SL orders are keeper-executed asynchronously after the increase fills (same as limit entry).
+
 Example short limit on Arbitrum (ETH/USDC collateral):
 
 ```json

package/dist/agent/skills/hyperliquid/SKILL.md

@@ -124,6 +124,38 @@ Positions and orders from MCP reflect **live HyperCore state** after prior txs a
 
 Validate `szHuman` against `availableToBuy` / `availableToSell` from `fetch_open_context`.
 
+## Bracket limit order (TP/SL on open)
+
+When **`takeProfitTriggerPxHuman`** and/or **`stopLossTriggerPxHuman`** are set on `ctm_hyperliquid_build_limit_order_multisign`, the tool submits **one L1 EIP-712** action with `grouping: "normalTpsl"` (entry + TP/SL children). This is **not** CoreWriter — no HyperEVM gas at Execute; deliver signature to Hyperliquid `/exchange` (same path as `update_leverage`).
+
+- **Auto from trade ideas:** map target → TP, invalidation → SL when both levels exist after desk offsets (`targetOffsetPct` / `targetOffsetMode` in `trade-desk.yaml` — conservative TP **inside** target: long below, short above; `price` or `atr` mode).
+- **Geometry:** long → SL < entry < TP; short → TP < entry < SL.
+- **`tpslExecMode`:** `limit_at_trigger` (default — limit px = trigger px) or `market` (10% slippage tolerance on HL). Configure default in trade-desk / node trade defaults under `hyperliquid.tpslExecMode`.
+- **`targetOffsetPct` / `targetOffsetMode`:** desk defaults under `hyperliquid` — pull TP inside analysis target (`price` = % of target; `atr` = % of one ATR bar from analysis OHLCV).
+- **OCO semantics:** TP/SL children activate when the entry order **fully fills**. If the parent is canceled before fill, children are canceled. Untriggered children do **not** appear in `fetch_open_orders` until entry fills.
+
+```json
+{
+  "keyGen": { "pubkeyhex": "…", "keylist": ["…"] },
+  "chainId": 999,
+  "rpcUrl": "https://…",
+  "executorAddress": "0x…",
+  "chainDetail": {},
+  "purposeText": "HL long BTC 0.01 @ 95000 TP 100000 SL 90000",
+  "useCustomGas": false,
+  "coin": "BTC",
+  "isBuy": true,
+  "limitPxHuman": "95000",
+  "szHuman": "0.01",
+  "tif": "gtc",
+  "takeProfitTriggerPxHuman": "100000",
+  "stopLossTriggerPxHuman": "90000",
+  "tpslExecMode": "limit_at_trigger"
+}
+```
+
+After `{ requestId }`: `sign_request_agree` → `trigger_sign_result` **without txParams** → Execute posts to `/exchange`.
+
 ## Close position example
 
 Use `isLong: true` for a **long** position (submits sell reduce-only IoC):

package/dist/agent/skills/uniswap-v4/SKILL.md

@@ -132,6 +132,30 @@ Assume 0.1 ETH = `100000000000000000` wei.
 
 Use the same `swapTransactionDeadlineUnix` in step 2 and `swapDeadlineUnix` in step 3.
 
+## Limit orders (UniswapX — Ethereum mainnet only)
+
+Official UniswapX limit orders are **chainId 1 only** (not Robinhood 4663 or L2s today). Flow:
+
+| Step | Tool | Creates sign request? |
+|------|------|------------------------|
+| 1. Quote | `ctm_uniswap_v4_limit_order_quote` | No — quote + `permitData` |
+| 2. Submit | `ctm_uniswap_v4_build_limit_order_multisign` | Yes → EIP-712 `{ requestId }` → delivery POST `/v1/order` |
+
+Optional: `ctm_uniswap_v4_fetch_limit_orders` — list open orders for swapper.
+
+Trade-build bridge: `build_trade_from_*` with `protocolId: uniswap`, `chainId: 1`, `orderKind: limit`.
+
+## Take-profit / stop-loss (agent monitor)
+
+Uniswap spot has **no native TP/SL** like Hyperliquid. Use:
+
+- `evaluate_uniswap_tpsl_monitor` — price vs TP/SL levels
+- `register_uniswap_tpsl_monitor_cron` — creates a polling cron job that triggers **market swap** exits
+
+Best-effort only — not exchange-grade resting orders. Template: `uniswap-tpsl-monitor-cron.example.md`.
+
+Robinhood Chain (4663) OHLCV for monitors uses **Bitquery** (`BITQUERY_API_KEY`); other OHLCV chains use The Graph.
+
 ## Teaching users about slippage
 
 - **Quote slippage** (`slippage` on quote, default 0.5%): Trade API routing tolerance.
@@ -217,8 +241,9 @@ OHLCV is **only** available on chains with a pinned public Uniswap V4 subgraph o
 | 81457 | Blast |
 | 42161 | Arbitrum |
 | 43114 | Avalanche |
+| 4663 | Robinhood (Bitquery OHLCV — not limit orders) |
 
-**Swap / LP / quote tools** work on all `supportedChainIds` (~20+ EVM chains). On chains **without** a pinned subgraph (e.g. zkSync `324`, Celo `42220`, World Chain `480`, Linea `59144`, Zora `7777777`), use **CoinGecko/CoinMarketCap time series** via `get_defi_protocol_fetch_options` — do not call `fetch_ohlcv`.
+**Swap / LP / quote tools** work on all `supportedChainIds` (~20+ EVM chains). **Limit orders** are **mainnet (1) only**. On chains **without** a pinned subgraph (e.g. zkSync `324`, Celo `42220`, World Chain `480`, Linea `59144`, Zora `7777777`), use **CoinGecko/CoinMarketCap time series** via `get_defi_protocol_fetch_options` — do not call `fetch_ohlcv`.
 
 All OHLCV tiers (native subgraph, subgraph aggregation, sub-hour swap bucketing) require the same subgraph; there is no RPC-only fallback.
 

package/dist/core/index.d.ts

@@ -1,9 +1,9 @@
-import { K as KeyGenSubset, M as MultisignBuildResult } from '../types-PZrvtjv8.js';
-export { C as ChainCategory, a as ChainSupportContext, E as EvmTokenKind, b as KeyGenSubsetForPermit, c as MultisignCommonArgs, N as NearTokenKind, P as ParamDoc, d as ProtocolActionDescriptor, e as ProtocolModule, S as SolanaTokenKind, T as TokenRef } from '../types-PZrvtjv8.js';
+export { C as ChainCategory, a as ChainSupportContext, E as EvmTokenKind, K as KeyGenSubset, b as KeyGenSubsetForPermit, M as MultisignBuildResult, c as MultisignCommonArgs, N as NearTokenKind, P as ParamDoc, d as ProtocolActionDescriptor, e as ProtocolModule, S as SolanaTokenKind, T as TokenRef } from '../types-PZrvtjv8.js';
 export { getClientIdFromKeyGenResult as firstClientIdFromKeyGen } from '@continuumdao/continuum-node-sdk';
 export { C as ChainCategoryBuildInput, a as ChainCategoryModule, M as MultisignLeg, c as coreChainCategoryModule, f as finalizeMultisign } from '../envelope-C_bfuKab.js';
 export { g as getActionsByChainCategory, a as getProtocolModule, b as getProtocolModules, r as registerProtocolModule } from '../registry-DxDSPQ-p.js';
-import { TypedDataDomain } from 'viem';
+export { B as BuildEip712MultisignBodyArgs, E as EIP712_SIGN_REQUEST_KIND, a as Eip712MultisignDelivery, b as Eip712TypedDataField, c as Eip712TypedDataPayload, d as buildEip712MultisignBody } from '../eip712Multisign-xhXpUYp3.js';
+import 'viem';
 
 /** Merge user purpose text with an optional batch / protocol suffix. */
 declare function mergePurposeText(purposeText: string | undefined, purposeSuffix?: string): string;
@@ -29,42 +29,10 @@ declare function postJsonViaOptionalProxy<T>(args: {
     proxyEnvelope?: unknown;
 }): Promise<T>;
 
-declare const EIP712_SIGN_REQUEST_KIND: "eip712";
-type Eip712TypedDataField = {
-    name: string;
-    type: string;
-};
-type Eip712TypedDataPayload = {
-    domain: TypedDataDomain;
-    types: Record<string, readonly Eip712TypedDataField[] | Eip712TypedDataField[]>;
-    primaryType: string;
-    message: Record<string, unknown>;
-};
-type Eip712MultisignDelivery = Record<string, unknown> & {
-    kind: string;
-};
-type BuildEip712MultisignBodyArgs = {
-    keyGen: KeyGenSubset;
-    purposeText: string;
-    purposeSuffix?: string;
-    /** Chain id stored on the sign request (protocol context; may differ from EIP-712 domain chainId). */
-    destinationChainID: string;
-    destinationAddress: string;
-    typedData: Eip712TypedDataPayload;
-    delivery: Eip712MultisignDelivery;
-    audit?: Record<string, unknown>;
-    expiryDate?: number;
-};
-/**
- * Build an mpc-auth multiSignRequest body for a single-leg EIP-712 digest (no EVM tx broadcast).
- * `msgHash` is the EIP-712 hash; `msgRaw` is UTF-8 hex JSON audit envelope (not RLP calldata).
- */
-declare function buildEip712MultisignBody(args: BuildEip712MultisignBodyArgs): MultisignBuildResult;
-
 /** Default MPC sign-request agreement window for fast-moving DeFi protocols (30 minutes). */
 declare const DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS: number;
 /** Protocol ids that default to 30-minute expiry when `expiryDate` is omitted on multisign MCP tools. */
 declare const DEFI_PROTOCOLS_WITH_30MIN_EXPIRY: Set<string>;
 declare function defiMultisignExpiryUnixSeconds(protocolId: string | undefined, explicitExpiryDate?: number | null): number | undefined;
 
-export { type BuildEip712MultisignBodyArgs, DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS, DEFI_PROTOCOLS_WITH_30MIN_EXPIRY, EIP712_SIGN_REQUEST_KIND, type Eip712MultisignDelivery, type Eip712TypedDataField, type Eip712TypedDataPayload, KeyGenSubset, MultisignBuildResult, buildEip712MultisignBody, defiMultisignExpiryUnixSeconds, getAaveGraphqlProxyUrl, getCoingeckoProxyUrl, getEulerGraphqlProxyUrl, getMapleGraphqlProxyUrl, getMorphoGraphqlProxyUrl, mergePurposeText, postJsonViaOptionalProxy, setAaveGraphqlProxyUrl, setCoingeckoProxyUrl, setEulerGraphqlProxyUrl, setMapleGraphqlProxyUrl, setMorphoGraphqlProxyUrl };
+export { DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS, DEFI_PROTOCOLS_WITH_30MIN_EXPIRY, defiMultisignExpiryUnixSeconds, getAaveGraphqlProxyUrl, getCoingeckoProxyUrl, getEulerGraphqlProxyUrl, getMapleGraphqlProxyUrl, getMorphoGraphqlProxyUrl, mergePurposeText, postJsonViaOptionalProxy, setAaveGraphqlProxyUrl, setCoingeckoProxyUrl, setEulerGraphqlProxyUrl, setMapleGraphqlProxyUrl, setMorphoGraphqlProxyUrl };

package/dist/eip712Multisign-xhXpUYp3.d.ts

@@ -0,0 +1,36 @@
+import { TypedDataDomain } from 'viem';
+import { K as KeyGenSubset, M as MultisignBuildResult } from './types-PZrvtjv8.js';
+
+declare const EIP712_SIGN_REQUEST_KIND: "eip712";
+type Eip712TypedDataField = {
+    name: string;
+    type: string;
+};
+type Eip712TypedDataPayload = {
+    domain: TypedDataDomain;
+    types: Record<string, readonly Eip712TypedDataField[] | Eip712TypedDataField[]>;
+    primaryType: string;
+    message: Record<string, unknown>;
+};
+type Eip712MultisignDelivery = Record<string, unknown> & {
+    kind: string;
+};
+type BuildEip712MultisignBodyArgs = {
+    keyGen: KeyGenSubset;
+    purposeText: string;
+    purposeSuffix?: string;
+    /** Chain id stored on the sign request (protocol context; may differ from EIP-712 domain chainId). */
+    destinationChainID: string;
+    destinationAddress: string;
+    typedData: Eip712TypedDataPayload;
+    delivery: Eip712MultisignDelivery;
+    audit?: Record<string, unknown>;
+    expiryDate?: number;
+};
+/**
+ * Build an mpc-auth multiSignRequest body for a single-leg EIP-712 digest (no EVM tx broadcast).
+ * `msgHash` is the EIP-712 hash; `msgRaw` is UTF-8 hex JSON audit envelope (not RLP calldata).
+ */
+declare function buildEip712MultisignBody(args: BuildEip712MultisignBodyArgs): MultisignBuildResult;
+
+export { type BuildEip712MultisignBodyArgs as B, EIP712_SIGN_REQUEST_KIND as E, type Eip712MultisignDelivery as a, type Eip712TypedDataField as b, type Eip712TypedDataPayload as c, buildEip712MultisignBody as d };

package/dist/index.cjs

@@ -616,8 +616,18 @@ var UNIVERSAL_ROUTER_SPENDER = {
   143: "0x0d97dc33264bfc1c226207428a79b26757fb9dc3",
   59144: "0x661e93cca42afacb172121ef892830ca3b70f08d",
   4217: "0x1febb76be10aaf3a1402f04e8e835f2c382f7914",
-  196: "0x5507749f2c558bb3e162c6e90c314c092e7372ff"
+  196: "0x5507749f2c558bb3e162c6e90c314c092e7372ff",
+  /** Robinhood Chain mainnet — Universal Router v2.1.1 (Trade API / interface) */
+  4663: "0x8876789976decbfcbbbe364623c63652db8c0904"
 };
+var UNIVERSAL_ROUTER_VERSION_BY_CHAIN = {
+  /** Robinhood has UR 2.1.1 only in the supported-chains table (no 2.0 Trade API column). */
+  4663: "2.1.1"
+};
+function getUniswapUniversalRouterVersion(chainId) {
+  const v = UNIVERSAL_ROUTER_VERSION_BY_CHAIN[chainId];
+  return typeof v === "string" && v.trim() ? v.trim() : UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT;
+}
 function isUniswapV4ChainSupported(chainId) {
   if (chainId == null) return false;
   const n = parseEvmChainIdToNumber(chainId);
@@ -652,7 +662,9 @@ var POSITION_MANAGER_BY_CHAIN = {
   11155111: "0x4B2C77d209D3405F41a037Ec6c77F7F5b8e2ca80",
   130: "0x0d97dc33264bfc1c226207428a79b26757fb9dc3",
   1868: "0x0e2850543f69f678257266e0907ff9a58b3f13de",
-  59144: "0x661e93cca42afacb172121ef892830ca3b70f08d"
+  59144: "0x661e93cca42afacb172121ef892830ca3b70f08d",
+  /** Robinhood Chain mainnet */
+  4663: "0x58daec3116aae6D93017bAAea7749052E8a04fA7"
 };
 function getUniswapV4PositionManagerOrThrow(chainId) {
   const raw = POSITION_MANAGER_BY_CHAIN[chainId];
@@ -699,8 +711,8 @@ function parseUniswapChainId(value) {
 function trimAddr(a) {
   return a.trim();
 }
-function isUniswapTokenInAddressNative(tokenIn) {
-  const t = (tokenIn ?? "").toString().trim();
+function isUniswapNativeTokenAddress(token) {
+  const t = (token ?? "").toString().trim();
   if (!t) return false;
   try {
     return viem.getAddress(t) === viem.zeroAddress;
@@ -715,7 +727,16 @@ function isUniswapFullQuoteResponseNativeIn(stored) {
   const input = q.input;
   if (!input) return false;
   const raw = (input.address ?? input.token ?? "").toString().trim();
-  return isUniswapTokenInAddressNative(raw);
+  return isUniswapNativeTokenAddress(raw);
+}
+function isUniswapFullQuoteResponseNativeOut(stored) {
+  if (!stored) return false;
+  const q = stored.quote;
+  if (!q || typeof q !== "object" || Array.isArray(q)) return false;
+  const output = q.output;
+  if (!output) return false;
+  const raw = (output.address ?? output.token ?? "").toString().trim();
+  return isUniswapNativeTokenAddress(raw);
 }
 async function fetchEthereumAddressForKeyGen(managementNodeUrl, keyGenId, readAuth = { bearerOnGet: true, jwt: null }, init) {
   const base = managementNodeUrl.trim().replace(/\/$/, "");
@@ -777,6 +798,31 @@ function buildUniswapQuoteRequestBody(args) {
   }
   return body;
 }
+function resolveChainIdFromStoredUniswapQuote(stored) {
+  if (!stored) return 0;
+  const top = stored;
+  for (const key of ["tokenInChainId", "chainId"]) {
+    const raw = top[key];
+    if (raw != null && String(raw).trim() !== "") {
+      try {
+        return parseUniswapChainId(raw);
+      } catch {
+      }
+    }
+  }
+  const q = top.quote;
+  if (q && typeof q === "object" && !Array.isArray(q)) {
+    const input = q.input;
+    const chain = input?.chainId;
+    if (chain != null && String(chain).trim() !== "") {
+      try {
+        return parseUniswapChainId(chain);
+      } catch {
+      }
+    }
+  }
+  return 0;
+}
 function errorMessageFromUniswapJsonBody(value) {
   if (value == null) return null;
   if (typeof value === "string") {
@@ -889,16 +935,18 @@ async function uniswapTradeQuote(args) {
   }
   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 chainIdForRouter = parseUniswapChainId(resolveInputChainId(args));
+  const urv = args.universalRouterVersion && args.universalRouterVersion.trim() || getUniswapUniversalRouterVersion(chainIdForRouter);
   const body = buildUniswapQuoteRequestBody({ ...args, swapper });
-  const nativeIn = isUniswapTokenInAddressNative(args.tokenIn);
+  const nativeIn = isUniswapNativeTokenAddress(args.tokenIn);
+  const nativeOut = isUniswapNativeTokenAddress(args.tokenOut);
   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"
+    /** Native (0x0) in or out: enables ERC20↔ETH routes (incl. UniswapX on Robinhood). */
+    "x-erc20eth-enabled": nativeIn || nativeOut ? "true" : "false"
   };
   const fetchFn = args.fetchImpl ?? globalThis.fetch;
   const res = await fetchFn(quoteUrl, {
@@ -909,7 +957,11 @@ async function uniswapTradeQuote(args) {
   });
   const text = await res.text();
   if (!res.ok) {
-    throw new Error(messageFromUniswapHttpResponseBody(text, res.status, res.statusText));
+    let msg = messageFromUniswapHttpResponseBody(text, res.status, res.statusText);
+    if (res.status === 404 && chainIdForRouter === 4663) {
+      msg += " On Robinhood Chain, confirm USDG is 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168, use Native ETH or WETH (0x0Bd7\u2026) as output, and try at least ~$300 notional (UniswapX minimum).";
+    }
+    throw new Error(msg);
   }
   const forParse = text.replace(/^\uFEFF/, "");
   try {
@@ -1016,16 +1068,17 @@ async function uniswapCreateSwap(args) {
     quote: classic,
     deadline
   };
-  const urv = (args.universalRouterVersion ?? UNISWAP_UNIVERSAL_ROUTER_VERSION_DEFAULT).trim() || "2.0";
+  const urv = (args.universalRouterVersion ?? "").trim() || getUniswapUniversalRouterVersion(resolveChainIdFromStoredUniswapQuote(args.fullQuoteFromPermit));
   const fn = args.fetchImpl ?? globalThis.fetch;
   const nativeIn = isUniswapFullQuoteResponseNativeIn(args.fullQuoteFromPermit);
+  const nativeOut = isUniswapFullQuoteResponseNativeOut(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-erc20eth-enabled": nativeIn || nativeOut ? "true" : "false",
       "x-permit2-disabled": "true"
     },
     body: JSON.stringify(body)
@@ -2225,6 +2278,270 @@ async function swapExactInput(args) {
   return swapFromQuote({ ...args, swap });
 }
 
+// src/protocols/evm/uniswap-v4/limitOrder.ts
+function trimAddr3(a) {
+  return a.trim();
+}
+var UNISWAP_LIMIT_ORDER_CHAIN_ID = 1;
+var DEFAULT_UNISWAPX_ORDER_BASE = "https://api.uniswap.org/v2";
+var DEFAULT_LIMIT_ORDER_QUOTE_PATH = "/limit_order_quote";
+var UNISWAP_QUOTE_HEADERS_BASE2 = {
+  "Content-Type": "application/json",
+  "User-Agent": "ctm-mpc-defi uniswapLimitOrderQuote/1.0 (TS)"
+};
+function isUniswapLimitOrderChainSupported(chainId) {
+  return parseUniswapChainId(chainId) === UNISWAP_LIMIT_ORDER_CHAIN_ID;
+}
+function assertUniswapLimitOrderChain(chainId) {
+  if (!isUniswapLimitOrderChainSupported(chainId)) {
+    throw new Error(
+      `UniswapX limit orders are only supported on Ethereum mainnet (chainId ${UNISWAP_LIMIT_ORDER_CHAIN_ID}). Got ${chainId}. Use market swap on this chain or wait for UniswapX limit support.`
+    );
+  }
+}
+function inferPrimaryTypeFromPermitTypes(types) {
+  for (const key of Object.keys(types)) {
+    if (key !== "EIP712Domain") {
+      return key;
+    }
+  }
+  throw new Error("permitData.types missing primaryType (no non-EIP712Domain entry)");
+}
+function permitDataToEip712Payload(permitData) {
+  const domain = permitData.domain;
+  const types = permitData.types;
+  const message = permitData.values ?? permitData.message;
+  if (domain == null || typeof domain !== "object" || Array.isArray(domain)) {
+    throw new Error("limit order quote: permitData.domain missing");
+  }
+  if (types == null || typeof types !== "object" || Array.isArray(types)) {
+    throw new Error("limit order quote: permitData.types missing");
+  }
+  if (message == null || typeof message !== "object" || Array.isArray(message)) {
+    throw new Error("limit order quote: permitData.values (message) missing");
+  }
+  const primaryType = typeof permitData.primaryType === "string" && permitData.primaryType.trim() ? permitData.primaryType.trim() : inferPrimaryTypeFromPermitTypes(
+    types
+  );
+  return {
+    domain,
+    types,
+    primaryType,
+    message
+  };
+}
+function extractPermitDataFromLimitQuote(quoteResponse) {
+  const permitData = quoteResponse.permitData;
+  if (permitData == null) return null;
+  if (typeof permitData !== "object" || Array.isArray(permitData)) {
+    throw new Error("limit order quote: permitData is not an object");
+  }
+  return permitData;
+}
+function buildLimitOrderQuoteRequestBody(args) {
+  const base = buildUniswapQuoteRequestBody({
+    type: args.type,
+    amount: args.amount,
+    tokenIn: args.tokenIn,
+    tokenOut: args.tokenOut,
+    chainId: args.chainId,
+    tokenInChainId: args.tokenInChainId,
+    tokenOutChainId: args.tokenOutChainId,
+    swapper: args.swapper
+  });
+  assertUniswapLimitOrderChain(base.tokenInChainId);
+  return {
+    ...base,
+    limitPrice: String(args.limitPrice).trim(),
+    orderDeadline: args.orderDeadline
+  };
+}
+async function uniswapLimitOrderQuote(args) {
+  const apiKey = (args.uniswapApiKey || "").trim();
+  if (!apiKey) {
+    throw new Error("uniswapApiKey (x-api-key) is required");
+  }
+  let swapper;
+  if ((args.swapper || "").trim()) {
+    swapper = trimAddr3(args.swapper);
+  } else {
+    const keyGen = (args.keyGen || "").trim();
+    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 chainIdForGuard = parseUniswapChainId(resolveInputChainId(args));
+  assertUniswapLimitOrderChain(chainIdForGuard);
+  const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : "https://trade-api.gateway.uniswap.org/v1";
+  const quoteUrl = `${base}${DEFAULT_LIMIT_ORDER_QUOTE_PATH}`;
+  const body = buildLimitOrderQuoteRequestBody({ ...args, swapper });
+  const headers = {
+    ...UNISWAP_QUOTE_HEADERS_BASE2,
+    "x-api-key": apiKey
+  };
+  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(
+      `Limit order quote: ${messageFromUniswapHttpResponseBody(text, res.status, res.statusText)}`
+    );
+  }
+}
+function buildUniswapXLimitOrderSubmitBody(args) {
+  const quote = args.quoteResponse.quote;
+  if (quote == null || typeof quote !== "object" || Array.isArray(quote)) {
+    throw new Error("limit order submit: quoteResponse.quote missing");
+  }
+  const routing = typeof args.quoteResponse.routing === "string" && args.quoteResponse.routing.trim() ? args.quoteResponse.routing.trim() : "LIMIT_ORDER";
+  const chainId = args.quoteResponse.chainId ?? quote.chainId ?? UNISWAP_LIMIT_ORDER_CHAIN_ID;
+  const quoteId = typeof args.quoteResponse.quoteId === "string" ? args.quoteResponse.quoteId : void 0;
+  const requestId = typeof args.quoteResponse.requestId === "string" ? args.quoteResponse.requestId : void 0;
+  return {
+    signature: args.signatureHex.startsWith("0x") ? args.signatureHex : `0x${args.signatureHex}`,
+    quote,
+    chainId: parseUniswapChainId(chainId),
+    orderType: "Limit",
+    routing,
+    ...quoteId ? { quoteId } : {},
+    ...requestId ? { requestId } : {}
+  };
+}
+async function fetchUniswapXLimitOrders(args) {
+  const chainId = args.chainId ?? UNISWAP_LIMIT_ORDER_CHAIN_ID;
+  assertUniswapLimitOrderChain(chainId);
+  const base = args.baseUrl && args.baseUrl.trim() ? args.baseUrl.trim().replace(/\/$/, "") : DEFAULT_UNISWAPX_ORDER_BASE;
+  const params = new URLSearchParams({
+    chainId: String(chainId),
+    swapper: trimAddr3(args.swapper)
+  });
+  if (args.limit != null && args.limit > 0) {
+    params.set("limit", String(Math.floor(args.limit)));
+  }
+  const url = `${base}/limit-orders?${params.toString()}`;
+  const headers = {
+    Accept: "application/json",
+    "User-Agent": "ctm-mpc-defi uniswapLimitOrdersList/1.0 (TS)"
+  };
+  const apiKey = (args.uniswapApiKey || "").trim();
+  if (apiKey) {
+    headers["x-api-key"] = apiKey;
+  }
+  const fetchFn = args.fetchImpl ?? globalThis.fetch;
+  const res = await fetchFn(url, { method: "GET", headers });
+  const text = await res.text();
+  if (!res.ok) {
+    const parsed = (() => {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return null;
+      }
+    })();
+    const msg = errorMessageFromUniswapJsonBody(parsed) ?? (text.trim() || res.statusText);
+    throw new Error(`List limit orders HTTP ${res.status}: ${msg}`);
+  }
+  return JSON.parse(text.replace(/^\uFEFF/, ""));
+}
+async function uniswapFetchLimitOrdersMcp(args) {
+  let swapper;
+  if ((args.swapper || "").trim()) {
+    swapper = trimAddr3(args.swapper);
+  } else {
+    const keyGen = (args.keyGen || "").trim();
+    if (!keyGen) {
+      throw new Error("swapper or keyGen is required");
+    }
+    const mpc = (args.managementNodeUrl || "").trim();
+    if (!mpc) {
+      throw new Error("managementNodeUrl is required when swapper is not provided");
+    }
+    swapper = await fetchEthereumAddressForKeyGen(
+      mpc,
+      keyGen,
+      args.nodeReadAuth ?? { bearerOnGet: true, jwt: null }
+    );
+  }
+  return fetchUniswapXLimitOrders({
+    swapper,
+    chainId: args.chainId,
+    uniswapApiKey: args.uniswapApiKey,
+    limit: args.limit,
+    baseUrl: args.baseUrl,
+    fetchImpl: args.fetchImpl
+  });
+}
+async function buildEvmMultisignBodyUniswapV4LimitOrderBatch(args) {
+  assertUniswapLimitOrderChain(args.chainId);
+  const permitRaw = extractPermitDataFromLimitQuote(args.fullLimitQuote);
+  if (!permitRaw) {
+    throw new Error(
+      "Limit order quote has no permitData \u2014 cannot build EIP-712 sign request. Re-quote or confirm mainnet limit order support for this pair."
+    );
+  }
+  const typedData = permitDataToEip712Payload(permitRaw);
+  const submitTemplate = buildUniswapXLimitOrderSubmitBody({
+    quoteResponse: args.fullLimitQuote,
+    signatureHex: "0x"
+  });
+  return buildEip712MultisignBody({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(UNISWAP_LIMIT_ORDER_CHAIN_ID),
+    destinationAddress: PERMIT2_ADDRESS,
+    typedData,
+    delivery: {
+      kind: "uniswapx_limit_order",
+      chainId: UNISWAP_LIMIT_ORDER_CHAIN_ID,
+      swapper: viem.getAddress(args.swapper),
+      submitBodyTemplate: submitTemplate,
+      quoteResponse: args.fullLimitQuote,
+      uniswapApiKey: args.uniswapApiKey,
+      tradeApiBaseUrl: args.tradeApiBaseUrl ?? "https://trade-api.gateway.uniswap.org/v1"
+    },
+    audit: {
+      protocol: "uniswap-v4",
+      action: "limitOrder",
+      routing: args.fullLimitQuote.routing ?? "LIMIT_ORDER",
+      orderType: "Limit",
+      primaryType: typedData.primaryType
+    },
+    expiryDate: args.expiryDate
+  });
+}
+async function buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp(args) {
+  return buildEvmMultisignBodyUniswapV4LimitOrderBatch({
+    keyGen: args.keyGen,
+    chainId: args.chainId,
+    purposeText: args.purposeText,
+    fullLimitQuote: args.fullLimitQuote,
+    swapper: viem.getAddress(args.executorAddress),
+    uniswapApiKey: args.uniswapApiKey,
+    tradeApiBaseUrl: args.tradeApiBaseUrl,
+    expiryDate: args.expiryDate
+  });
+}
+
 // src/protocols/evm/uniswap-v4/index.ts
 var UNISWAP_V4_PROTOCOL_ID = "uniswap-v4";
 var uniswapV4ProtocolModule = {
@@ -2271,6 +2588,17 @@ var uniswapV4ProtocolModule = {
         type: { type: "EXACT_INPUT | EXACT_OUTPUT", required: true, description: "Trade type" }
       }
     },
+    {
+      id: "uniswap-v4.limit-order",
+      protocolId: UNISWAP_V4_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place UniswapX limit order via EIP-712 sign + POST /order (Ethereum mainnet only)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        fullLimitQuote: { type: "object", required: true, description: "Full limit order quote from Trade API" },
+        uniswapApiKey: { type: "string", required: true, description: "Uniswap Trade API key" }
+      }
+    },
     {
       id: "uniswap-v4.mint-liquidity",
       protocolId: UNISWAP_V4_PROTOCOL_ID,
@@ -2326,6 +2654,10 @@ var uniswapV4 = {
   swapExactInput,
   swapFromQuote,
   buildSwapMultisignBody: buildEvmMultisignBodyUniswapV4SkipPermit2Batch,
+  limitOrderQuote: uniswapLimitOrderQuote,
+  buildLimitOrderMultisignBody: buildEvmMultisignBodyUniswapV4LimitOrderBatchFromMcp,
+  fetchLimitOrders: fetchUniswapXLimitOrders,
+  fetchLimitOrdersMcp: uniswapFetchLimitOrdersMcp,
   quote: uniswapTradeQuote,
   createLiquidityPosition: uniswapLpCreatePosition,
   increaseLiquidityPosition: uniswapLpIncreasePosition,