@continuumdao/ctm-mpc-defi 0.2.47 → 0.2.49

package/dist/protocols/evm/derive/index.js

@@ -0,0 +1,2536 @@
+import { parseAbi, getAddress, parseUnits, encodeAbiParameters, keccak256, toHex, hashTypedData, hashMessage, stringToHex, encodeFunctionData, defineChain, createPublicClient, parseGwei, serializeTransaction, http } from 'viem';
+import { getClientIdFromKeyGenResult, fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase } from '@continuumdao/continuum-node-sdk';
+
+// 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);
+  }
+}
+
+// src/protocols/evm/derive/constants.ts
+var DERIVE_PROTOCOL_ID = "derive";
+var DERIVE_MATCHING_VERIFYING_CONTRACT = "0xeB8d770ec18DB98Db922E9D83260A585b9F0DeAD";
+var DERIVE_ACTION_TYPEHASH = "0x4d7a9f27c403ff9c0f19bce61d76d82f9aa29f8d6d4b0c5474607d9770d1af17";
+var DERIVE_TRADE_MODULE = "0xB8D20c2B7a1Ad2EE33Bc50eF10876eD3035b5e7b";
+var DERIVE_TRANSFER_MODULE = "0x01259207A40925b794C8ac320456F7F6c8FE2636";
+var DERIVE_DOMAIN_SEPARATOR_MAINNET = "0xda616dfabb88681b08e1592820a41d55ddc62d68de110e327ae99d734506fe19";
+var DERIVE_DOMAIN_SEPARATOR_TESTNET = "0x24d674cd5f2b9d564691c51e9d88f649b99246a2244dd74ce27b96578d773e85";
+var DERIVE_MAINNET_API = "https://api.derive.xyz/v3";
+var DERIVE_TESTNET_API = "https://testnet.api.derive.xyz/v3";
+var DERIVE_MAINNET_API_V2 = "https://api.lyra.finance";
+var DERIVE_TESTNET_API_V2 = "https://api-demo.lyra.finance";
+var DERIVE_ACTION_MANAGER_TESTNET = "0xd3625eCf97E5554C62A48Ac1c9284C9dCeFceB68";
+var DERIVE_EIP712_NAME = "Matching";
+var DERIVE_EIP712_VERSION = "1.0";
+var DERIVE_DEFAULT_SIGNATURE_EXPIRY_SEC = 300;
+var DERIVE_MIN_ORDER_EXPIRY_SEC = 10;
+var DERIVE_OHLCV_INTERVALS = ["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w"];
+var DERIVE_OHLCV_PERIOD_SEC = {
+  "1m": 60,
+  "5m": 300,
+  "15m": 900,
+  "30m": 1800,
+  "1h": 3600,
+  "4h": 14400,
+  "1d": 86400,
+  "1w": 604800
+};
+var DERIVE_DEFAULT_OHLCV_INTERVAL = "15m";
+var DERIVE_DEFAULT_OHLCV_BARS = 96;
+var DERIVE_DEFAULT_TICKER_ATM_STRIKES = 9;
+var DERIVE_DEFAULT_LOOKBACK_DAYS = 2;
+var DERIVE_MAX_LOOKBACK_DAYS = 90;
+var DERIVE_MAX_OHLCV_BARS = 2e3;
+var DERIVE_UNFUNDED_NOTES = "No Derive subaccount on this KeyGen. Fund from a logo row: Ethereum L1 USDC/WETH/WBTC (ctm_derive_build_deposit_new_subaccount_multisign or register_deposit_address + transfer), Socket USDC/WETH/WBTC on Optimism/Base/Arbitrum (ctm_derive_build_socket_deposit_multisign), or HyperEVM HYPE (ctm_derive_build_hype_vault_deposit_multisign). After credit, EIP-712 orders use Derive collateral.";
+var DERIVE_UNFUNDED_NEXT = [
+  "ctm_derive_fetch_risk_universes",
+  "ctm_derive_build_deposit_new_subaccount_multisign",
+  "ctm_derive_register_deposit_address",
+  "ctm_derive_build_socket_deposit_multisign",
+  "ctm_derive_build_hype_vault_deposit_multisign"
+];
+var DERIVE_MISSING_SUBACCOUNT_ERROR = "subaccountId is required and must come from ctm_derive_fetch_subaccounts. If that list is empty, fund from a Derive logo row (Ethereum L1, Socket on OP/Base/Arb, or HyperEVM HYPE). Do not use subaccount_id 0 for orders.";
+var DERIVE_SETTLEMENT_CHAIN_IDS = [1, 11155111];
+function deriveNetworkFromChainId(chainId) {
+  return chainId === 11155111 ? "testnet" : "mainnet";
+}
+function deriveSettlementChainId(network) {
+  return network === "testnet" ? 11155111 : 1;
+}
+function deriveApiBaseUrl(network = "mainnet") {
+  return network === "testnet" ? DERIVE_TESTNET_API : DERIVE_MAINNET_API;
+}
+function deriveApiFallbackBaseUrl(network = "mainnet") {
+  return network === "testnet" ? DERIVE_TESTNET_API_V2 : DERIVE_MAINNET_API_V2;
+}
+function deriveApiBaseUrlForChainId(chainId) {
+  return deriveApiBaseUrl(deriveNetworkFromChainId(chainId));
+}
+function deriveActionManagerAddress(chainId, override) {
+  const explicit = (override ?? process.env.DERIVE_ACTION_MANAGER ?? "").trim();
+  if (explicit) return getAddress(explicit);
+  if (chainId === 11155111) return DERIVE_ACTION_MANAGER_TESTNET;
+  throw new Error(
+    "Derive mainnet ACTION_MANAGER is not published yet. Pass actionManager or set DERIVE_ACTION_MANAGER. Testnet (11155111) uses the documented Sepolia address."
+  );
+}
+function isDeriveSettlementChainId(chainId) {
+  return DERIVE_SETTLEMENT_CHAIN_IDS.includes(chainId);
+}
+var DERIVE_ASSET_ROW_CHAIN_IDS = [1, 10, 8453, 42161, 999, 11155111];
+function isDeriveAssetRowChainId(chainId) {
+  return DERIVE_ASSET_ROW_CHAIN_IDS.includes(chainId);
+}
+function isDeriveChainSupported(chainId) {
+  return isDeriveAssetRowChainId(chainId);
+}
+var NATIVE_ZERO = "0x0000000000000000000000000000000000000000";
+var USDC = {
+  1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  10: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  42161: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  11155111: "0x73Efab09362052D26FB93A730Be4F8a5EdC833af"
+};
+var WETH = {
+  1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  10: "0x4200000000000000000000000000000000000006",
+  8453: "0x4200000000000000000000000000000000000006",
+  42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"
+};
+var WBTC = {
+  1: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+  10: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
+  42161: "0x2f2a2543B76A4166549B7eCDcE5542a773Aa44fB"
+};
+var WHYPE = "0x5555555555555555555555555555555555555555";
+function deriveMappedTokensForChain(chainId) {
+  const tokens = [];
+  const add = (address, symbol, decimals, roles) => {
+    if (!address) return;
+    tokens.push({ address: getAddress(address), symbol, decimals, roles });
+  };
+  if ([1, 10, 8453, 42161].includes(chainId)) {
+    add(NATIVE_ZERO, "ETH", 18, ["native", "underlying"]);
+    add(WETH[chainId], "WETH", 18, ["native_wrapped", "underlying"]);
+  }
+  if (chainId === 999) {
+    add(NATIVE_ZERO, "HYPE", 18, ["native", "collateral"]);
+    add(WHYPE, "WHYPE", 18, ["native_wrapped", "collateral"]);
+  }
+  add(USDC[chainId], "USDC", 6, ["collateral", "quote"]);
+  add(WBTC[chainId], "WBTC", 8, ["underlying", "collateral"]);
+  return tokens;
+}
+function deriveNativeWrappedForChain(chainId) {
+  if (chainId === 999) return WHYPE;
+  return WETH[chainId];
+}
+function deriveAdvisorNotes() {
+  return "Fund from Ethereum USDC/WETH/WBTC (L1 ACTION_MANAGER or deposit address), Socket USDC/WETH/WBTC on Optimism/Base/Arbitrum, or HyperEVM HYPE (vault). Derive Chain 957 is not a Continuum Assets chain. After credit, EIP-712 options use Derive collateral.";
+}
+function deriveKeyForNodeAssetRow(args) {
+  const raw = (args.contractAddress ?? "").trim();
+  if (!raw || raw.toLowerCase() === "native") {
+    const w = (args.nativeWrapped ?? "").trim();
+    if (!w) return NATIVE_ZERO;
+    try {
+      return getAddress(w).toLowerCase();
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const a = getAddress(raw);
+    if (a.toLowerCase() === NATIVE_ZERO && args.nativeWrapped) {
+      return getAddress(args.nativeWrapped.trim()).toLowerCase();
+    }
+    return a.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+
+// src/protocols/evm/derive/api.ts
+function methodName(method) {
+  return method.replace(/^\//, "");
+}
+function isDerivePublicMethod(method) {
+  return methodName(method).startsWith("public/");
+}
+function isEmptyDerivePublicResult(method, result) {
+  const m = methodName(method);
+  if (result == null) return true;
+  if (m === "public/get_all_currencies" && Array.isArray(result) && result.length === 0) return true;
+  if (m === "public/get_tickers" && result && typeof result === "object") {
+    const tickers = result.tickers;
+    if (Array.isArray(tickers) && tickers.length === 0) return true;
+    if (tickers && typeof tickers === "object" && !Array.isArray(tickers) && Object.keys(tickers).length === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function isDeriveRecoverablePublicError(err) {
+  const name = err instanceof Error ? err.name : "";
+  const msg = err instanceof Error ? err.message : String(err);
+  return name === "TimeoutError" || name === "AbortError" || /Internal error|HTTP 404|Not Found|returned empty|empty catalog|Ticker not found|aborted due to timeout|The operation was aborted/i.test(
+    msg
+  );
+}
+function unwrapResult(json, method) {
+  if (json && typeof json === "object") {
+    const rec = json;
+    if (rec.error) {
+      const err = rec.error;
+      const detail = err.data != null && String(err.data).trim() ? ` (${String(err.data).slice(0, 160)})` : "";
+      throw new Error(`Derive ${method} failed: ${err.message ?? JSON.stringify(rec.error)}${detail}`);
+    }
+    if ("result" in rec) return rec.result;
+  }
+  return json;
+}
+async function deriveRpcPost(args) {
+  const method = methodName(args.method);
+  const headers = { "Content-Type": "application/json" };
+  if (args.auth) {
+    headers["X-DeriveWallet"] = args.auth.wallet;
+    headers["X-DeriveTimestamp"] = args.auth.timestamp;
+    headers["X-DeriveSignature"] = args.auth.signature;
+  }
+  const res = await fetch(`${args.base}/${method}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(args.params ?? {}),
+    cache: "no-store",
+    signal: AbortSignal.timeout(15e3)
+  });
+  const text = await res.text().catch(() => "");
+  if (!res.ok || !text.trim() || text.trim() === "Not Found") {
+    throw new Error(`Derive ${method} HTTP ${res.status}: ${text.slice(0, 240) || "empty body"}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new Error(`Derive ${method} returned non-JSON: ${text.slice(0, 160)}`);
+  }
+  const result = unwrapResult(json, method);
+  if (isEmptyDerivePublicResult(method, result)) {
+    throw new Error(`Derive ${method} returned empty catalog`);
+  }
+  return result;
+}
+async function deriveRpc(args) {
+  const network = args.network ?? "mainnet";
+  const method = methodName(args.method);
+  const primary = deriveApiBaseUrl(network);
+  try {
+    return await deriveRpcPost({
+      base: primary,
+      method,
+      params: args.params,
+      auth: args.auth
+    });
+  } catch (err) {
+    const fallback = deriveApiFallbackBaseUrl(network);
+    if (!isDerivePublicMethod(method) || fallback === primary || !isDeriveRecoverablePublicError(err)) {
+      throw err;
+    }
+    return await deriveRpcPost({
+      base: fallback,
+      method,
+      params: args.params,
+      auth: args.auth
+    });
+  }
+}
+function requireDeriveAuth(auth, toolHint) {
+  if (!auth?.wallet?.trim() || !auth?.timestamp?.trim() || !auth?.signature?.trim()) {
+    throw new Error(
+      `${toolHint} needs EIP-191 login headers (X-DeriveWallet / X-DeriveTimestamp / X-DeriveSignature). The node caches one personal_sign of a millisecond timestamp for the KeyGen executor.`
+    );
+  }
+  return auth;
+}
+
+// src/protocols/evm/derive/assets.ts
+async function deriveFetchInstrument(args) {
+  const name = args.instrumentName.trim().toUpperCase();
+  if (!name) throw new Error("instrumentName is required.");
+  const result = await deriveRpc({
+    method: "public/get_instrument",
+    params: { instrument_name: name },
+    network: args.network
+  });
+  if (!result?.instrument_name && !result?.base_asset_address) {
+    throw new Error(`Derive instrument not found: ${name}`);
+  }
+  return { ...result, instrument_name: result.instrument_name ?? name };
+}
+async function deriveFetchCurrenciesRaw(args) {
+  const result = await deriveRpc({
+    method: "public/get_all_currencies",
+    network: args?.network
+  });
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.currencies)) {
+    return result.currencies;
+  }
+  return [];
+}
+function asInstrumentList(result) {
+  if (Array.isArray(result)) return result;
+  if (result && typeof result === "object" && Array.isArray(result.instruments)) {
+    return result.instruments;
+  }
+  return [];
+}
+async function deriveFetchOptionInstrumentsOneShot(args) {
+  const result = await deriveRpc({
+    method: "public/get_instruments",
+    params: {
+      instrument_type: "option",
+      currency: args.currency,
+      expired: args.expired
+    },
+    network: args.network
+  });
+  return asInstrumentList(result);
+}
+async function deriveFetchOptionInstrumentPage(args) {
+  const result = await deriveRpc({
+    method: "public/get_all_instruments",
+    params: {
+      instrument_type: "option",
+      currency: args.currency,
+      expired: args.expired,
+      page: args.page,
+      page_size: args.pageSize
+    },
+    network: args.network
+  });
+  return asInstrumentList(result);
+}
+async function deriveFetchOptionInstruments(args) {
+  const currency = args.currency.trim().toUpperCase();
+  if (!currency) throw new Error("currency is required (e.g. ETH).");
+  const expired = args.expired ?? false;
+  const pageSize = args.pageSize ?? 200;
+  if (args.page == null) {
+    try {
+      const oneShot = await deriveFetchOptionInstrumentsOneShot({ currency, expired, network: args.network });
+      if (oneShot.length) return { instruments: oneShot };
+    } catch {
+    }
+  }
+  if (args.page != null) {
+    return {
+      instruments: await deriveFetchOptionInstrumentPage({
+        currency,
+        expired,
+        page: args.page,
+        pageSize,
+        network: args.network
+      })
+    };
+  }
+  const instruments = [];
+  for (let page = 1; page <= 8; page++) {
+    const chunk = await deriveFetchOptionInstrumentPage({
+      currency,
+      expired,
+      page,
+      pageSize,
+      network: args.network
+    });
+    instruments.push(...chunk);
+    if (chunk.length < pageSize) break;
+  }
+  return { instruments };
+}
+function deriveSearchInstruments(instruments, query, limit = 25) {
+  const q = query.trim().toUpperCase();
+  if (!q) return instruments.slice(0, limit);
+  return instruments.filter((i) => {
+    const name = String(i.instrument_name ?? "").toUpperCase();
+    return name.includes(q) || name.replace(/-/g, "").includes(q.replace(/-/g, ""));
+  }).slice(0, limit);
+}
+
+// src/protocols/evm/derive/reads.ts
+function networkFromArgs(chainId, network) {
+  if (network) return network;
+  if (chainId != null) return deriveNetworkFromChainId(chainId);
+  return "mainnet";
+}
+function assertInterval(interval) {
+  const v = interval ?? DERIVE_DEFAULT_OHLCV_INTERVAL;
+  if (!DERIVE_OHLCV_INTERVALS.includes(v)) {
+    throw new Error(`Invalid Derive OHLCV interval: ${interval}. Valid: ${DERIVE_OHLCV_INTERVALS.join(", ")}`);
+  }
+  return v;
+}
+function resolveDeriveOhlcvWindow(args) {
+  const periodSec = DERIVE_OHLCV_PERIOD_SEC[args.interval];
+  const endTimeMs = args.endTimeMs ?? Date.now();
+  let startTimeMs = args.startTimeMs;
+  if (startTimeMs == null) {
+    if (args.lookbackDays != null || args.lookbackHours != null) {
+      const days = args.lookbackDays ?? args.lookbackHours / 24;
+      if (days > DERIVE_MAX_LOOKBACK_DAYS) {
+        throw new Error(`lookbackDays max is ${DERIVE_MAX_LOOKBACK_DAYS}.`);
+      }
+      startTimeMs = endTimeMs - Math.round(days * 864e5);
+    } else {
+      startTimeMs = endTimeMs - DERIVE_DEFAULT_OHLCV_BARS * periodSec * 1e3;
+    }
+  }
+  if (startTimeMs >= endTimeMs) {
+    throw new Error("Invalid OHLCV time range: startTimeMs must be before endTimeMs.");
+  }
+  const expectedBars = Math.ceil((endTimeMs - startTimeMs) / (periodSec * 1e3));
+  if (expectedBars > DERIVE_MAX_OHLCV_BARS) {
+    throw new Error(
+      `OHLCV range needs ~${expectedBars} bars at ${args.interval} (max ${DERIVE_MAX_OHLCV_BARS}). Use a coarser interval or shorter lookback.`
+    );
+  }
+  return { startTimeMs, endTimeMs, expectedBars, periodSec };
+}
+function mapDeriveTradingviewCandles(raw) {
+  const rows = Array.isArray(raw) ? raw : raw && typeof raw === "object" && Array.isArray(raw.candles) ? raw.candles : [];
+  return rows.map((row) => {
+    const r = row;
+    const tsSec = Number(r.timestamp_bucket ?? r.timestamp ?? 0);
+    return {
+      timestampMs: Number.isFinite(tsSec) ? tsSec * 1e3 : 0,
+      open: String(r.open_price ?? r.open ?? "0"),
+      high: String(r.high_price ?? r.high ?? "0"),
+      low: String(r.low_price ?? r.low ?? "0"),
+      close: String(r.close_price ?? r.close ?? "0"),
+      volume: String(r.volume_usd ?? r.volume_contracts ?? r.volume ?? "0")
+    };
+  }).filter((c) => c.timestampMs > 0).sort((a, b) => a.timestampMs - b.timestampMs);
+}
+var INSTRUMENT_NAME_RE = /^([A-Z0-9]+)-(\d{8})-(\d+(?:\.\d+)?)-([CP])$/;
+function deriveParseInstrumentName(name) {
+  const m = name.trim().toUpperCase().match(INSTRUMENT_NAME_RE);
+  if (!m) return null;
+  return { currency: m[1], expiryYmd: m[2], strike: m[3], optionType: m[4] };
+}
+function deriveExpiryUnixToYmd(expirySec) {
+  const d = new Date(expirySec * 1e3);
+  const y = d.getUTCFullYear();
+  const mo = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  return `${y}${mo}${day}`;
+}
+function tickerScalar(row, keys) {
+  for (const key of keys) {
+    const v = row[key];
+    if (v != null && String(v).trim() !== "") return String(v);
+  }
+  return null;
+}
+function mapDeriveTickerRow(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw;
+  const inner = row.instrument_ticker && typeof row.instrument_ticker === "object" ? row.instrument_ticker : row;
+  const instrumentName = tickerScalar(inner, ["instrument_name", "instrumentName"])?.toUpperCase();
+  if (!instrumentName) return null;
+  const parsed = deriveParseInstrumentName(instrumentName);
+  const details = inner.option_details && typeof inner.option_details === "object" ? inner.option_details : {};
+  const expiryRaw = details.expiry;
+  const expiry = expiryRaw != null && Number.isFinite(Number(expiryRaw)) ? Number(expiryRaw) : null;
+  const optionTypeRaw = String(details.option_type ?? parsed?.optionType ?? "").trim().toUpperCase();
+  const optionType = optionTypeRaw === "C" || optionTypeRaw === "P" ? optionTypeRaw : parsed?.optionType ?? null;
+  const strike = tickerScalar(details, ["strike"]) ?? parsed?.strike ?? null;
+  const greeks = inner.option_pricing && typeof inner.option_pricing === "object" ? inner.option_pricing : null;
+  return {
+    instrumentName,
+    bidPx: tickerScalar(inner, ["b", "best_bid_price", "bid"]),
+    askPx: tickerScalar(inner, ["a", "best_ask_price", "ask"]),
+    markPx: tickerScalar(inner, ["M", "mark_price", "mark"]) ?? tickerScalar(greeks ?? {}, ["m", "mark_price"]),
+    indexPx: tickerScalar(inner, ["I", "index_price", "index"]),
+    strike,
+    expiry,
+    expiryYmd: parsed?.expiryYmd ?? (expiry != null ? deriveExpiryUnixToYmd(expiry) : null),
+    optionType,
+    greeks
+  };
+}
+function collectDeriveTickerRows(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (!raw || typeof raw !== "object") return [];
+  const rec = raw;
+  if (Array.isArray(rec.tickers)) return rec.tickers;
+  if (rec.tickers && typeof rec.tickers === "object") {
+    return Object.entries(rec.tickers).map(([name, row]) => {
+      if (row && typeof row === "object" && !Array.isArray(row)) {
+        const inner = row;
+        if (!inner.instrument_name && !inner.instrumentName) {
+          return { ...inner, instrument_name: name };
+        }
+      }
+      return row;
+    });
+  }
+  if (rec.result != null) return collectDeriveTickerRows(rec.result);
+  return [];
+}
+function normalizeDeriveExpiryYmd(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(Math.trunc(raw));
+  return String(raw ?? "").trim().replace(/-/g, "");
+}
+function deriveAtmTickerWindow(tickers, maxStrikes = DERIVE_DEFAULT_TICKER_ATM_STRIKES) {
+  const strikes = [
+    ...new Set(
+      tickers.map((t) => Number(t.strike)).filter((n) => Number.isFinite(n) && n > 0)
+    )
+  ].sort((a, b) => a - b);
+  if (strikes.length <= maxStrikes) return tickers;
+  const indexPx = Number(tickers.find((t) => t.indexPx)?.indexPx);
+  let center = Math.floor(strikes.length / 2);
+  if (Number.isFinite(indexPx) && indexPx > 0) {
+    let best = 0;
+    let bestDist = Infinity;
+    strikes.forEach((strike, i) => {
+      const dist = Math.abs(strike - indexPx);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = i;
+      }
+    });
+    center = best;
+  }
+  const half = Math.floor(maxStrikes / 2);
+  let start = Math.max(0, center - half);
+  if (start + maxStrikes > strikes.length) start = Math.max(0, strikes.length - maxStrikes);
+  const keep = new Set(strikes.slice(start, start + maxStrikes));
+  return tickers.filter((t) => keep.has(Number(t.strike)));
+}
+async function deriveFetchTickersSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const currency = args.currency.trim().toUpperCase();
+  const expiryDate = normalizeDeriveExpiryYmd(args.expiryDate);
+  if (!currency) throw new Error("currency is required.");
+  if (!/^\d{8}$/.test(expiryDate)) {
+    throw new Error("expiryDate must be YYYYMMDD (e.g. 20260925 or 2026-09-25).");
+  }
+  const raw = await deriveRpc({
+    method: "public/get_tickers",
+    params: { instrument_type: "option", currency, expiry_date: expiryDate },
+    network
+  });
+  let tickers = collectDeriveTickerRows(raw).map(mapDeriveTickerRow).filter((row) => row != null);
+  if (args.optionType) tickers = tickers.filter((row) => row.optionType === args.optionType);
+  tickers.sort((a, b) => Number(a.strike ?? 0) - Number(b.strike ?? 0) || a.instrumentName.localeCompare(b.instrumentName));
+  const listedCount = tickers.length;
+  const ladder = args.ladder ?? "atm";
+  if (ladder === "atm") tickers = deriveAtmTickerWindow(tickers);
+  const indexPx = tickers.find((row) => row.indexPx)?.indexPx ?? null;
+  return {
+    currency,
+    expiryDate,
+    optionType: args.optionType ?? null,
+    ladder,
+    indexPx,
+    listedCount,
+    tickerCount: tickers.length,
+    callCount: tickers.filter((row) => row.optionType === "C").length,
+    putCount: tickers.filter((row) => row.optionType === "P").length,
+    tickers,
+    notes: ladder === "atm" ? `ATM strike/premium ladder (~${DERIVE_DEFAULT_TICKER_ATM_STRIKES} strikes around index). Pass ladder: "all" for every strike on this expiry. Then snapshot or order_quote one instrumentName.` : "Full strike/premium ladder for this expiry. Then snapshot or order_quote one instrumentName.",
+    network
+  };
+}
+function mapDeriveOrderBookLevels(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((row) => {
+    if (Array.isArray(row) && row.length >= 2) {
+      return { price: String(row[0]), amount: String(row[1]) };
+    }
+    if (row && typeof row === "object") {
+      const r = row;
+      const price = r.price ?? r[0];
+      const amount = r.amount ?? r.size ?? r[1];
+      if (price != null && amount != null) return { price: String(price), amount: String(amount) };
+    }
+    return null;
+  }).filter((row) => row != null).slice(0, 8);
+}
+async function deriveFetchOrderBookSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const instrumentName = args.instrumentName.trim().toUpperCase();
+  if (!instrumentName) throw new Error("instrumentName is required.");
+  const raw = await deriveRpc({
+    method: "public/get_order_book",
+    params: { instrument_name: instrumentName, depth: args.depth ?? 10 },
+    network
+  });
+  return {
+    instrumentName,
+    bids: mapDeriveOrderBookLevels(raw.bids),
+    asks: mapDeriveOrderBookLevels(raw.asks),
+    network
+  };
+}
+async function deriveFetchCurrenciesSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const currencies = await deriveFetchCurrenciesRaw({ network });
+  return {
+    currencies: currencies.map((c) => ({
+      currency: String(c.currency ?? c.name ?? "")
+    })),
+    network
+  };
+}
+function summarizeDeriveOptionChain(args) {
+  const currency = args.currency.trim().toUpperCase();
+  const byExpiry = /* @__PURE__ */ new Map();
+  let callCount = 0;
+  let putCount = 0;
+  for (const row of args.instruments) {
+    if (row.isActive === false) continue;
+    const parsed = deriveParseInstrumentName(row.instrumentName);
+    const optionTypeRaw = String(row.optionType ?? parsed?.optionType ?? "").trim().toUpperCase();
+    const optionType = optionTypeRaw === "C" || optionTypeRaw === "P" ? optionTypeRaw : null;
+    const expiryYmd = parsed?.expiryYmd ?? (row.expiry != null && Number.isFinite(row.expiry) ? deriveExpiryUnixToYmd(row.expiry) : "");
+    if (!expiryYmd) continue;
+    const strikeNum = Number(row.strike ?? parsed?.strike ?? NaN);
+    const bucket = byExpiry.get(expiryYmd) ?? { expiryUnix: row.expiry ?? null, calls: 0, puts: 0, strikes: [] };
+    if (bucket.expiryUnix == null && row.expiry != null) bucket.expiryUnix = row.expiry;
+    if (optionType === "C") {
+      bucket.calls += 1;
+      callCount += 1;
+    } else if (optionType === "P") {
+      bucket.puts += 1;
+      putCount += 1;
+    }
+    if (Number.isFinite(strikeNum)) bucket.strikes.push(strikeNum);
+    byExpiry.set(expiryYmd, bucket);
+  }
+  const expiries = [...byExpiry.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([expiryYmd, bucket]) => {
+    const sorted = [...bucket.strikes].sort((a, b) => a - b);
+    return {
+      expiryYmd,
+      expiryUnix: bucket.expiryUnix,
+      callCount: bucket.calls,
+      putCount: bucket.puts,
+      minStrike: sorted[0] != null ? String(sorted[0]) : null,
+      maxStrike: sorted[sorted.length - 1] != null ? String(sorted[sorted.length - 1]) : null
+    };
+  });
+  return {
+    currency,
+    instrumentCount: callCount + putCount,
+    callCount,
+    putCount,
+    expiries
+  };
+}
+async function deriveFetchOptionChainSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const { instruments } = await deriveFetchOptionInstruments({
+    currency: args.currency,
+    expired: args.expired,
+    network
+  });
+  return {
+    currency: args.currency.trim().toUpperCase(),
+    instruments: instruments.map((i) => {
+      const parsed = deriveParseInstrumentName(i.instrument_name);
+      const optionTypeRaw = String(i.option_details?.option_type ?? parsed?.optionType ?? "").trim().toUpperCase();
+      return {
+        instrumentName: i.instrument_name,
+        instrumentType: i.instrument_type ?? "option",
+        isActive: i.is_active ?? true,
+        strike: i.option_details?.strike ?? parsed?.strike ?? null,
+        expiry: i.option_details?.expiry ?? null,
+        optionType: optionTypeRaw === "C" || optionTypeRaw === "P" ? optionTypeRaw : parsed?.optionType ?? null
+      };
+    }),
+    network
+  };
+}
+async function deriveFetchOptionChainAgentSummary(args) {
+  const full = await deriveFetchOptionChainSummary(args);
+  return {
+    ...summarizeDeriveOptionChain(full),
+    notes: 'Complete expiry list (counts + min/max strike only \u2014 not a missing-weekly warning). Next: ctm_derive_fetch_tickers {currency, expiryDate} for an ATM premium ladder. expiryDate accepts 20260925 or 2026-09-25. Pass ladder: "all" only if the operator wants every strike.',
+    network: full.network
+  };
+}
+async function deriveSearchInstrumentsSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const { instruments } = await deriveFetchOptionInstruments({ currency: args.currency, network });
+  const hits = deriveSearchInstruments(instruments, args.query, args.limit ?? 25);
+  return {
+    instruments: hits.map((i) => ({ instrumentName: i.instrument_name })),
+    network
+  };
+}
+async function deriveFetchMarketSnapshotSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const name = args.instrumentName.trim().toUpperCase();
+  const ticker = await deriveRpc({
+    method: "public/get_ticker",
+    params: { instrument_name: name },
+    network
+  });
+  const mark = ticker.M != null ? String(ticker.M) : null;
+  const index = ticker.I != null ? String(ticker.I) : null;
+  const bid = ticker.b != null ? String(ticker.b) : null;
+  const ask = ticker.a != null ? String(ticker.a) : null;
+  const midUsd = mark ?? (bid && ask ? String((Number(bid) + Number(ask)) / 2) : bid ?? ask);
+  if (!midUsd) throw new Error(`No live ticker for ${name}.`);
+  return {
+    snapshot: {
+      instrumentName: name,
+      livePrice: {
+        markPx: mark,
+        indexPx: index,
+        bidPx: bid,
+        askPx: ask,
+        midUsd,
+        source: mark ? "mark" : "bidAsk"
+      },
+      greeks: ticker.option_pricing ?? null,
+      fetchedAtMs: Date.now()
+    },
+    network
+  };
+}
+async function deriveFetchOhlcvSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const interval = assertInterval(args.interval);
+  const { startTimeMs, endTimeMs, expectedBars, periodSec } = resolveDeriveOhlcvWindow({
+    interval,
+    lookbackDays: args.lookbackDays,
+    lookbackHours: args.lookbackHours,
+    startTimeMs: args.startTimeMs,
+    endTimeMs: args.endTimeMs
+  });
+  const kind = args.marketKind ?? (args.currency && !args.instrumentName ? "index" : "option");
+  let candles;
+  let market;
+  if (kind === "index") {
+    const currency = (args.currency ?? args.instrumentName ?? "").trim().toUpperCase().replace(/-.*$/, "");
+    if (!currency) throw new Error("currency is required for index OHLCV.");
+    market = currency;
+    const raw = await deriveRpc({
+      method: "public/get_index_chart_data",
+      params: {
+        currency,
+        start_timestamp: Math.floor(startTimeMs / 1e3),
+        end_timestamp: Math.floor(endTimeMs / 1e3),
+        period: periodSec
+      },
+      network
+    });
+    candles = mapDeriveTradingviewCandles(raw);
+  } else {
+    const instrumentName = (args.instrumentName ?? "").trim().toUpperCase();
+    if (!instrumentName) throw new Error("instrumentName is required for option OHLCV.");
+    market = instrumentName;
+    const raw = await deriveRpc({
+      method: "public/get_tradingview_chart_data",
+      params: {
+        instrument_name: instrumentName,
+        start_timestamp: Math.floor(startTimeMs / 1e3),
+        end_timestamp: Math.floor(endTimeMs / 1e3),
+        period: periodSec
+      },
+      network
+    });
+    candles = mapDeriveTradingviewCandles(raw);
+  }
+  if (candles.length > expectedBars) {
+    candles = candles.slice(-expectedBars);
+  }
+  if (candles.length === 0) {
+    throw new Error(`No OHLCV data for ${market} between ${startTimeMs} and ${endTimeMs} at ${interval}.`);
+  }
+  return {
+    ohlcv: {
+      market,
+      coin: market,
+      interval,
+      marketKind: kind,
+      startTimeMs,
+      endTimeMs,
+      expectedBars,
+      candleCount: candles.length,
+      latestCandle: candles[candles.length - 1] ?? null,
+      candles,
+      fetchedAtMs: Date.now(),
+      dataSource: "derive"
+    },
+    dataSource: "derive",
+    network
+  };
+}
+async function deriveOrderQuoteSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const instrumentName = args.instrumentName.trim().toUpperCase();
+  const quote = await deriveRpc({
+    method: "public/order_quote",
+    params: {
+      instrument_name: instrumentName,
+      direction: args.direction,
+      amount: args.amount,
+      limit_price: args.limitPrice,
+      ...args.subaccountId && args.subaccountId > 0 ? { subaccount_id: args.subaccountId } : {}
+    },
+    network
+  });
+  return { quote, instrumentName, network };
+}
+function synthesizeDeriveRiskUniversesFromCurrencies(currencies) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const c of currencies) {
+    const name = String(c.currency ?? "").trim().toUpperCase();
+    if (!name) continue;
+    const addrs = c.protocol_asset_addresses ?? {};
+    const types = (c.instrument_types ?? []).map((t) => String(t));
+    const collateral = {
+      name,
+      address: addrs.option ?? addrs.spot ?? null,
+      erc20: { underlying_erc20: addrs.underlying_erc20 ?? null }
+    };
+    for (const mgr of c.managers ?? []) {
+      const address = String(mgr.address ?? "").trim();
+      if (!address) continue;
+      const key = `${address.toLowerCase()}:${mgr.margin_type ?? ""}:${mgr.currency ?? ""}`;
+      const existing = byKey.get(key);
+      if (existing) {
+        if (!existing.instrument_types.includes("option") && types.includes("option")) {
+          existing.instrument_types = [.../* @__PURE__ */ new Set([...existing.instrument_types, ...types])];
+        }
+        if (!existing.collaterals.some((row) => row.name === name)) existing.collaterals.push(collateral);
+        continue;
+      }
+      byKey.set(key, {
+        manager_id: typeof mgr.manager_id === "number" ? mgr.manager_id : null,
+        address,
+        margin_type: mgr.margin_type ?? null,
+        currency: mgr.currency ?? null,
+        instrument_types: types,
+        collaterals: [collateral]
+      });
+    }
+  }
+  return [
+    {
+      risk_universe_id: null,
+      source: "public/get_all_currencies",
+      managers: [...byKey.values()]
+    }
+  ];
+}
+async function deriveFetchRiskUniversesSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  try {
+    const result = await deriveRpc({ method: "public/get_risk_universes", network });
+    const universes = Array.isArray(result) ? result : result?.universes ?? [];
+    if (universes.length) {
+      return {
+        universes,
+        notes: "Pick a manager that lists ETH-OPTION (or the underlying) and accepts your collateral (usually USDC). L1 ACTION_MANAGER uses manager_id + collaterals[].address + underlying_erc20. Socket / HYPE vault deposits do not need the protocol-asset address.",
+        network
+      };
+    }
+  } catch {
+  }
+  const currencies = await deriveFetchCurrenciesRaw({ network });
+  return {
+    universes: synthesizeDeriveRiskUniversesFromCurrencies(currencies),
+    notes: "v3 public/get_risk_universes is failing on mainnet; managers below are reconstructed from public/get_all_currencies (address + margin_type + protocol assets). L1 ACTION_MANAGER still needs a numeric manager_id \u2014 use Socket / HYPE vault, or register_deposit_address, until v3 recovers. Socket / HYPE vault deposits do not need the protocol-asset address.",
+    network
+  };
+}
+async function deriveFetchPendingDepositsSummary(args) {
+  const network = networkFromArgs(args.chainId, args.network);
+  const wallet = (args.wallet ?? args.executorAddress ?? "").trim();
+  if (!wallet) throw new Error("wallet or executorAddress is required.");
+  const result = await deriveRpc({
+    method: "public/get_pending_deposits",
+    params: { wallet },
+    network
+  });
+  const pending = Array.isArray(result) ? result : result?.deposits ?? [];
+  return {
+    pending,
+    credited: Array.isArray(pending) && pending.length === 0,
+    notes: pending.length === 0 ? "No pending L1 deposits. If you just sent depositToNewSubaccount, wait ~2 minutes and retry, then call ctm_derive_fetch_subaccounts." : "Deposit is queued on L1 and not yet credited. Wait and poll again \u2014 do not place orders until fetch_subaccounts returns ids.",
+    network
+  };
+}
+function networkFromArgs2(chainId, network) {
+  if (network) return network;
+  if (chainId != null) return deriveNetworkFromChainId(chainId);
+  return "mainnet";
+}
+function parseSubaccountIds(result) {
+  if (Array.isArray(result)) {
+    return result.map((x) => Number(x)).filter((n) => Number.isFinite(n) && n > 0);
+  }
+  if (result && typeof result === "object") {
+    const rec = result;
+    const ids = rec.subaccount_ids ?? rec.subaccounts ?? rec.ids;
+    if (Array.isArray(ids)) {
+      return ids.map((x) => typeof x === "object" && x ? Number(x.subaccount_id ?? x) : Number(x)).filter((n) => Number.isFinite(n) && n > 0);
+    }
+  }
+  return [];
+}
+function deriveEmptySubaccountsPayload(wallet) {
+  return {
+    wallet,
+    subaccounts: [],
+    funded: false,
+    notes: DERIVE_UNFUNDED_NOTES,
+    next: [...DERIVE_UNFUNDED_NEXT]
+  };
+}
+function resolveWallet(args) {
+  const raw = (args.wallet ?? args.executorAddress ?? "").trim();
+  if (!raw) throw new Error("wallet or executorAddress is required.");
+  return raw;
+}
+async function deriveFetchSubaccountsSummary(args) {
+  const network = networkFromArgs2(args.chainId, args.network);
+  const wallet = getAddress(resolveWallet(args));
+  const auth = requireDeriveAuth(args.auth, "ctm_derive_fetch_subaccounts");
+  const result = await deriveRpc({
+    method: "private/get_subaccounts",
+    params: { wallet },
+    network,
+    auth
+  });
+  const ids = parseSubaccountIds(result);
+  if (ids.length === 0) {
+    return { ...deriveEmptySubaccountsPayload(wallet), network };
+  }
+  return {
+    wallet,
+    subaccounts: ids,
+    funded: true,
+    notes: "Same KeyGen owns these subaccounts on every chain. Place/cancel/replace need subaccountId from this list. First deposit also creates a fallback (manager 0) \u2014 two ids is normal.",
+    next: ["ctm_derive_fetch_portfolio", "ctm_derive_build_place_order_multisign"],
+    network
+  };
+}
+async function deriveFetchPortfolioSummary(args) {
+  const network = networkFromArgs2(args.chainId, args.network);
+  if (!args.subaccountId || args.subaccountId <= 0) throw new Error(DERIVE_MISSING_SUBACCOUNT_ERROR);
+  const auth = requireDeriveAuth(args.auth, "ctm_derive_fetch_portfolio");
+  const portfolio = await deriveRpc({
+    method: "private/get_subaccount",
+    params: { subaccount_id: args.subaccountId },
+    network,
+    auth
+  });
+  return { portfolio, subaccountId: args.subaccountId, wallet: getAddress(resolveWallet(args)), network };
+}
+async function deriveFetchPositionsSummary(args) {
+  const network = networkFromArgs2(args.chainId, args.network);
+  if (!args.subaccountId || args.subaccountId <= 0) throw new Error(DERIVE_MISSING_SUBACCOUNT_ERROR);
+  const auth = requireDeriveAuth(args.auth, "ctm_derive_fetch_positions");
+  const result = await deriveRpc({
+    method: "private/get_positions",
+    params: { subaccount_id: args.subaccountId },
+    network,
+    auth
+  });
+  const positions = Array.isArray(result) ? result : result.positions ?? [];
+  return { positions, subaccountId: args.subaccountId, wallet: getAddress(resolveWallet(args)), network };
+}
+async function deriveFetchOpenOrdersSummary(args) {
+  const network = networkFromArgs2(args.chainId, args.network);
+  if (!args.subaccountId || args.subaccountId <= 0) throw new Error(DERIVE_MISSING_SUBACCOUNT_ERROR);
+  const auth = requireDeriveAuth(args.auth, "ctm_derive_fetch_open_orders");
+  const result = await deriveRpc({
+    method: "private/get_open_orders",
+    params: { subaccount_id: args.subaccountId },
+    network,
+    auth
+  });
+  const orders = Array.isArray(result) ? result : result.orders ?? [];
+  return { orders, subaccountId: args.subaccountId, wallet: getAddress(resolveWallet(args)), network };
+}
+var DERIVE_ACTION_TYPES = {
+  Action: [
+    { name: "subaccountId", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "module", type: "address" },
+    { name: "data", type: "bytes" },
+    { name: "expiry", type: "uint256" },
+    { name: "owner", type: "address" },
+    { name: "signer", type: "address" }
+  ]
+};
+function deriveE18(value, field) {
+  const text = value.trim();
+  if (!/^-?\d+(\.\d+)?$/.test(text)) {
+    throw new Error(`${field} must be a decimal string (no scientific notation).`);
+  }
+  const scaled = parseUnits(text, 18);
+  if (scaled % 1000000n !== 0n) {
+    throw new Error(`${field} has more than 12 decimal places \u2014 Derive rejects sub-1e12 precision.`);
+  }
+  return scaled;
+}
+function deriveRandomNonce(nowMs = Date.now()) {
+  const nanos = BigInt(nowMs) * 1000000n + BigInt(Math.floor(Math.random() * 1e6));
+  return nanos.toString();
+}
+function deriveExpirySec(secondsFromNow = DERIVE_DEFAULT_SIGNATURE_EXPIRY_SEC, nowMs = Date.now()) {
+  if (secondsFromNow < DERIVE_MIN_ORDER_EXPIRY_SEC) {
+    throw new Error(`Order signature expiry must be at least ${DERIVE_MIN_ORDER_EXPIRY_SEC} seconds.`);
+  }
+  return Math.floor(nowMs / 1e3) + secondsFromNow;
+}
+function deriveMatchingDomain(network) {
+  return {
+    name: DERIVE_EIP712_NAME,
+    version: DERIVE_EIP712_VERSION,
+    chainId: BigInt(deriveSettlementChainId(network)),
+    verifyingContract: DERIVE_MATCHING_VERIFYING_CONTRACT
+  };
+}
+function deriveDomainSeparator(network) {
+  return network === "testnet" ? DERIVE_DOMAIN_SEPARATOR_TESTNET : DERIVE_DOMAIN_SEPARATOR_MAINNET;
+}
+function encodeDeriveTradeData(args) {
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "uint256" },
+      { type: "int256" },
+      { type: "int256" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "bool" }
+    ],
+    [
+      getAddress(args.assetAddress),
+      BigInt(args.subId),
+      deriveE18(args.limitPrice, "limitPrice"),
+      deriveE18(args.amount, "amount"),
+      deriveE18(args.maxFee, "maxFee"),
+      BigInt(args.recipientSubaccountId),
+      args.isBid
+    ]
+  );
+}
+function encodeDeriveTransferData(args) {
+  const amount = deriveE18(args.amount, "amount");
+  if (amount <= 0n) throw new Error("transfer amount must be strictly positive");
+  return encodeAbiParameters(
+    [
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "uint256" }
+    ],
+    [
+      BigInt(args.toSubaccountId),
+      BigInt(args.newSubaccountManager),
+      getAddress(args.asset),
+      BigInt(args.subId),
+      amount,
+      deriveE18(args.maxFeeUsd, "maxFeeUsd")
+    ]
+  );
+}
+function deriveActionTypehash() {
+  return keccak256(toHex("Action(uint256 subaccountId,uint256 nonce,address module,bytes data,uint256 expiry,address owner,address signer)"));
+}
+function buildDeriveActionTypedData(args) {
+  const owner = getAddress(args.owner);
+  const signer = getAddress(args.signer);
+  return {
+    domain: deriveMatchingDomain(args.network),
+    types: DERIVE_ACTION_TYPES,
+    primaryType: "Action",
+    message: {
+      subaccountId: BigInt(args.subaccountId),
+      nonce: BigInt(args.nonce),
+      module: getAddress(args.module),
+      data: args.data,
+      expiry: BigInt(args.expirySec),
+      owner,
+      signer
+    }
+  };
+}
+function hashDeriveAction(args) {
+  const typed = buildDeriveActionTypedData(args);
+  return hashTypedData({
+    domain: typed.domain,
+    types: typed.types,
+    primaryType: "Action",
+    message: typed.message
+  });
+}
+function assertPositiveSubaccountId(subaccountId) {
+  if (subaccountId == null) {
+    throw new Error("subaccountId is required.");
+  }
+  const id = BigInt(subaccountId);
+  if (id <= 0n) {
+    throw new Error("subaccountId must be a positive Derive subaccount id (not 0).");
+  }
+  return id;
+}
+function deriveLoginTimestamp(nowMs = Date.now()) {
+  return String(nowMs);
+}
+function deriveLoginMessage(timestampMs) {
+  const ts = timestampMs.trim();
+  if (!/^\d+$/.test(ts)) throw new Error("Derive login timestamp must be a millisecond UTC decimal string.");
+  return ts;
+}
+function deriveLoginDigest(timestampMs) {
+  return hashMessage(deriveLoginMessage(timestampMs));
+}
+function deriveAuthHeaders(auth) {
+  return {
+    "X-DeriveWallet": getAddress(auth.wallet),
+    "X-DeriveTimestamp": auth.timestamp.trim(),
+    "X-DeriveSignature": auth.signature.trim()
+  };
+}
+
+// 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 = getClientIdFromKeyGenResult(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, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  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;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+
+// src/core/eip712Multisign.ts
+var EIP712_SIGN_REQUEST_KIND = "eip712";
+function msgHashNo0x(digest) {
+  return digest.startsWith("0x") ? digest.slice(2) : digest;
+}
+function eip712SignatureText(domain, primaryType) {
+  return JSON.stringify({
+    kind: "EIP-712",
+    ...typeof domain.name === "string" ? { name: domain.name } : {},
+    primaryType
+  });
+}
+function jsonStringifyForAudit(value) {
+  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+function eip712LegEnvelope(typedData, delivery, digest) {
+  return {
+    version: 1,
+    digest,
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message,
+    delivery
+  };
+}
+function eip712MsgRawHex(envelope) {
+  return stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712Multisign(args) {
+  if (args.legs.length < 1) {
+    throw new Error("buildEip712Multisign requires at least one leg");
+  }
+  const eip712 = [];
+  const legs = args.legs.map((leg) => {
+    const digest = hashTypedData({
+      domain: leg.typedData.domain,
+      types: leg.typedData.types,
+      primaryType: leg.typedData.primaryType,
+      message: leg.typedData.message
+    });
+    const envelope = eip712LegEnvelope(leg.typedData, leg.delivery, digest);
+    eip712.push(envelope);
+    return {
+      msgHash: msgHashNo0x(digest),
+      msgRaw: eip712MsgRawHex(envelope),
+      destinationAddress: args.destinationAddress,
+      signatureText: eip712SignatureText(leg.typedData.domain, leg.typedData.primaryType),
+      audit: {
+        kind: "EIP712",
+        primaryType: leg.typedData.primaryType,
+        deliveryKind: leg.delivery.kind,
+        ...leg.audit ?? {}
+      },
+      feeSnapshot: {}
+    };
+  });
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON: {
+      signRequestKind: EIP712_SIGN_REQUEST_KIND,
+      eip712
+    },
+    expiryDate: args.expiryDate,
+    legs
+  });
+}
+
+// src/protocols/evm/derive/exchangeMultisign.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function networkFromChain(chainId) {
+  return deriveNetworkFromChainId(chainId);
+}
+function requireSubaccount(subaccountId) {
+  try {
+    return assertPositiveSubaccountId(subaccountId);
+  } catch {
+    throw new Error(DERIVE_MISSING_SUBACCOUNT_ERROR);
+  }
+}
+async function loadTradeData(args) {
+  const instrument = await deriveFetchInstrument({ instrumentName: args.instrumentName, network: args.network });
+  const assetAddress = String(instrument.base_asset_address ?? "").trim();
+  const subId = instrument.base_asset_sub_id ?? instrument.sub_id;
+  if (!assetAddress || subId == null) {
+    throw new Error(`Instrument ${args.instrumentName} is missing base_asset_address / sub_id.`);
+  }
+  const data = encodeDeriveTradeData({
+    assetAddress,
+    subId,
+    limitPrice: args.limitPrice,
+    amount: args.amount,
+    maxFee: args.maxFee,
+    recipientSubaccountId: args.subaccountId,
+    isBid: args.direction === "buy"
+  });
+  return { instrument, assetAddress, subId: String(subId), data };
+}
+function deriveExchangeDelivery(args) {
+  const ticket = args.ticketKind ?? "limit";
+  const triggerPrice = (args.triggerPrice ?? "").trim();
+  const durationSec = args.algoDurationSec;
+  const slices = args.algoNumSlices;
+  if (ticket === "stop_limit") {
+    if (!triggerPrice || !(Number(triggerPrice) > 0)) {
+      throw new Error("Stop limit requires a positive trigger price.");
+    }
+  }
+  if (ticket === "twap") {
+    if (durationSec == null || !Number.isFinite(durationSec) || durationSec < 60) {
+      throw new Error("TWAP requires algoDurationSec of at least 60.");
+    }
+    if (slices == null || !Number.isInteger(slices) || slices < 2) {
+      throw new Error("TWAP requires algoNumSlices of at least 2.");
+    }
+  }
+  return {
+    kind: "derive_exchange",
+    method: args.method,
+    chainId: args.chainId,
+    settlementChainId: deriveSettlementChainId(args.network),
+    network: args.network,
+    params: {
+      subaccount_id: Number(args.subaccountId),
+      nonce: args.nonce,
+      signer: args.signer,
+      signature_expiry_sec: args.signatureExpirySec,
+      instrument_name: args.instrumentName,
+      direction: args.direction,
+      amount: args.amount,
+      limit_price: args.limitPrice,
+      max_fee: args.maxFee,
+      order_type: args.orderType,
+      time_in_force: args.timeInForce,
+      reduce_only: args.reduceOnly,
+      ...args.label ? { label: args.label } : {},
+      ...args.orderIdToCancel ? { order_id_to_cancel: args.orderIdToCancel } : {},
+      ...args.nonceToCancel ? { nonce_to_cancel: args.nonceToCancel } : {},
+      ...ticket === "stop_limit" ? {
+        trigger_price: triggerPrice,
+        trigger_type: args.triggerType ?? "stoploss",
+        trigger_price_type: args.triggerPriceType ?? "mark"
+      } : {},
+      ...ticket === "twap" ? {
+        algo_type: "twap",
+        algo_duration_sec: durationSec,
+        algo_num_slices: slices
+      } : {}
+    }
+  };
+}
+async function buildDerivePlaceOrderMultisign(args) {
+  const subaccountId = requireSubaccount(args.subaccountId);
+  const network = networkFromChain(args.chainId);
+  const owner = getAddress(args.executorAddress);
+  const nonce = args.nonce ?? deriveRandomNonce();
+  const expirySec = deriveExpirySec(args.signatureExpirySec);
+  const { data, instrument } = await loadTradeData({
+    instrumentName: args.instrumentName,
+    direction: args.direction,
+    amount: args.amount,
+    limitPrice: args.limitPrice,
+    maxFee: args.maxFee,
+    subaccountId,
+    network
+  });
+  const typedData = buildDeriveActionTypedData({
+    network,
+    subaccountId,
+    nonce,
+    module: DERIVE_TRADE_MODULE,
+    data,
+    expirySec,
+    owner,
+    signer: owner
+  });
+  return buildEip712Multisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        typedData,
+        delivery: deriveExchangeDelivery({
+          method: "private/order",
+          chainId: args.chainId,
+          network,
+          subaccountId: subaccountId.toString(),
+          nonce,
+          signer: owner,
+          signatureExpirySec: expirySec,
+          instrumentName: instrument.instrument_name,
+          direction: args.direction,
+          amount: args.amount,
+          limitPrice: args.limitPrice,
+          maxFee: args.maxFee,
+          orderType: args.orderType ?? "limit",
+          timeInForce: args.timeInForce ?? "gtc",
+          reduceOnly: args.reduceOnly === true,
+          label: args.label,
+          ticketKind: args.ticketKind,
+          triggerPrice: args.triggerPrice,
+          triggerType: args.triggerType,
+          triggerPriceType: args.triggerPriceType,
+          algoDurationSec: args.algoDurationSec,
+          algoNumSlices: args.algoNumSlices
+        }),
+        audit: {
+          protocol: DERIVE_PROTOCOL_ID,
+          action: "placeOrder",
+          instrumentName: instrument.instrument_name,
+          subaccountId: subaccountId.toString()
+        }
+      }
+    ]
+  });
+}
+async function buildDeriveReplaceOrderMultisign(args) {
+  const hasOrder = Boolean(args.orderIdToCancel?.trim());
+  const hasNonce = Boolean(args.nonceToCancel?.trim());
+  if (hasOrder === hasNonce) {
+    throw new Error("Replace requires exactly one of orderIdToCancel or nonceToCancel.");
+  }
+  const subaccountId = requireSubaccount(args.subaccountId);
+  const network = networkFromChain(args.chainId);
+  const owner = getAddress(args.executorAddress);
+  const nonce = args.nonce ?? deriveRandomNonce();
+  const expirySec = deriveExpirySec(args.signatureExpirySec);
+  const { data, instrument } = await loadTradeData({
+    instrumentName: args.instrumentName,
+    direction: args.direction,
+    amount: args.amount,
+    limitPrice: args.limitPrice,
+    maxFee: args.maxFee,
+    subaccountId,
+    network
+  });
+  const typedData = buildDeriveActionTypedData({
+    network,
+    subaccountId,
+    nonce,
+    module: DERIVE_TRADE_MODULE,
+    data,
+    expirySec,
+    owner,
+    signer: owner
+  });
+  return buildEip712Multisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        typedData,
+        delivery: deriveExchangeDelivery({
+          method: "private/replace",
+          chainId: args.chainId,
+          network,
+          subaccountId: subaccountId.toString(),
+          nonce,
+          signer: owner,
+          signatureExpirySec: expirySec,
+          instrumentName: instrument.instrument_name,
+          direction: args.direction,
+          amount: args.amount,
+          limitPrice: args.limitPrice,
+          maxFee: args.maxFee,
+          orderType: args.orderType ?? "limit",
+          timeInForce: args.timeInForce ?? "gtc",
+          reduceOnly: args.reduceOnly === true,
+          label: args.label,
+          ticketKind: args.ticketKind,
+          triggerPrice: args.triggerPrice,
+          triggerType: args.triggerType,
+          triggerPriceType: args.triggerPriceType,
+          algoDurationSec: args.algoDurationSec,
+          algoNumSlices: args.algoNumSlices,
+          orderIdToCancel: args.orderIdToCancel,
+          nonceToCancel: args.nonceToCancel
+        }),
+        audit: {
+          protocol: DERIVE_PROTOCOL_ID,
+          action: "replaceOrder",
+          instrumentName: instrument.instrument_name,
+          subaccountId: subaccountId.toString()
+        }
+      }
+    ]
+  });
+}
+function buildDeriveCancelMultisign(args) {
+  const subaccountId = requireSubaccount(args.subaccountId);
+  const instrumentName = args.instrumentName.trim().toUpperCase();
+  const orderId = args.orderId.trim();
+  if (!instrumentName) throw new Error("instrumentName is required.");
+  if (!orderId) throw new Error("orderId is required.");
+  const wallet = getAddress(args.executorAddress);
+  const timestamp = deriveLoginTimestamp();
+  const digest = deriveLoginDigest(timestamp);
+  const msgHash = digest.startsWith("0x") ? digest.slice(2) : digest;
+  const network = networkFromChain(args.chainId);
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: wallet,
+    expiryDate: args.expiryDate,
+    extraJSON: {
+      signRequestKind: "personal_sign",
+      delivery: {
+        kind: "derive_exchange",
+        method: "private/cancel",
+        chainId: args.chainId,
+        network,
+        settlementChainId: deriveSettlementChainId(network),
+        login: { wallet, timestamp },
+        params: {
+          instrument_name: instrumentName,
+          order_id: orderId,
+          subaccount_id: Number(subaccountId)
+        }
+      }
+    },
+    legs: [
+      {
+        msgHash,
+        msgRaw: stringToHex(timestamp),
+        destinationAddress: wallet,
+        signatureText: "Derive private/cancel EIP-191 login",
+        audit: {
+          kind: "PERSONAL_SIGN",
+          protocol: DERIVE_PROTOCOL_ID,
+          action: "cancel",
+          instrumentName,
+          orderId,
+          subaccountId: subaccountId.toString()
+        },
+        feeSnapshot: {}
+      }
+    ]
+  });
+}
+function defiEvmTransport(rpcUrl, opts) {
+  const url = rpcUrl.trim();
+  return http(url, opts);
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// 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: defiEvmTransport(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;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient, executor });
+    } else {
+      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,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+var erc20AllowanceAbi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+function publicClientForRpc(chainId, rpcUrl) {
+  const ch = defineChain({
+    id: chainId,
+    name: `chain-${chainId}`,
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl.trim()] } }
+  });
+  return createPublicClient({ chain: ch, transport: defiEvmTransport(rpcUrl.trim()) });
+}
+async function resolveErc20Decimals(args) {
+  const token = getAddress(args.token);
+  const onChain = await args.publicClient.readContract({
+    address: token,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const n = typeof onChain === "bigint" ? Number(onChain) : Number(onChain);
+  if (!Number.isFinite(n) || n < 0 || n > 36) {
+    throw new Error(`Invalid on-chain decimals for ${token}.`);
+  }
+  for (const hint of [args.registryDecimals, args.apiDecimals]) {
+  }
+  return n;
+}
+async function buildConditionalErc20ApproveSteps(args) {
+  if (args.amountWei <= 0n) return [];
+  const token = getAddress(args.token);
+  const spender = getAddress(args.spender);
+  const owner = getAddress(args.owner);
+  const fallback = args.fallbackGas ?? 100000n;
+  const allowance = await args.publicClient.readContract({
+    address: token,
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+  if (allowance >= args.amountWei) return [];
+  const steps = [];
+  if (allowance > 0n) {
+    steps.push({
+      to: token,
+      data: encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [spender, 0n] }),
+      value: 0n,
+      fallbackGas: fallback
+    });
+  }
+  steps.push({
+    to: token,
+    data: encodeFunctionData({
+      abi: erc20ApproveAbi,
+      functionName: "approve",
+      args: [spender, args.amountWei]
+    }),
+    value: 0n,
+    fallbackGas: fallback
+  });
+  return steps;
+}
+
+// src/protocols/evm/derive/depositMultisign.ts
+var DEPOSIT_APPROVE_FALLBACK = 100000n;
+var DEPOSIT_CALL_FALLBACK = 450000n;
+var actionManagerAbi = parseAbi([
+  "function depositToNewSubaccount(address protocolAsset, uint256 amount, uint256 managerId, address owner)"
+]);
+async function buildDeriveDepositNewSubaccountMultisign(args) {
+  if (!isDeriveSettlementChainId(args.chainId)) {
+    throw new Error(
+      "ACTION_MANAGER.depositToNewSubaccount is Ethereum L1 only (chainId 1 / 11155111). Use ctm_derive_build_socket_deposit_multisign on OP/Base/Arb, or ctm_derive_build_hype_vault_deposit_multisign on HyperEVM."
+    );
+  }
+  const executor = getAddress(args.executorAddress);
+  const protocolAsset = getAddress(args.protocolAsset);
+  const underlying = getAddress(args.underlyingErc20);
+  const managerId = BigInt(args.managerId);
+  if (managerId <= 0n) throw new Error("managerId must be a positive risk-universe manager id.");
+  const actionManager = deriveActionManagerAddress(args.chainId, args.actionManager);
+  const publicClient = publicClientForRpc(args.chainId, args.rpcUrl);
+  const decimals = await resolveErc20Decimals({ publicClient, token: underlying });
+  const amountWei = parseUnits(args.amountHuman.trim(), decimals);
+  if (amountWei <= 0n) throw new Error("amountHuman must be a positive deposit amount.");
+  const approveSteps = await buildConditionalErc20ApproveSteps({
+    publicClient,
+    token: underlying,
+    spender: actionManager,
+    owner: executor,
+    amountWei,
+    fallbackGas: DEPOSIT_APPROVE_FALLBACK
+  });
+  const depositData = encodeFunctionData({
+    abi: actionManagerAbi,
+    functionName: "depositToNewSubaccount",
+    args: [protocolAsset, amountWei, managerId, executor]
+  });
+  const steps = [
+    ...approveSteps.map((s) => ({
+      to: s.to,
+      data: s.data,
+      value: s.value,
+      fallbackGas: s.fallbackGas ?? DEPOSIT_APPROVE_FALLBACK
+    })),
+    { to: actionManager, data: depositData, value: 0n, fallbackGas: DEPOSIT_CALL_FALLBACK }
+  ];
+  const firstDataNo0x = steps[0].data.startsWith("0x") ? steps[0].data.slice(2) : steps[0].data;
+  const gasLimitConfig = args.useCustomGas && args.chainDetail?.gasLimit != null ? Number(args.chainDetail.gasLimit) : void 0;
+  const n = steps.length;
+  const purposeSuffix = n === 1 ? "Derive: depositToNewSubaccount (allowance already set). First credit creates trading + fallback subaccounts." : `Derive: ${n}-tx batch \u2014 approve L1 collateral to ACTION_MANAGER, then depositToNewSubaccount.`;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl.trim(),
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate: args.expiryDate
+    },
+    steps,
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    resolveGasLimit: ({ index, estimatedGas }) => {
+      if (index === steps.length - 1 && index > 0) {
+        const gas = DEPOSIT_CALL_FALLBACK;
+        return args.useCustomGas ? gasLimitFromEstimateAndChainConfig(gas, gasLimitConfig) : gas;
+      }
+      return estimatedGas;
+    },
+    buildBatchMeta: ({ index }) => {
+      const isDeposit = index === steps.length - 1;
+      return {
+        signatureText: JSON.stringify({
+          kind: "Derive",
+          protocol: DERIVE_PROTOCOL_ID,
+          action: isDeposit ? "depositToNewSubaccount" : "approve",
+          chainId: args.chainId,
+          managerId: args.managerId
+        })
+      };
+    }
+  });
+}
+var TRANSFER_FALLBACK = 80000n;
+var erc20TransferAbi = parseAbi(["function transfer(address to, uint256 amount) returns (bool)"]);
+async function deriveRegisterDepositAddress(args) {
+  const network = args.network ?? deriveNetworkFromChainId(args.chainId ?? 1);
+  const wallet = getAddress(args.wallet);
+  const subaccountId = args.subaccountId ?? 0;
+  const managerId = args.managerId;
+  if (!subaccountId && !managerId) {
+    throw new Error("register_deposit_address needs managerId (new subaccount) or subaccountId (existing).");
+  }
+  const result = await deriveRpc({
+    method: "public/register_deposit_address",
+    params: {
+      wallet,
+      subaccount_id: subaccountId,
+      ...managerId ? { manager_id: managerId } : {}
+    },
+    network
+  });
+  const depositAddress = (result?.deposit_address ?? "").trim();
+  if (!depositAddress) throw new Error("Derive did not return a deposit_address.");
+  return {
+    depositAddress: getAddress(depositAddress),
+    wallet,
+    managerId: result.manager_id ?? managerId ?? null,
+    subaccountId: result.subaccount_id ?? (subaccountId || null),
+    network,
+    notes: "Send the registered token on Ethereum L1 (chainId 1 / 11155111) only. The keeper sweeps into ACTION_MANAGER. Do not send from Base/Arb to this address."
+  };
+}
+async function buildDeriveDepositAddressTransferMultisign(args) {
+  if (!isDeriveSettlementChainId(args.chainId)) {
+    throw new Error("Standard deposit-address transfers are Ethereum L1 only (chainId 1 / 11155111). Use Socket on Arb/OP/Base.");
+  }
+  const executor = getAddress(args.executorAddress);
+  const token = getAddress(args.underlyingErc20);
+  const to = getAddress(args.depositAddress);
+  const publicClient = publicClientForRpc(args.chainId, args.rpcUrl);
+  const decimals = await resolveErc20Decimals({ publicClient, token });
+  const amountWei = parseUnits(args.amountHuman.trim(), decimals);
+  if (amountWei <= 0n) throw new Error("amountHuman must be a positive deposit amount.");
+  const data = encodeFunctionData({
+    abi: erc20TransferAbi,
+    functionName: "transfer",
+    args: [to, amountWei]
+  });
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl.trim(),
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate: args.expiryDate
+    },
+    steps: [{ to: token, data, value: 0n, fallbackGas: TRANSFER_FALLBACK }],
+    purposeSuffix: "Derive: ERC-20 transfer to registered L1 deposit address (standard / keeper sweep).",
+    firstMsgRawNo0x: data.startsWith("0x") ? data.slice(2) : data,
+    destinationAddress: token,
+    buildBatchMeta: () => ({
+      signatureText: JSON.stringify({
+        kind: "Derive",
+        protocol: DERIVE_PROTOCOL_ID,
+        action: "depositAddressTransfer",
+        chainId: args.chainId,
+        depositAddress: to
+      })
+    })
+  });
+}
+var DERIVE_SOCKET_APP_CHAIN_ID = 957;
+var DERIVE_SOCKET_CHAIN_IDS = [1, 10, 8453, 42161];
+var DERIVE_HYPE_CHAIN_ID = 999;
+var DERIVE_WHYPE = "0x5555555555555555555555555555555555555555";
+var DERIVE_HYPE_VAULT_DEFAULT = "0xb792F94Ed56eD0bA163e5Ba139e2Bd0029A81d0a";
+var DERIVE_SOCKET_MSG_GAS_LIMIT = 500000n;
+var DERIVE_SOCKET_FEE_FALLBACK_WEI = 2000000000000000n;
+var SOCKET_ROUTES = [
+  {
+    chainId: 1,
+    symbol: "USDC",
+    token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    vault: "0x6D303CEE7959f814042D31E0624fB88Ec6fbcC1d",
+    connector: "0x200AF8FCdD5246D70B369A98143Ac8930A077B7A",
+    decimals: 6
+  },
+  {
+    chainId: 1,
+    symbol: "WETH",
+    token: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    vault: "0xD4efe33C66B8CdE33B8896a2126E41e5dB571b7e",
+    connector: "0xCf814e58f1649F94d37E51f730D6bF72409fA09c",
+    decimals: 18
+  },
+  {
+    chainId: 1,
+    symbol: "WBTC",
+    token: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+    vault: "0x3Eec7c855aF33280F1eD38b93059F5aa5862E3ab",
+    connector: "0xA621Bc5A9d13D39eb098865B723CEee71BB5C181",
+    decimals: 8
+  },
+  {
+    chainId: 10,
+    symbol: "USDC",
+    token: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    vault: "0xDEf0bfBdf7530C75AB3C73f8d2F64d9eaA7aA98e",
+    connector: "0xfd76d8b79C2E2c86EA0814e92D5cA0e4E8096c13",
+    decimals: 6
+  },
+  {
+    chainId: 10,
+    symbol: "WETH",
+    token: "0x4200000000000000000000000000000000000006",
+    vault: "0xdD4c717a69763176d8B7A687728e228597eAB86d",
+    connector: "0x27f4B23944e2bb59b1E276aff22FD2Be45658F64",
+    decimals: 18
+  },
+  {
+    chainId: 10,
+    symbol: "WBTC",
+    token: "0x68f180fcCe6836688e9084f035309E29Bf0A2095",
+    vault: "0xE5967877065f111a556850d8f05b8DaD88edCEc9",
+    connector: "0x906A44Daa8bdA5599a384264e3811b9BeA1109b4",
+    decimals: 8
+  },
+  {
+    chainId: 8453,
+    symbol: "USDC",
+    token: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    vault: "0x4e798659b9846F1da7B6D6B5d09d581270aB6FEC",
+    connector: "0x57B03E14d409ADC7fAb6CFc44b5886CAD2D5f02b",
+    decimals: 6
+  },
+  {
+    chainId: 8453,
+    symbol: "WETH",
+    token: "0x4200000000000000000000000000000000000006",
+    vault: "0xBd282333710B9C7e33E8a37d027885A7C079Ae23",
+    connector: "0xbE9DBda519e15a1c0d238cEa0b3daD47a484A6Ff",
+    decimals: 18
+  },
+  {
+    chainId: 42161,
+    symbol: "USDC",
+    token: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    vault: "0x5e027ad442e031424b5a2C0ad6f656662Be32882",
+    connector: "0x17Fc4c7ea8267044b6D0ACC17a6C049Bed6F8B21",
+    decimals: 6
+  },
+  {
+    chainId: 42161,
+    symbol: "WETH",
+    token: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    vault: "0x8e9f58E6c206CB9C98aBb9F235E0f02D65dFc922",
+    connector: "0x3809150509df79D96334c4EB6Ba1c386827C3c67",
+    decimals: 18
+  },
+  {
+    chainId: 42161,
+    symbol: "WBTC",
+    token: "0x2f2a2543B76A4166549B7eCDcE5542a773Aa44fB",
+    vault: "0x3D20c6A2b719129af175E0ff7B1875DEb360896f",
+    connector: "0x42c846313c37845B9d67BB5c1F4F48E528234Afc",
+    decimals: 8
+  }
+];
+function norm(address) {
+  return getAddress(address).toLowerCase();
+}
+function isDeriveSocketChainId(chainId) {
+  return DERIVE_SOCKET_CHAIN_IDS.includes(chainId);
+}
+function deriveHypeVaultAddress(override) {
+  const explicit = (override ?? process.env.DERIVE_HYPE_VAULT ?? "").trim();
+  return getAddress(explicit || DERIVE_HYPE_VAULT_DEFAULT);
+}
+function deriveSocketRouteForToken(chainId, token) {
+  let key;
+  try {
+    key = norm(token);
+  } catch {
+    return null;
+  }
+  const hit = SOCKET_ROUTES.find((r) => r.chainId === chainId && norm(r.token) === key);
+  return hit ?? null;
+}
+function deriveSocketWethRoute(chainId) {
+  return SOCKET_ROUTES.find((r) => r.chainId === chainId && r.symbol === "WETH") ?? null;
+}
+function deriveFundRouteForAssetRow(args) {
+  const raw = (args.contractAddress ?? "").trim();
+  const isNative = !raw || raw.toLowerCase() === "native" || raw.toLowerCase() === NATIVE_ZERO;
+  if (args.chainId === DERIVE_HYPE_CHAIN_ID) {
+    if (isNative || raw && norm(raw) === norm(DERIVE_WHYPE)) {
+      return {
+        kind: "hype_vault",
+        chainId: DERIVE_HYPE_CHAIN_ID,
+        symbol: "HYPE",
+        token: isNative ? NATIVE_ZERO : getAddress(DERIVE_WHYPE),
+        decimals: 18,
+        native: isNative
+      };
+    }
+    return null;
+  }
+  if (args.chainId === 11155111) {
+    if (isNative) return null;
+    try {
+      return {
+        kind: "l1_direct",
+        chainId: 11155111,
+        symbol: "USDC",
+        token: getAddress(raw),
+        decimals: 6,
+        native: false
+      };
+    } catch {
+      return null;
+    }
+  }
+  if (args.chainId === 1) {
+    if (isNative) {
+      const weth = deriveSocketWethRoute(1);
+      if (!weth) return null;
+      return { kind: "l1_direct", chainId: 1, symbol: "ETH", token: NATIVE_ZERO, decimals: 18, native: true, socket: weth };
+    }
+    const socket = deriveSocketRouteForToken(1, raw);
+    if (!socket) return null;
+    return {
+      kind: "l1_direct",
+      chainId: 1,
+      symbol: socket.symbol,
+      token: getAddress(socket.token),
+      decimals: socket.decimals,
+      native: false,
+      socket
+    };
+  }
+  if (isDeriveSocketChainId(args.chainId)) {
+    if (isNative) {
+      const weth = deriveSocketWethRoute(args.chainId);
+      if (!weth) return null;
+      return {
+        kind: "socket",
+        chainId: args.chainId,
+        symbol: "ETH",
+        token: NATIVE_ZERO,
+        decimals: 18,
+        native: true,
+        socket: weth
+      };
+    }
+    const socket = deriveSocketRouteForToken(args.chainId, raw);
+    if (!socket) return null;
+    return {
+      kind: "socket",
+      chainId: args.chainId,
+      symbol: socket.symbol,
+      token: getAddress(socket.token),
+      decimals: socket.decimals,
+      native: false,
+      socket
+    };
+  }
+  return null;
+}
+function deriveFundableTokensForChain(chainId) {
+  if (chainId === DERIVE_HYPE_CHAIN_ID) {
+    return [
+      { address: NATIVE_ZERO, symbol: "HYPE", decimals: 18, roles: ["native", "collateral"] },
+      { address: getAddress(DERIVE_WHYPE), symbol: "WHYPE", decimals: 18, roles: ["native_wrapped", "collateral"] }
+    ];
+  }
+  if (chainId === 11155111) {
+    return [{ address: getAddress("0x73Efab09362052D26FB93A730Be4F8a5EdC833af"), symbol: "USDC", decimals: 6, roles: ["collateral"] }];
+  }
+  const rows = SOCKET_ROUTES.filter((r) => r.chainId === chainId).map((r) => ({
+    address: getAddress(r.token),
+    symbol: r.symbol,
+    decimals: r.decimals,
+    roles: r.symbol === "USDC" ? ["collateral", "quote"] : ["collateral", "underlying"]
+  }));
+  if (deriveSocketWethRoute(chainId)) {
+    rows.unshift({ address: NATIVE_ZERO, symbol: "ETH", decimals: 18, roles: ["native", "underlying"] });
+  }
+  return rows;
+}
+var APPROVE_FALLBACK = 100000n;
+var WRAP_FALLBACK = 80000n;
+var BRIDGE_FALLBACK = 350000n;
+var wethDepositAbi = parseAbi(["function deposit() payable"]);
+var socketVaultLegacyAbi = parseAbi([
+  "function getMinFees(address connector, uint256 minGasLimit) view returns (uint256)",
+  "function depositToAppChain(address receiver, uint256 amount, uint256 msgGasLimit, address connector) payable"
+]);
+async function readSocketFee(args) {
+  try {
+    const fee = await args.publicClient.readContract({
+      address: args.vault,
+      abi: socketVaultLegacyAbi,
+      functionName: "getMinFees",
+      args: [args.connector, DERIVE_SOCKET_MSG_GAS_LIMIT]
+    });
+    if (typeof fee === "bigint" && fee > 0n) return fee;
+  } catch {
+  }
+  return DERIVE_SOCKET_FEE_FALLBACK_WEI;
+}
+async function buildDeriveSocketDepositMultisign(args) {
+  const executor = getAddress(args.executorAddress);
+  const receiver = getAddress(args.receiver ?? args.executorAddress);
+  const rawToken = (args.token ?? "").trim();
+  const isNative = !rawToken || rawToken.toLowerCase() === "native" || rawToken.toLowerCase() === NATIVE_ZERO;
+  const route = isNative ? deriveSocketWethRoute(args.chainId) : deriveSocketRouteForToken(args.chainId, rawToken);
+  if (!route) {
+    throw new Error(
+      `No Derive Socket route for chain ${args.chainId} token ${rawToken || "native"}. Fundable rows are USDC / WETH / WBTC on Ethereum, Optimism, Base, Arbitrum.`
+    );
+  }
+  const vault = getAddress(route.vault);
+  const connector = getAddress(route.connector);
+  const publicClient = publicClientForRpc(args.chainId, args.rpcUrl);
+  const erc20 = getAddress(route.token);
+  const decimals = isNative ? 18 : await resolveErc20Decimals({ publicClient, token: erc20 });
+  const amountWei = parseUnits(args.amountHuman.trim(), decimals);
+  if (amountWei <= 0n) throw new Error("amountHuman must be a positive deposit amount.");
+  const feeWei = await readSocketFee({ publicClient, vault, connector });
+  const vaultCalldata = encodeFunctionData({
+    abi: socketVaultLegacyAbi,
+    functionName: "depositToAppChain",
+    args: [receiver, amountWei, DERIVE_SOCKET_MSG_GAS_LIMIT, connector]
+  });
+  const steps = [];
+  if (isNative) {
+    steps.push({
+      to: erc20,
+      data: encodeFunctionData({ abi: wethDepositAbi, functionName: "deposit" }),
+      value: amountWei,
+      fallbackGas: WRAP_FALLBACK
+    });
+  }
+  const approveSteps = await buildConditionalErc20ApproveSteps({
+    publicClient,
+    token: erc20,
+    spender: vault,
+    owner: executor,
+    amountWei,
+    fallbackGas: APPROVE_FALLBACK
+  });
+  steps.push(
+    ...approveSteps.map((s) => ({
+      to: s.to,
+      data: s.data,
+      value: s.value,
+      fallbackGas: s.fallbackGas ?? APPROVE_FALLBACK
+    }))
+  );
+  steps.push({ to: vault, data: vaultCalldata, value: feeWei, fallbackGas: BRIDGE_FALLBACK });
+  const firstDataNo0x = steps[0].data.startsWith("0x") ? steps[0].data.slice(2) : steps[0].data;
+  const gasLimitConfig = args.useCustomGas && args.chainDetail?.gasLimit != null ? Number(args.chainDetail.gasLimit) : void 0;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl.trim(),
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate: args.expiryDate
+    },
+    steps,
+    purposeSuffix: `Derive Socket deposit ${route.symbol} \u2192 Derive Chain (FAST). Credit in ~2\u20135 min; then fetch_subaccounts.`,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    payableValueWei: steps.reduce((sum, s) => sum + s.value, 0n),
+    resolveGasLimit: ({ index, estimatedGas }) => {
+      if (index === steps.length - 1) {
+        const gas = BRIDGE_FALLBACK;
+        return args.useCustomGas ? gasLimitFromEstimateAndChainConfig(gas, gasLimitConfig) : gas;
+      }
+      return estimatedGas;
+    },
+    buildBatchMeta: ({ index }) => ({
+      signatureText: JSON.stringify({
+        kind: "Derive",
+        protocol: DERIVE_PROTOCOL_ID,
+        action: index === steps.length - 1 ? "socketDeposit" : isNative && index === 0 ? "wrap" : "approve",
+        chainId: args.chainId,
+        symbol: route.symbol,
+        vault
+      })
+    })
+  });
+}
+var WRAP_FALLBACK2 = 80000n;
+var APPROVE_FALLBACK2 = 100000n;
+var DEPOSIT_FALLBACK = 250000n;
+var whypeDepositAbi = parseAbi(["function deposit() payable"]);
+var vaultDepositAbi = parseAbi(["function deposit(uint256 amount)"]);
+async function buildDeriveHypeVaultDepositMultisign(args) {
+  if (args.chainId !== DERIVE_HYPE_CHAIN_ID) {
+    throw new Error("Derive HYPE vault deposits are HyperEVM only (chainId 999).");
+  }
+  const executor = getAddress(args.executorAddress);
+  const vault = deriveHypeVaultAddress(args.vault);
+  const raw = (args.token ?? NATIVE_ZERO).trim();
+  const isNative = !raw || raw.toLowerCase() === "native" || raw.toLowerCase() === NATIVE_ZERO;
+  const amountWei = parseUnits(args.amountHuman.trim(), 18);
+  if (amountWei <= 0n) throw new Error("amountHuman must be a positive HYPE amount.");
+  const publicClient = publicClientForRpc(args.chainId, args.rpcUrl);
+  const steps = [];
+  if (isNative) {
+    steps.push({
+      to: getAddress(DERIVE_WHYPE),
+      data: encodeFunctionData({ abi: whypeDepositAbi, functionName: "deposit" }),
+      value: amountWei,
+      fallbackGas: WRAP_FALLBACK2
+    });
+  }
+  const approveSteps = await buildConditionalErc20ApproveSteps({
+    publicClient,
+    token: getAddress(DERIVE_WHYPE),
+    spender: vault,
+    owner: executor,
+    amountWei,
+    fallbackGas: APPROVE_FALLBACK2
+  });
+  steps.push(
+    ...approveSteps.map((s) => ({
+      to: s.to,
+      data: s.data,
+      value: s.value,
+      fallbackGas: s.fallbackGas ?? APPROVE_FALLBACK2
+    }))
+  );
+  steps.push({
+    to: vault,
+    data: encodeFunctionData({ abi: vaultDepositAbi, functionName: "deposit", args: [amountWei] }),
+    value: 0n,
+    fallbackGas: DEPOSIT_FALLBACK
+  });
+  const firstDataNo0x = steps[0].data.startsWith("0x") ? steps[0].data.slice(2) : steps[0].data;
+  const gasLimitConfig = args.useCustomGas && args.chainDetail?.gasLimit != null ? Number(args.chainDetail.gasLimit) : void 0;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl.trim(),
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails,
+      expiryDate: args.expiryDate
+    },
+    steps,
+    purposeSuffix: "Derive: wrap HYPE \u2192 WHYPE (if native), approve vault, deposit. First credit creates a Standard Margin subaccount.",
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    payableValueWei: steps.reduce((sum, s) => sum + s.value, 0n),
+    resolveGasLimit: ({ index, estimatedGas }) => {
+      if (index === steps.length - 1) {
+        const gas = DEPOSIT_FALLBACK;
+        return args.useCustomGas ? gasLimitFromEstimateAndChainConfig(gas, gasLimitConfig) : gas;
+      }
+      return estimatedGas;
+    },
+    buildBatchMeta: ({ index }) => ({
+      signatureText: JSON.stringify({
+        kind: "Derive",
+        protocol: DERIVE_PROTOCOL_ID,
+        action: index === steps.length - 1 ? "hypeVaultDeposit" : isNative && index === 0 ? "wrap" : "approve",
+        chainId: args.chainId,
+        vault
+      })
+    })
+  });
+}
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+async function buildDeriveTransferSpotMultisign(args) {
+  let fromId;
+  try {
+    fromId = assertPositiveSubaccountId(args.fromSubaccountId);
+  } catch {
+    throw new Error(DERIVE_MISSING_SUBACCOUNT_ERROR);
+  }
+  const toId = BigInt(args.toSubaccountId ?? 0);
+  const newManager = BigInt(args.newSubaccountManager);
+  if (toId === 0n && newManager <= 0n) {
+    throw new Error("newSubaccountManager is required when toSubaccountId is 0 (create an extra subaccount).");
+  }
+  const owner = getAddress(args.executorAddress);
+  const network = deriveNetworkFromChainId(args.chainId);
+  const nonce = args.nonce ?? deriveRandomNonce();
+  const expirySec = deriveExpirySec(args.signatureExpirySec);
+  const data = encodeDeriveTransferData({
+    toSubaccountId: toId,
+    newSubaccountManager: newManager,
+    asset: args.asset,
+    subId: args.subId ?? 0,
+    amount: args.amount,
+    maxFeeUsd: args.maxFeeUsd ?? "0"
+  });
+  const typedData = buildDeriveActionTypedData({
+    network,
+    subaccountId: fromId,
+    nonce,
+    module: DERIVE_TRANSFER_MODULE,
+    data,
+    expirySec,
+    owner,
+    signer: owner
+  });
+  return buildEip712Multisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS2,
+    expiryDate: args.expiryDate,
+    legs: [
+      {
+        typedData,
+        delivery: {
+          kind: "derive_exchange",
+          method: "private/transfer_spot",
+          chainId: args.chainId,
+          network,
+          settlementChainId: deriveSettlementChainId(network),
+          params: {
+            subaccount_id: Number(fromId),
+            nonce,
+            signer: owner,
+            signature_expiry_sec: expirySec,
+            asset: getAddress(args.asset),
+            amount: args.amount,
+            to_subaccount_id: Number(toId),
+            new_subaccount_manager: Number(newManager)
+          }
+        },
+        audit: {
+          protocol: DERIVE_PROTOCOL_ID,
+          action: "transferSpot",
+          fromSubaccountId: fromId.toString(),
+          toSubaccountId: toId.toString(),
+          newSubaccountManager: newManager.toString()
+        }
+      }
+    ]
+  });
+}
+
+// src/protocols/evm/derive/index.ts
+var deriveProtocolModule = {
+  id: DERIVE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const chainId = typeof ctx.chainId === "number" ? ctx.chainId : Number(ctx.chainId);
+    return Number.isFinite(chainId) && isDeriveChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "erc20" || token.kind === "native";
+  },
+  actions: [
+    {
+      id: "derive.depositNewSubaccount",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Ethereum L1 approve + ACTION_MANAGER.depositToNewSubaccount. First credit creates the trading + fallback subaccounts. chainId 1 / 11155111. Arb/OP/Base use derive.socketDeposit; HyperEVM HYPE uses derive.hypeVaultDeposit.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        protocolAsset: { type: "string", required: true, description: "Risk-universe collateral protocol asset" },
+        underlyingErc20: { type: "string", required: true, description: "L1 ERC-20 to approve (usually USDC)" },
+        amountHuman: { type: "string", required: true, description: "Deposit amount in underlying decimals" },
+        managerId: { type: "number", required: true, description: "Risk-universe manager_id" }
+      }
+    },
+    {
+      id: "derive.depositAddressTransfer",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Ethereum L1 ERC-20 transfer to a registered Derive deposit address (standard / keeper sweep). Call register_deposit_address first.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        underlyingErc20: { type: "string", required: true, description: "L1 ERC-20 to send (usually USDC)" },
+        amountHuman: { type: "string", required: true, description: "Transfer amount in token units" },
+        depositAddress: { type: "string", required: true, description: "From register_deposit_address" }
+      }
+    },
+    {
+      id: "derive.socketDeposit",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Socket FAST deposit of USDC/WETH/WBTC on Ethereum, Optimism, Base, or Arbitrum into Derive Chain. Native ETH wraps to WETH first. useCustomGas.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        token: { type: "string", required: true, description: "Row ERC-20 or native 0x0 (wraps to WETH)" },
+        amountHuman: { type: "string", required: true, description: "Deposit amount in token units" }
+      }
+    },
+    {
+      id: "derive.hypeVaultDeposit",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "HyperEVM (999): wrap native HYPE to WHYPE if needed, approve Derive vault, deposit.",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        amountHuman: { type: "string", required: true, description: "HYPE amount" },
+        token: { type: "string", required: false, description: "Native 0x0 or WHYPE" }
+      }
+    },
+    {
+      id: "derive.placeOrder",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place a Derive options limit order via EIP-712 Action (delivery derive_exchange). Does not spend the current-chain token.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        instrumentName: { type: "string", required: true, description: "e.g. ETH-20260626-3000-C" },
+        direction: { type: "string", required: true, description: "buy or sell" },
+        amount: { type: "string", required: true, description: "Contract size" },
+        limitPrice: { type: "string", required: true, description: "Limit price" },
+        maxFee: { type: "string", required: true, description: "Max fee (e18-scaled, \u226412 decimals)" },
+        subaccountId: { type: "number", required: true, description: "From fetch_subaccounts \u2014 never 0" }
+      }
+    },
+    {
+      id: "derive.replaceOrder",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Replace a Derive open order (EIP-712 Action + orderIdToCancel or nonceToCancel).",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        instrumentName: { type: "string", required: true, description: "Instrument of the replacement order" },
+        direction: { type: "string", required: true, description: "buy or sell" },
+        amount: { type: "string", required: true, description: "Contract size" },
+        limitPrice: { type: "string", required: true, description: "Limit price" },
+        maxFee: { type: "string", required: true, description: "Max fee" },
+        subaccountId: { type: "number", required: true, description: "From fetch_subaccounts" },
+        orderIdToCancel: { type: "string", required: false, description: "Existing order id (xor nonceToCancel)" },
+        nonceToCancel: { type: "string", required: false, description: "Existing order nonce (xor orderIdToCancel)" }
+      }
+    },
+    {
+      id: "derive.cancel",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel a Derive open order. v3 cancel is session-auth; this signs EIP-191 login for private/cancel delivery.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        instrumentName: { type: "string", required: true, description: "Instrument of the open order" },
+        orderId: { type: "string", required: true, description: "order_id from fetch_open_orders" },
+        subaccountId: { type: "number", required: true, description: "From fetch_subaccounts" }
+      }
+    },
+    {
+      id: "derive.transferSpot",
+      protocolId: DERIVE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "EIP-712 transfer_spot. Use toSubaccountId 0 + newSubaccountManager to create an extra subaccount after the first funded one.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        fromSubaccountId: { type: "number", required: true, description: "Funded source subaccount" },
+        toSubaccountId: { type: "number", required: true, description: "0 to create an extra subaccount" },
+        newSubaccountManager: { type: "number", required: true, description: "Required when toSubaccountId is 0" },
+        asset: { type: "string", required: true, description: "Protocol asset address" },
+        amount: { type: "string", required: true, description: "Transfer amount" }
+      }
+    }
+  ]
+};
+registerProtocolModule(deriveProtocolModule);
+
+export { DERIVE_ACTION_MANAGER_TESTNET, DERIVE_ACTION_TYPEHASH, DERIVE_ACTION_TYPES, DERIVE_ASSET_ROW_CHAIN_IDS, DERIVE_DEFAULT_LOOKBACK_DAYS, DERIVE_DEFAULT_OHLCV_BARS, DERIVE_DEFAULT_OHLCV_INTERVAL, DERIVE_DEFAULT_SIGNATURE_EXPIRY_SEC, DERIVE_DEFAULT_TICKER_ATM_STRIKES, DERIVE_DOMAIN_SEPARATOR_MAINNET, DERIVE_DOMAIN_SEPARATOR_TESTNET, DERIVE_EIP712_NAME, DERIVE_EIP712_VERSION, DERIVE_HYPE_CHAIN_ID, DERIVE_HYPE_VAULT_DEFAULT, DERIVE_MAINNET_API, DERIVE_MAINNET_API_V2, DERIVE_MATCHING_VERIFYING_CONTRACT, DERIVE_MAX_LOOKBACK_DAYS, DERIVE_MAX_OHLCV_BARS, DERIVE_MIN_ORDER_EXPIRY_SEC, DERIVE_MISSING_SUBACCOUNT_ERROR, DERIVE_OHLCV_INTERVALS, DERIVE_OHLCV_PERIOD_SEC, DERIVE_PROTOCOL_ID, DERIVE_SETTLEMENT_CHAIN_IDS, DERIVE_SOCKET_APP_CHAIN_ID, DERIVE_SOCKET_CHAIN_IDS, DERIVE_SOCKET_FEE_FALLBACK_WEI, DERIVE_SOCKET_MSG_GAS_LIMIT, DERIVE_TESTNET_API, DERIVE_TESTNET_API_V2, DERIVE_TRADE_MODULE, DERIVE_TRANSFER_MODULE, DERIVE_UNFUNDED_NEXT, DERIVE_UNFUNDED_NOTES, DERIVE_WHYPE, NATIVE_ZERO, assertPositiveSubaccountId, buildDeriveActionTypedData, buildDeriveCancelMultisign, buildDeriveDepositAddressTransferMultisign, buildDeriveDepositNewSubaccountMultisign, buildDeriveHypeVaultDepositMultisign, buildDerivePlaceOrderMultisign, buildDeriveReplaceOrderMultisign, buildDeriveSocketDepositMultisign, buildDeriveTransferSpotMultisign, collectDeriveTickerRows, deriveActionManagerAddress, deriveActionTypehash, deriveAdvisorNotes, deriveApiBaseUrl, deriveApiBaseUrlForChainId, deriveApiFallbackBaseUrl, deriveAtmTickerWindow, deriveAuthHeaders, deriveDomainSeparator, deriveE18, deriveEmptySubaccountsPayload, deriveExpirySec, deriveExpiryUnixToYmd, deriveFetchCurrenciesRaw, deriveFetchCurrenciesSummary, deriveFetchInstrument, deriveFetchMarketSnapshotSummary, deriveFetchOhlcvSummary, deriveFetchOpenOrdersSummary, deriveFetchOptionChainAgentSummary, deriveFetchOptionChainSummary, deriveFetchOptionInstruments, deriveFetchOrderBookSummary, deriveFetchPendingDepositsSummary, deriveFetchPortfolioSummary, deriveFetchPositionsSummary, deriveFetchRiskUniversesSummary, deriveFetchSubaccountsSummary, deriveFetchTickersSummary, deriveFundRouteForAssetRow, deriveFundableTokensForChain, deriveHypeVaultAddress, deriveKeyForNodeAssetRow, deriveLoginDigest, deriveLoginMessage, deriveLoginTimestamp, deriveMappedTokensForChain, deriveMatchingDomain, deriveNativeWrappedForChain, deriveNetworkFromChainId, deriveOrderQuoteSummary, deriveParseInstrumentName, deriveProtocolModule, deriveRandomNonce, deriveRegisterDepositAddress, deriveRpc, deriveSearchInstruments, deriveSearchInstrumentsSummary, deriveSettlementChainId, deriveSocketRouteForToken, deriveSocketWethRoute, encodeDeriveTradeData, encodeDeriveTransferData, hashDeriveAction, isDeriveAssetRowChainId, isDeriveChainSupported, isDerivePublicMethod, isDeriveRecoverablePublicError, isDeriveSettlementChainId, isDeriveSocketChainId, isEmptyDerivePublicResult, mapDeriveOrderBookLevels, mapDeriveTickerRow, mapDeriveTradingviewCandles, normalizeDeriveExpiryYmd, requireDeriveAuth, resolveDeriveOhlcvWindow, summarizeDeriveOptionChain, synthesizeDeriveRiskUniversesFromCurrencies };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map