@continuumdao/ctm-mpc-defi 0.2.47 → 0.2.49

package/dist/agent/catalog.cjs

@@ -4,6 +4,7 @@ var viem = require('viem');
 var api = require('@morpho-org/midnight-sdk/api');
 var zodToJsonSchema = require('zod-to-json-schema');
 var zod = require('zod');
+require('@msgpack/msgpack');
 var module$1 = require('module');
 var url = require('url');
 var fs = require('fs');
@@ -1302,6 +1303,14 @@ function aliasField(o, target, ...sources) {
   const val = firstDefined(...sources.map((k) => o[k]));
   if (val != null) o[target] = val;
 }
+function normalizeHyperliquidTrailingOffsetType(o) {
+  const raw = String(o.trailingOffsetType ?? "").trim().toLowerCase();
+  if (!raw) return;
+  if (raw === "price" || raw === "px" || raw === "distance") o.trailingOffsetType = "price";
+  else if (raw === "percentage" || raw === "percent" || raw === "pct" || raw === "%") {
+    o.trailingOffsetType = "percentage";
+  }
+}
 function derivePurposeIfMissing(o, build) {
   const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
   if (purposeText) {
@@ -1378,18 +1387,40 @@ function preprocessHyperliquidLimitOrderInput(raw) {
   aliasField(o, "szHuman", "szHuman", "sz", "size");
   aliasField(o, "takeProfitTriggerPxHuman", "takeProfitTriggerPxHuman", "takeProfitPxHuman", "tpTriggerPxHuman", "targetPxHuman");
   aliasField(o, "stopLossTriggerPxHuman", "stopLossTriggerPxHuman", "stopLossPxHuman", "slTriggerPxHuman", "invalidationPxHuman");
+  aliasField(o, "trailingOffsetHuman", "trailingOffsetHuman", "retracement", "trailingOffset");
+  aliasField(o, "trailingOffsetType", "trailingOffsetType", "retracementUnit", "offsetType");
+  aliasField(o, "trailingActivationPxHuman", "trailingActivationPxHuman", "activationPx", "activationPrice");
+  normalizeHyperliquidTrailingOffsetType(o);
   derivePurposeIfMissing(o, (x) => {
     const coin = String(x.coin ?? "").trim();
     const side = x.isBuy === true || x.isBuy === "true" ? "buy" : "sell";
     const sz = String(x.szHuman ?? "").trim();
     const tp = String(x.takeProfitTriggerPxHuman ?? "").trim();
     const sl = String(x.stopLossTriggerPxHuman ?? "").trim();
+    const trail = String(x.trailingOffsetHuman ?? "").trim();
+    if (coin && sz && trail) return `HL trailing ${side} ${coin} ${sz}`;
     if (coin && sz && (tp || sl)) return `HL bracket ${side} ${coin} ${sz}`;
     if (coin && sz) return `HL limit ${side} ${coin} ${sz}`;
     return void 0;
   });
   return o;
 }
+function preprocessHyperliquidTrailingStopInput(raw) {
+  const o = preprocessHyperliquidCoinInput(raw);
+  if (!preprocessObject(o)) return raw;
+  aliasField(o, "szHuman", "szHuman", "sz", "size");
+  aliasField(o, "trailingOffsetHuman", "trailingOffsetHuman", "retracement", "trailingOffset");
+  aliasField(o, "trailingOffsetType", "trailingOffsetType", "retracementUnit", "offsetType");
+  aliasField(o, "trailingActivationPxHuman", "trailingActivationPxHuman", "activationPx", "activationPrice");
+  normalizeHyperliquidTrailingOffsetType(o);
+  derivePurposeIfMissing(o, (x) => {
+    const coin = String(x.coin ?? "").trim();
+    const offset = String(x.trailingOffsetHuman ?? "").trim();
+    if (coin && offset) return `HL trailing stop ${coin} ${offset}`;
+    return void 0;
+  });
+  return o;
+}
 function preprocessHyperliquidCloseInput(raw) {
   const o = preprocessHyperliquidCoinInput(raw);
   if (!preprocessObject(o)) return raw;
@@ -3519,6 +3550,62 @@ var mcpContinuumDaoFetchProposalInputSchema = zod.z.object({
 var mcpContinuumDaoFetchProposalOutputSchema = zod.z.object({
   proposal: zod.z.unknown()
 });
+var mcpContinuumDaoProposalVoteRowSchema = zod.z.object({
+  voter: zod.z.string(),
+  explorerUrl: zod.z.string(),
+  support: zod.z.number().int(),
+  supportLabel: zod.z.string(),
+  weight: zod.z.string(),
+  weightCtm: zod.z.string(),
+  reason: zod.z.string(),
+  optionWeights: zod.z.array(zod.z.string()).optional(),
+  how: zod.z.string(),
+  attached: zod.z.boolean(),
+  attachedTokenId: zod.z.string().optional(),
+  nodeInfo: zod.z.object({
+    forumHandle: zod.z.string().optional(),
+    email: zod.z.string().optional(),
+    ipv4: zod.z.string().optional(),
+    ipv6: zod.z.string().optional(),
+    vpsProvider: zod.z.string().optional(),
+    ramInstalled: zod.z.string().optional(),
+    cpuCores: zod.z.string().optional(),
+    dIDType: zod.z.string().optional(),
+    dID: zod.z.string().optional(),
+    dataHex: zod.z.string().optional()
+  }).strict().optional(),
+  txHash: zod.z.string().optional(),
+  txExplorerUrl: zod.z.string().optional(),
+  blockNumber: zod.z.string().optional()
+});
+var mcpContinuumDaoFetchProposalVotesInputSchema = zod.z.object({
+  chainId: zod.z.union([zod.z.string(), zod.z.number()]),
+  rpcUrl: zod.z.string().min(1),
+  proposalId: zod.z.union([zod.z.string(), zod.z.number()]),
+  governor: evmAddressSchema.optional(),
+  votingEscrow: evmAddressSchema.optional(),
+  nodeProperties: evmAddressSchema.optional(),
+  fromBlock: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  toBlock: zod.z.union([zod.z.string(), zod.z.number()]).optional()
+});
+var mcpContinuumDaoFetchProposalVotesOutputSchema = zod.z.object({
+  proposalId: zod.z.string(),
+  catalogId: zod.z.number().optional(),
+  governor: zod.z.string(),
+  nodeProperties: zod.z.string().optional(),
+  title: zod.z.string().optional(),
+  configuration: zod.z.enum(["bravo", "delta"]).optional(),
+  fromBlock: zod.z.string(),
+  toBlock: zod.z.string(),
+  truncated: zod.z.boolean(),
+  votes: zod.z.array(mcpContinuumDaoProposalVoteRowSchema),
+  voterCount: zod.z.number().int().nonnegative(),
+  attachedVoterCount: zod.z.number().int().nonnegative(),
+  forWeight: zod.z.string(),
+  againstWeight: zod.z.string(),
+  abstainWeight: zod.z.string(),
+  note: zod.z.string()
+});
 var liveProposalRowSchema = zod.z.object({
   id: zod.z.number().optional(),
   onchainId: zod.z.string(),
@@ -4516,6 +4603,34 @@ var mcpGmxFetchOhlcvOutputSchema = zod.z.object({
   candleCount: zod.z.number().int().nonnegative(),
   candles: zod.z.array(gmxOhlcvCandleSchema)
 });
+function hyperliquidFloatToWire(value) {
+  const n = typeof value === "number" ? value : Number.parseFloat(String(value).trim());
+  if (!Number.isFinite(n)) throw new Error("Invalid Hyperliquid wire number.");
+  const rounded = n.toFixed(8);
+  if (Math.abs(Number.parseFloat(rounded) - n) >= 1e-12) {
+    throw new Error(`Hyperliquid wire value ${value} has too many decimal places.`);
+  }
+  const normalized = Number(rounded === "-0" ? "0" : rounded);
+  return String(normalized);
+}
+var HYPERLIQUID_TRAILING_ACTIVATION_PX_ERROR = "Invalid trailing activation price.";
+var POSITIVE_DECIMAL_RE = /^\d+(\.\d+)?$/;
+function parseHyperliquidTrailingActivationPx(value) {
+  if (value == null) return null;
+  const raw = String(value).trim().replace(/,/g, "");
+  if (!raw) return null;
+  if (!POSITIVE_DECIMAL_RE.test(raw)) {
+    throw new Error(HYPERLIQUID_TRAILING_ACTIVATION_PX_ERROR);
+  }
+  const px = Number.parseFloat(raw);
+  if (!Number.isFinite(px) || px <= 0) {
+    throw new Error(HYPERLIQUID_TRAILING_ACTIVATION_PX_ERROR);
+  }
+  hyperliquidFloatToWire(raw);
+  return raw;
+}
+
+// src/agent/schemas/hyperliquid.ts
 function mcpHyperliquidMultisignInput(fields, preprocess) {
   const inner = evmMultisignCommonInputSchema.extend(fields);
   const shaped = preprocess ? zod.z.preprocess(preprocess, inner) : inner;
@@ -4663,7 +4778,16 @@ var mcpHyperliquidFetchOpenOrdersOutputSchema = zod.z.object({
       sz: zod.z.string(),
       oid: zod.z.number().describe("Pass to build_cancel_multisign as oid"),
       timestamp: zod.z.number(),
-      reduceOnly: zod.z.boolean().optional()
+      reduceOnly: zod.z.boolean().optional(),
+      isTrigger: zod.z.boolean().optional(),
+      triggerPx: zod.z.string().optional(),
+      triggerCondition: zod.z.string().optional(),
+      orderType: zod.z.string().optional(),
+      trailingStop: zod.z.object({
+        retracement: zod.z.string(),
+        activationPx: zod.z.string().nullable(),
+        bestPx: zod.z.string().nullable()
+      }).nullable().optional()
     })
   )
 });
@@ -4788,6 +4912,16 @@ var mcpHyperliquidFetchDelegationsOutputSchema = zod.z.object({
   )
 });
 var hyperliquidTpslExecModeSchema = zod.z.enum(["limit_at_trigger", "market"]);
+var mcpHyperliquidTrailingActivationPxSchema = zod.z.string().min(1).optional().superRefine((value, ctx) => {
+  try {
+    parseHyperliquidTrailingActivationPx(value);
+  } catch (e) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: e instanceof Error ? e.message : "Invalid trailing activation price."
+    });
+  }
+}).describe("Optional mark price where trailing tracking begins. Omit to start immediately.");
 var mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidMultisignInput(
   {
     coin: zod.z.string().min(1).describe("coin from fetch_markets (name) or search_markets"),
@@ -4799,10 +4933,30 @@ var mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidMultisignInput(
     dex: zod.z.string().optional(),
     takeProfitTriggerPxHuman: zod.z.string().min(1).optional().describe("Take-profit trigger price \u2014 with SL enables L1 normalTpsl bracket (EIP-712, not CoreWriter)."),
     stopLossTriggerPxHuman: zod.z.string().min(1).optional().describe("Stop-loss trigger price \u2014 with TP enables L1 normalTpsl bracket (EIP-712, not CoreWriter)."),
-    tpslExecMode: hyperliquidTpslExecModeSchema.optional().describe("Trigger execution: limit_at_trigger (default) or market.")
+    tpslExecMode: hyperliquidTpslExecModeSchema.optional().describe("Trigger execution: limit_at_trigger (default) or market."),
+    trailingOffsetHuman: zod.z.string().min(1).optional().describe(
+      "Trailing-stop retracement (price distance or percent). Cannot combine with stopLossTriggerPxHuman. Perp only \u2014 EIP-712 /exchange."
+    ),
+    trailingOffsetType: zod.z.enum(["price", "percentage"]).optional().describe("price = fixed distance; percentage = retracement rate (default)."),
+    trailingActivationPxHuman: mcpHyperliquidTrailingActivationPxSchema
   },
   preprocessHyperliquidLimitOrderInput
 );
+var mcpHyperliquidTrailingStopInputSchema = mcpHyperliquidMultisignInput(
+  {
+    coin: zod.z.string().min(1).describe("perp coin from fetch_markets or fetch_positions"),
+    isBuy: agentBooleanSchema().describe(
+      "Execution side: false to close a long / open a short; true to close a short / open a long."
+    ),
+    szHuman: zod.z.string().min(1).describe("Size in coin units (use position size to close)."),
+    reduceOnly: agentBooleanSchema().optional().describe("true (default) closes/reduces; false can open a position."),
+    trailingOffsetHuman: zod.z.string().min(1).describe("Retracement distance or percent (e.g. 2 or 2%)."),
+    trailingOffsetType: zod.z.enum(["price", "percentage"]).optional().describe("price = fixed distance; percentage = retracement rate (default)."),
+    trailingActivationPxHuman: mcpHyperliquidTrailingActivationPxSchema,
+    dex: zod.z.string().optional()
+  },
+  preprocessHyperliquidTrailingStopInput
+);
 var mcpHyperliquidCloseInputSchema = mcpHyperliquidMultisignInput(
   {
     coin: zod.z.string().min(1),
@@ -5134,6 +5288,305 @@ var mcpArcusBuildWithdrawMultisignInputSchema = withMultisignKeySourceRefine(
     product: arcusFundProductSchema
   })
 );
+function mcpDeriveMultisignInput(fields) {
+  return withMultisignKeySourceRefine(evmMultisignCommonInputSchema.extend(fields));
+}
+var deriveAuthSchema = zod.z.object({
+  wallet: zod.z.string().min(1),
+  timestamp: zod.z.string().min(1),
+  signature: zod.z.string().min(1)
+}).optional().describe("Server-filled EIP-191 login (X-DeriveWallet / Timestamp / Signature). Agents must not pass auth.");
+var deriveNetworkSchema = zod.z.enum(["mainnet", "testnet"]).optional();
+var deriveFetchBaseSchema = zod.z.object({
+  chainId: zod.z.coerce.number().int().positive().optional().describe("Asset-row chain (dialog context). Trading is always Derive API."),
+  network: deriveNetworkSchema
+});
+var deriveWalletSchema = deriveFetchBaseSchema.extend({
+  wallet: evmAddressSchema.optional(),
+  executorAddress: evmAddressSchema.optional().describe("MPC executor \u2014 same address is the Derive owner on every chain."),
+  auth: deriveAuthSchema
+});
+var deriveOhlcvIntervalSchema = zod.z.enum(["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w"]);
+var deriveOhlcvCandleSchema = zod.z.object({
+  timestampMs: zod.z.number(),
+  open: zod.z.string(),
+  high: zod.z.string(),
+  low: zod.z.string(),
+  close: zod.z.string(),
+  volume: zod.z.string()
+});
+var mcpDeriveFetchCurrenciesInputSchema = deriveFetchBaseSchema;
+var mcpDeriveFetchCurrenciesOutputSchema = zod.z.object({
+  currencies: zod.z.array(zod.z.object({ currency: zod.z.string() })),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchOptionChainInputSchema = deriveFetchBaseSchema.extend({
+  currency: zod.z.string().min(1).describe("Underlying currency e.g. ETH"),
+  expired: zod.z.boolean().optional()
+});
+var mcpDeriveFetchOptionChainOutputSchema = zod.z.object({
+  currency: zod.z.string(),
+  instrumentCount: zod.z.number(),
+  callCount: zod.z.number(),
+  putCount: zod.z.number(),
+  expiries: zod.z.array(
+    zod.z.object({
+      expiryYmd: zod.z.string(),
+      expiryUnix: zod.z.number().nullable(),
+      callCount: zod.z.number(),
+      putCount: zod.z.number(),
+      minStrike: zod.z.string().nullable(),
+      maxStrike: zod.z.string().nullable()
+    })
+  ),
+  notes: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchTickersInputSchema = deriveFetchBaseSchema.extend({
+  currency: zod.z.string().min(1).describe("Underlying e.g. ETH"),
+  expiryDate: zod.z.union([zod.z.string().min(1), zod.z.number().int().positive()]).describe("YYYYMMDD from fetch_option_chain. String or number (20260925). 2026-09-25 is ok."),
+  optionType: zod.z.enum(["C", "P"]).optional().describe("Calls only or puts only. Omit for both."),
+  ladder: zod.z.enum(["atm", "all"]).optional().describe("Default atm (~9 strikes around index). Use all only when the operator wants every strike.")
+});
+var mcpDeriveFetchTickersOutputSchema = zod.z.object({
+  currency: zod.z.string(),
+  expiryDate: zod.z.string(),
+  optionType: zod.z.enum(["C", "P"]).nullable().optional(),
+  ladder: zod.z.enum(["atm", "all"]).optional(),
+  indexPx: zod.z.string().nullable().optional(),
+  listedCount: zod.z.number().optional(),
+  tickerCount: zod.z.number().optional(),
+  callCount: zod.z.number().optional(),
+  putCount: zod.z.number().optional(),
+  tickers: zod.z.array(
+    zod.z.object({
+      instrumentName: zod.z.string(),
+      bidPx: zod.z.string().nullable(),
+      askPx: zod.z.string().nullable(),
+      markPx: zod.z.string().nullable(),
+      indexPx: zod.z.string().nullable(),
+      strike: zod.z.string().nullable(),
+      expiry: zod.z.number().nullable(),
+      expiryYmd: zod.z.string().nullable(),
+      optionType: zod.z.enum(["C", "P"]).nullable(),
+      greeks: zod.z.unknown().nullable()
+    })
+  ),
+  notes: zod.z.string().optional(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveSearchInstrumentsInputSchema = deriveFetchBaseSchema.extend({
+  currency: zod.z.string().min(1),
+  query: zod.z.string().min(1).describe("Instrument name fragment e.g. 3000-C or 20260626"),
+  limit: zod.z.coerce.number().int().positive().max(50).optional()
+});
+var mcpDeriveSearchInstrumentsOutputSchema = zod.z.object({
+  instruments: zod.z.array(zod.z.object({ instrumentName: zod.z.string() })),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchMarketSnapshotInputSchema = deriveFetchBaseSchema.extend({
+  instrumentName: zod.z.string().min(1).describe("e.g. ETH-20260626-3000-C")
+});
+var mcpDeriveFetchMarketSnapshotOutputSchema = zod.z.object({
+  snapshot: zod.z.object({
+    instrumentName: zod.z.string(),
+    livePrice: zod.z.object({
+      markPx: zod.z.string().nullable(),
+      indexPx: zod.z.string().nullable(),
+      bidPx: zod.z.string().nullable(),
+      askPx: zod.z.string().nullable(),
+      midUsd: zod.z.string(),
+      source: zod.z.string()
+    }),
+    greeks: zod.z.unknown().nullable(),
+    fetchedAtMs: zod.z.number()
+  }),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchOhlcvInputSchema = deriveFetchBaseSchema.extend({
+  instrumentName: zod.z.string().optional().describe("Required for option candles"),
+  currency: zod.z.string().optional().describe("Required for index candles (underlying spot)"),
+  marketKind: zod.z.enum(["option", "index"]).optional(),
+  interval: deriveOhlcvIntervalSchema.optional(),
+  lookbackDays: zod.z.coerce.number().positive().optional(),
+  lookbackHours: zod.z.coerce.number().positive().optional(),
+  startTimeMs: zod.z.coerce.number().int().positive().optional(),
+  endTimeMs: zod.z.coerce.number().int().positive().optional()
+});
+var mcpDeriveFetchOhlcvOutputSchema = zod.z.object({
+  ohlcv: zod.z.object({
+    market: zod.z.string(),
+    coin: zod.z.string(),
+    interval: zod.z.string(),
+    marketKind: zod.z.enum(["option", "index"]),
+    startTimeMs: zod.z.number(),
+    endTimeMs: zod.z.number(),
+    expectedBars: zod.z.number(),
+    candleCount: zod.z.number(),
+    latestCandle: deriveOhlcvCandleSchema.nullable(),
+    candles: zod.z.array(deriveOhlcvCandleSchema),
+    fetchedAtMs: zod.z.number(),
+    dataSource: zod.z.literal("derive")
+  }),
+  dataSource: zod.z.literal("derive"),
+  network: zod.z.string().optional()
+});
+var mcpDeriveOrderQuoteInputSchema = deriveFetchBaseSchema.extend({
+  instrumentName: zod.z.string().min(1),
+  direction: zod.z.enum(["buy", "sell"]),
+  amount: zod.z.string().min(1),
+  limitPrice: zod.z.string().min(1),
+  subaccountId: agentCoercedIntSchema(zod.z.number().int().positive()).optional().describe("Required by v3 public/order_quote. From ctm_derive_fetch_subaccounts. Never 0.")
+});
+var mcpDeriveOrderQuoteOutputSchema = zod.z.object({
+  quote: jsonObjectSchema,
+  instrumentName: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchRiskUniversesInputSchema = deriveFetchBaseSchema;
+var mcpDeriveFetchRiskUniversesOutputSchema = zod.z.object({
+  universes: zod.z.array(zod.z.unknown()),
+  notes: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchPendingDepositsInputSchema = deriveWalletSchema;
+var mcpDeriveFetchPendingDepositsOutputSchema = zod.z.object({
+  pending: zod.z.array(zod.z.unknown()),
+  credited: zod.z.boolean(),
+  notes: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchSubaccountsInputSchema = deriveWalletSchema;
+var mcpDeriveFetchSubaccountsOutputSchema = zod.z.object({
+  wallet: zod.z.string(),
+  subaccounts: zod.z.array(zod.z.number()),
+  funded: zod.z.boolean(),
+  notes: zod.z.string(),
+  next: zod.z.array(zod.z.string()),
+  network: zod.z.string().optional()
+});
+var deriveSubaccountInput = deriveWalletSchema.extend({
+  subaccountId: agentCoercedIntSchema(zod.z.number().int().positive()).describe(
+    "subaccountId from ctm_derive_fetch_subaccounts. Never 0. If that list is empty, deposit on Ethereum L1 first."
+  )
+});
+var mcpDeriveFetchPortfolioInputSchema = deriveSubaccountInput;
+var mcpDeriveFetchPortfolioOutputSchema = zod.z.object({
+  portfolio: zod.z.unknown(),
+  subaccountId: zod.z.number(),
+  wallet: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchPositionsInputSchema = deriveSubaccountInput;
+var mcpDeriveFetchPositionsOutputSchema = zod.z.object({
+  positions: zod.z.array(zod.z.unknown()),
+  subaccountId: zod.z.number(),
+  wallet: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var mcpDeriveFetchOpenOrdersInputSchema = deriveSubaccountInput;
+var mcpDeriveFetchOpenOrdersOutputSchema = zod.z.object({
+  orders: zod.z.array(zod.z.unknown()),
+  subaccountId: zod.z.number(),
+  wallet: zod.z.string(),
+  network: zod.z.string().optional()
+});
+var deriveSubaccountIdField = agentCoercedIntSchema(zod.z.number().int().positive()).describe(
+  "subaccountId from ctm_derive_fetch_subaccounts. Collateral lives on Ethereum L1; EIP-712 orders do not move the current-chain token. If none exist, deposit first."
+);
+var mcpDeriveDepositNewSubaccountInputSchema = mcpDeriveMultisignInput({
+  protocolAsset: evmAddressSchema.describe("collaterals[].address from ctm_derive_fetch_risk_universes"),
+  underlyingErc20: evmAddressSchema.describe("collaterals[].erc20.underlying_erc20 on Ethereum L1 (usually USDC)"),
+  amountHuman: zod.z.string().min(1).describe("Deposit amount in underlying token units"),
+  managerId: agentCoercedIntSchema(zod.z.number().int().positive()).describe("Risk-universe manager_id"),
+  actionManager: evmAddressSchema.optional().describe("Override ACTION_MANAGER (required on mainnet until published)")
+});
+var mcpDeriveRegisterDepositAddressInputSchema = deriveFetchBaseSchema.extend({
+  wallet: evmAddressSchema,
+  managerId: agentCoercedIntSchema(zod.z.number().int().positive()).optional(),
+  subaccountId: agentCoercedIntSchema(zod.z.number().int().nonnegative()).optional()
+});
+var mcpDeriveRegisterDepositAddressOutputSchema = zod.z.object({
+  depositAddress: evmAddressSchema,
+  wallet: evmAddressSchema,
+  managerId: zod.z.number().int().nullable(),
+  subaccountId: zod.z.number().int().nullable(),
+  network: zod.z.string(),
+  notes: zod.z.string()
+});
+var mcpDeriveDepositAddressTransferInputSchema = mcpDeriveMultisignInput({
+  underlyingErc20: evmAddressSchema.describe("Ethereum L1 token to send (usually USDC)"),
+  amountHuman: zod.z.string().min(1),
+  depositAddress: evmAddressSchema.describe("From ctm_derive_register_deposit_address")
+});
+var mcpDeriveSocketDepositInputSchema = mcpDeriveMultisignInput({
+  token: evmAddressSchema.describe("USDC / WETH / WBTC on this chain, or native 0x0 to wrap WETH"),
+  amountHuman: zod.z.string().min(1),
+  receiver: evmAddressSchema.optional().describe("Derive Chain receiver; defaults to executor")
+});
+var mcpDeriveHypeVaultDepositInputSchema = mcpDeriveMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("HYPE amount"),
+  token: evmAddressSchema.optional().describe("Native 0x0 or WHYPE 0x555\u20265"),
+  vault: evmAddressSchema.optional()
+});
+var mcpDerivePlaceOrderInputSchema = mcpDeriveMultisignInput({
+  instrumentName: zod.z.string().min(1).describe("e.g. ETH-20260626-3000-C"),
+  direction: zod.z.enum(["buy", "sell"]),
+  amount: zod.z.string().min(1),
+  limitPrice: zod.z.string().min(1),
+  maxFee: zod.z.string().min(1),
+  subaccountId: deriveSubaccountIdField,
+  orderType: zod.z.enum(["limit", "market"]).optional(),
+  timeInForce: zod.z.enum(["gtc", "ioc", "fok", "post_only"]).optional(),
+  reduceOnly: zod.z.boolean().optional(),
+  label: zod.z.string().optional(),
+  ticketKind: zod.z.enum(["limit", "stop_limit", "twap"]).optional(),
+  triggerPrice: zod.z.string().optional().describe("Required for stop_limit"),
+  triggerType: zod.z.enum(["stoploss", "takeprofit"]).optional(),
+  triggerPriceType: zod.z.enum(["mark", "index"]).optional(),
+  algoDurationSec: agentCoercedIntSchema(zod.z.number().int().min(60)).optional().describe("Required for twap"),
+  algoNumSlices: agentCoercedIntSchema(zod.z.number().int().min(2)).optional().describe("Required for twap")
+});
+var mcpDeriveReplaceOrderInputSchema = mcpDeriveMultisignInput({
+  instrumentName: zod.z.string().min(1),
+  direction: zod.z.enum(["buy", "sell"]),
+  amount: zod.z.string().min(1),
+  limitPrice: zod.z.string().min(1),
+  maxFee: zod.z.string().min(1),
+  subaccountId: deriveSubaccountIdField,
+  orderType: zod.z.enum(["limit", "market"]).optional(),
+  timeInForce: zod.z.enum(["gtc", "ioc", "fok", "post_only"]).optional(),
+  reduceOnly: zod.z.boolean().optional(),
+  label: zod.z.string().optional(),
+  ticketKind: zod.z.enum(["limit", "stop_limit", "twap"]).optional(),
+  triggerPrice: zod.z.string().optional(),
+  triggerType: zod.z.enum(["stoploss", "takeprofit"]).optional(),
+  triggerPriceType: zod.z.enum(["mark", "index"]).optional(),
+  algoDurationSec: agentCoercedIntSchema(zod.z.number().int().min(60)).optional(),
+  algoNumSlices: agentCoercedIntSchema(zod.z.number().int().min(2)).optional(),
+  orderIdToCancel: zod.z.string().min(1).optional(),
+  nonceToCancel: zod.z.string().min(1).optional()
+}).refine((d) => Boolean(d.orderIdToCancel) !== Boolean(d.nonceToCancel), {
+  message: "Replace requires exactly one of orderIdToCancel or nonceToCancel."
+});
+var mcpDeriveCancelInputSchema = mcpDeriveMultisignInput({
+  instrumentName: zod.z.string().min(1),
+  orderId: zod.z.string().min(1).describe("order_id from ctm_derive_fetch_open_orders"),
+  subaccountId: deriveSubaccountIdField
+});
+var mcpDeriveTransferSpotInputSchema = mcpDeriveMultisignInput({
+  fromSubaccountId: deriveSubaccountIdField,
+  toSubaccountId: agentCoercedIntSchema(zod.z.number().int().nonnegative()).describe(
+    "Existing destination, or 0 to create an extra subaccount (requires newSubaccountManager)."
+  ),
+  newSubaccountManager: agentCoercedIntSchema(zod.z.number().int().nonnegative()).describe(
+    "Required when toSubaccountId is 0. Extra subaccounts only \u2014 first account is L1 deposit."
+  ),
+  asset: evmAddressSchema.describe("Protocol asset address"),
+  amount: zod.z.string().min(1),
+  maxFeeUsd: zod.z.string().optional(),
+  subId: agentCoercedIntSchema(zod.z.number().int().nonnegative()).optional()
+});
 var mcpCctpFeeFieldsSchema = zod.z.object({
   feeTierUsed: zod.z.enum(["low", "med", "high"]),
   maxFee: zod.z.string().describe("Selected tier max fee in USDC base units (6 decimals)"),
@@ -5844,11 +6297,21 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     actionId: "hyperliquid.limitOrder",
     protocolId: "hyperliquid",
     chainCategory: "evm",
-    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid limit/IoC order. Plain limit: CoreWriter (useCustomGas). When takeProfitTriggerPxHuman and/or stopLossTriggerPxHuman are set: one L1 EIP-712 normalTpsl bracket (entry + TP/SL) to /exchange \u2014 no useCustomGas.",
+    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid limit/IoC order. Plain limit: CoreWriter (useCustomGas). When takeProfitTriggerPxHuman, stopLossTriggerPxHuman, and/or trailingOffsetHuman are set: L1 EIP-712 to /exchange (normalTpsl for TP/SL; trailingStop is a second signed action) \u2014 no useCustomGas. Trailing cannot combine with a fixed SL. Perp only for trailing.",
     prerequisites: ["keyGenId", "chainId 999 or 998", "coin", "limitPxHuman", "szHuman"],
     handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildEvmMultisignBodyHyperliquidLimitOrderBatch" },
     inputZod: mcpHyperliquidLimitOrderInputSchema
   }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_build_trailing_stop_multisign",
+    actionId: "hyperliquid.trailingStop",
+    protocolId: "hyperliquid",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for a Hyperliquid perp trailing stop (EIP-712 L1 trailingStop action to /exchange \u2014 no useCustomGas). Retracement is a price distance or percentage; optional activation price delays tracking. Typically reduce-only to close a position. isBuy false closes a long / opens a short.",
+    prerequisites: ["keyGenId", "chainId 999 or 998", "coin", "szHuman", "trailingOffsetHuman"],
+    handler: { importPath: "protocols/evm/hyperliquid", exportName: "buildHyperliquidTrailingStopMultisign" },
+    inputZod: mcpHyperliquidTrailingStopInputSchema
+  }),
   defineProtocolMcpTool({
     name: "ctm_hyperliquid_build_close_multisign",
     actionId: "hyperliquid.close",
@@ -6390,6 +6853,108 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     prerequisites: ["keyGenId", "chainId", "comet", "steps"],
     handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Bulker" },
     inputZod: mcpCompoundV3BulkerInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_deposit_new_subaccount_multisign",
+    actionId: "derive.depositNewSubaccount",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Ethereum L1 only (chainId 1 / 11155111): approve the underlying ERC-20 to ACTION_MANAGER, then depositToNewSubaccount. First credit creates the trading + fallback (manager 0) subaccounts. Arb/OP/Base: ctm_derive_build_socket_deposit_multisign. HyperEVM HYPE: ctm_derive_build_hype_vault_deposit_multisign. useCustomGas.",
+    prerequisites: [
+      "chainId 1 or 11155111",
+      "managerId + protocolAsset + underlyingErc20 from ctm_derive_fetch_risk_universes",
+      "Ethereum L1 collateral (usually USDC)"
+    ],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveDepositNewSubaccountMultisign" },
+    inputZod: mcpDeriveDepositNewSubaccountInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_deposit_address_transfer_multisign",
+    actionId: "derive.depositAddressTransfer",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Ethereum L1 ERC-20 transfer to a registered Derive deposit address (standard / keeper sweep). Call ctm_derive_register_deposit_address first. useCustomGas.",
+    prerequisites: ["chainId 1 or 11155111", "depositAddress from ctm_derive_register_deposit_address"],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveDepositAddressTransferMultisign" },
+    inputZod: mcpDeriveDepositAddressTransferInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_socket_deposit_multisign",
+    actionId: "derive.socketDeposit",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Socket FAST deposit of USDC/WETH/WBTC on Ethereum, Optimism, Base, or Arbitrum. Native 0x0 wraps to WETH. Pays a small native bridge fee. useCustomGas.",
+    prerequisites: ["chainId 1 / 10 / 8453 / 42161", "token + amountHuman"],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveSocketDepositMultisign" },
+    inputZod: mcpDeriveSocketDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_hype_vault_deposit_multisign",
+    actionId: "derive.hypeVaultDeposit",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "HyperEVM (999) HYPE vault: wrap native HYPE to WHYPE if needed, approve, deposit. First credit creates a Standard Margin subaccount. useCustomGas.",
+    prerequisites: ["chainId 999", "amountHuman"],
+    followUp: ["ctm_derive_fetch_pending_deposits", "ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveHypeVaultDepositMultisign" },
+    inputZod: mcpDeriveHypeVaultDepositInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_place_order_multisign",
+    actionId: "derive.placeOrder",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "EIP-712 Derive options order (delivery derive_exchange). Requires subaccountId from ctm_derive_fetch_subaccounts. Does not move the current-chain token unless that row funded the account. No useCustomGas.",
+    prerequisites: [
+      "subaccountId from ctm_derive_fetch_subaccounts",
+      "funded Derive collateral (L1 / Socket / HYPE vault)",
+      "instrumentName, direction, amount, limitPrice, maxFee"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDerivePlaceOrderMultisign" },
+    inputZod: mcpDerivePlaceOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_replace_order_multisign",
+    actionId: "derive.replaceOrder",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "EIP-712 replace of a Derive open order. Requires subaccountId from ctm_derive_fetch_subaccounts and exactly one of orderIdToCancel or nonceToCancel. EIP-712 orders do not move the current-chain token.",
+    prerequisites: [
+      "subaccountId from ctm_derive_fetch_subaccounts",
+      "funded Derive collateral (L1 / Socket / HYPE vault)",
+      "orderIdToCancel or nonceToCancel"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveReplaceOrderMultisign" },
+    inputZod: mcpDeriveReplaceOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_cancel_multisign",
+    actionId: "derive.cancel",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Cancel a Derive open order (v3 private/cancel via EIP-191 login delivery). Requires subaccountId from ctm_derive_fetch_subaccounts. Does not move the current-chain token.",
+    prerequisites: [
+      "subaccountId from ctm_derive_fetch_subaccounts",
+      "orderId from ctm_derive_fetch_open_orders"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveCancelMultisign" },
+    inputZod: mcpDeriveCancelInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_derive_build_transfer_spot_multisign",
+    actionId: "derive.transferSpot",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "EIP-712 transfer_spot. Use toSubaccountId 0 + newSubaccountManager to create an extra subaccount after the first funded one. First account is a deposit (L1 / Socket / HYPE), not this tool.",
+    prerequisites: [
+      "fromSubaccountId from ctm_derive_fetch_subaccounts",
+      "funded Derive collateral (L1 / Socket / HYPE vault)"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveTransferSpotMultisign" },
+    inputZod: mcpDeriveTransferSpotInputSchema
   })
 ];
 
@@ -7851,9 +8416,10 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "continuum-dao.fetch-proposal-state",
     protocolId: "continuum-dao",
     chainCategory: "evm",
-    description: "Read ContinuumDAO.state and proposalVotes. `proposalId` may be a backend catalog id (0, -1, -2, \u2026) \u2014 those resolve to the row\u2019s onchainId hash and governorAddress before the Governor call. Catalog id 0 is not Governor proposal 0. Pass the row\u2019s governorAddress when set: ids -2 and -1 live on the superseded Linea governor 0x4800F9f1dC1b6daCA841B71E0531F547D374168E.",
+    description: "Read ContinuumDAO.state and proposalVotes. `proposalId` may be a backend catalog id (0, -1, -2, \u2026) \u2014 those resolve to the row\u2019s onchainId hash and governorAddress before the Governor call. Catalog id 0 is not Governor proposal 0. Pass the row\u2019s governorAddress when set: ids -2 and -1 live on the superseded Linea governor 0x4800F9f1dC1b6daCA841B71E0531F547D374168E. After this, offer ctm_continuum_dao_fetch_proposal_votes to see who voted and how.",
     prerequisites: ["rpcUrl", "proposalId", "governor"],
     followUp: [
+      "ctm_continuum_dao_fetch_proposal_votes",
       "ctm_continuum_dao_build_cast_vote_bravo_multisign",
       "ctm_continuum_dao_build_execute_multisign"
     ],
@@ -7866,9 +8432,13 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "continuum-dao.fetch-proposals",
     protocolId: "continuum-dao",
     chainCategory: "evm",
-    description: "List proposals from the public ContinuumDAO backend (POST /proposals). start/end are catalog id indexes (end exclusive), not offsets, and may be negative: the superseded Linea governor 0x4800F9f1\u2026 is stored as ids -2 and -1 so the current contract can start at 0. Omit start/end to fetch the full catalog (minIndex..maxIndex). Do not use this to answer \u201Cwhat is live now\u201D \u2014 use ctm_continuum_dao_fetch_live_proposals so on-chain state is overlaid.",
+    description: "List proposals from the public ContinuumDAO backend (POST /proposals). start/end are catalog id indexes (end exclusive), not offsets, and may be negative: the superseded Linea governor 0x4800F9f1\u2026 is stored as ids -2 and -1 so the current contract can start at 0. Omit start/end to fetch the full catalog (minIndex..maxIndex). Do not use this to answer \u201Cwhat is live now\u201D \u2014 use ctm_continuum_dao_fetch_live_proposals so on-chain state is overlaid. After naming a proposal, offer ctm_continuum_dao_fetch_proposal_votes so the operator can see who voted and how.",
     prerequisites: [],
-    followUp: ["ctm_continuum_dao_fetch_live_proposals", "ctm_continuum_dao_fetch_proposal"],
+    followUp: [
+      "ctm_continuum_dao_fetch_live_proposals",
+      "ctm_continuum_dao_fetch_proposal",
+      "ctm_continuum_dao_fetch_proposal_votes"
+    ],
     handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchProposals" },
     inputZod: mcpContinuumDaoFetchProposalsInputSchema,
     outputZod: mcpContinuumDaoFetchProposalsOutputSchema
@@ -7878,9 +8448,13 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "continuum-dao.fetch-proposal",
     protocolId: "continuum-dao",
     chainCategory: "evm",
-    description: "Fetch one proposal from the public ContinuumDAO backend (GET /proposals/:id). Id may be negative: -2 and -1 are the two proposals from the superseded Linea governor 0x4800F9f1dC1b6daCA841B71E0531F547D374168E.",
+    description: "Fetch one proposal from the public ContinuumDAO backend (GET /proposals/:id). Id may be negative: -2 and -1 are the two proposals from the superseded Linea governor 0x4800F9f1dC1b6daCA841B71E0531F547D374168E. After this, offer ctm_continuum_dao_fetch_proposal_votes so the operator can see who voted and how.",
     prerequisites: ["id"],
-    followUp: ["ctm_continuum_dao_explain_proposal", "ctm_continuum_dao_fetch_proposal_state"],
+    followUp: [
+      "ctm_continuum_dao_explain_proposal",
+      "ctm_continuum_dao_fetch_proposal_state",
+      "ctm_continuum_dao_fetch_proposal_votes"
+    ],
     handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchProposal" },
     inputZod: mcpContinuumDaoFetchProposalInputSchema,
     outputZod: mcpContinuumDaoFetchProposalOutputSchema
@@ -7890,11 +8464,12 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "continuum-dao.fetch-live-proposals",
     protocolId: "continuum-dao",
     chainCategory: "evm",
-    description: "Answer \u201Cwhat proposals are live now?\u201D. Lists the backend catalog (including negative ids on the superseded Linea governor) and overlays ContinuumDAO.state using each row\u2019s governorAddress. Rows set `committeeProposer` when the proposer is a ContinuumDAO Committee address \u2014 say Committee next to those titles. live = Active (voting). pending = Pending. readyToExecute = Succeeded (execute from here; no queue). recentlyCompleted = Canceled/Defeated/Expired/Executed in this scan. Requires Linea chainId + rpcUrl + governor for on-chain overlay. Read the `note` field aloud.",
+    description: "Answer \u201Cwhat proposals are live now?\u201D. Lists the backend catalog (including negative ids on the superseded Linea governor) and overlays ContinuumDAO.state using each row\u2019s governorAddress. Rows set `committeeProposer` when the proposer is a ContinuumDAO Committee address \u2014 say Committee next to those titles. live = Active (voting). pending = Pending. readyToExecute = Succeeded (execute from here; no queue). recentlyCompleted = Canceled/Defeated/Expired/Executed in this scan. Requires Linea chainId + rpcUrl + governor for on-chain overlay. Read the `note` field aloud. Then offer ctm_continuum_dao_fetch_proposal_votes for any named proposal so the operator can see who voted and how.",
     prerequisites: ["load_defi_protocol continuum-dao", "Linea chainId 59144 or 59141", "rpcUrl", "governor if constant is zero"],
     followUp: [
       "ctm_continuum_dao_explain_proposal",
       "ctm_continuum_dao_fetch_proposal",
+      "ctm_continuum_dao_fetch_proposal_votes",
       "ctm_continuum_dao_build_cast_vote_bravo_multisign",
       "ctm_continuum_dao_build_execute_multisign"
     ],
@@ -7907,13 +8482,32 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "continuum-dao.explain-proposal",
     protocolId: "continuum-dao",
     chainCategory: "evm",
-    description: "Deconstruct a ContinuumDAO proposal for the operator. Walks every user action (Bravo) or every option (Delta), labels encoder no-ops as signaling, flags C3 / value / approve / unknown signatures, and checks the forum thread section against the proposal type. `network.c3governor` is always present; an action is C3-remote only when network.name is not Linea (home chain 59144 / 59141). `committeeProposer` is true when the proposer is a ContinuumDAO Committee address \u2014 say that aloud. Read the `briefing` field aloud. Does not vote. For a policy recommendation load the mpc-config continuum-dao-vote-policy skill.",
+    description: "Deconstruct a ContinuumDAO proposal for the operator. Walks every user action (Bravo) or every option (Delta), labels encoder no-ops as signaling, flags C3 / value / approve / unknown signatures, and checks the forum thread section against the proposal type. `network.c3governor` is always present; an action is C3-remote only when network.name is not Linea (home chain 59144 / 59141). `committeeProposer` is true when the proposer is a ContinuumDAO Committee address \u2014 say that aloud. Read the `briefing` field aloud. Then offer ctm_continuum_dao_fetch_proposal_votes so the operator can see who voted and how. Does not vote. For a policy recommendation load the mpc-config continuum-dao-vote-policy skill.",
     prerequisites: ["id (backend) or onchainId"],
-    followUp: ["ctm_continuum_dao_fetch_proposal_state", "ctm_continuum_dao_forum_fetch_thread"],
+    followUp: [
+      "ctm_continuum_dao_fetch_proposal_votes",
+      "ctm_continuum_dao_fetch_proposal_state",
+      "ctm_continuum_dao_forum_fetch_thread"
+    ],
     handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoExplainProposal" },
     inputZod: mcpContinuumDaoExplainProposalInputSchema,
     outputZod: mcpContinuumDaoExplainProposalOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_proposal_votes",
+    actionId: "continuum-dao.fetch-proposal-votes",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Who voted on a ContinuumDAO proposal and how. Reads Governor VoteCast / VoteCastWithParams for live or past proposals. Each voter includes attached (NodeProperties.attachedTokenId after attachNodeFor) and, when they entered it at attach, nodeInfo (forum handle, VPS, DID, email, IP). Do not read email or IP aloud unless the operator asks. `proposalId` may be a backend catalog id (0, -1, -2, \u2026) or the on-chain hash. Bravo rows have For/Against/Abstain; Delta rows include option weights (last is NOTA). Offer this after listing or explaining a proposal. Linea only. Does not vote.",
+    prerequisites: ["rpcUrl", "proposalId", "governor if constant is zero"],
+    followUp: [
+      "ctm_continuum_dao_fetch_proposal_state",
+      "ctm_continuum_dao_explain_proposal"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchProposalVotes" },
+    inputZod: mcpContinuumDaoFetchProposalVotesInputSchema,
+    outputZod: mcpContinuumDaoFetchProposalVotesOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_continuum_dao_register_proposal",
     actionId: "continuum-dao.register-proposal",
@@ -8641,6 +9235,179 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     ],
     handler: { importPath: "protocols/evm/pendle", exportName: "buildEvmMultisignBodyPendleRedeemRewardsBatch" },
     inputZod: mcpPendleBuildRedeemRewardsMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_currencies",
+    actionId: "derive.fetch-currencies",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "List Derive currencies from public/get_all_currencies. Used to map asset-row symbols (ETH, USDC, BTC, \u2026). load_defi_protocol derive activates defi:derive:market-data.",
+    prerequisites: ["load_defi_protocol derive"],
+    followUp: ["ctm_derive_fetch_option_chain", "ctm_derive_fetch_tickers", "ctm_derive_search_instruments"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchCurrenciesSummary" },
+    inputZod: mcpDeriveFetchCurrenciesInputSchema,
+    outputZod: mcpDeriveFetchCurrenciesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_option_chain",
+    actionId: "derive.fetch-option-chain",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Compact Derive expiry ladder for a currency (counts + min/max strike per YYYYMMDD). Does not dump every instrument. Then ctm_derive_fetch_tickers for that expiry.",
+    prerequisites: ["currency e.g. ETH"],
+    followUp: ["ctm_derive_fetch_tickers", "ctm_derive_search_instruments", "ctm_derive_fetch_market_snapshot"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOptionChainAgentSummary" },
+    inputZod: mcpDeriveFetchOptionChainInputSchema,
+    outputZod: mcpDeriveFetchOptionChainOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_tickers",
+    actionId: "derive.fetch-tickers",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: 'ATM strike/premium ladder for one Derive expiry (bid/ask/mark). expiryDate is YYYYMMDD \u2014 string or number. Default ~9 strikes around index; pass ladder:"all" for every strike.',
+    prerequisites: ["currency", "expiryDate YYYYMMDD (string or number)"],
+    followUp: ["ctm_derive_fetch_market_snapshot", "ctm_derive_order_quote", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchTickersSummary" },
+    inputZod: mcpDeriveFetchTickersInputSchema,
+    outputZod: mcpDeriveFetchTickersOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_search_instruments",
+    actionId: "derive.search-instruments",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Search Derive option instrument names by strike, expiry, or C/P suffix.",
+    prerequisites: ["currency", "query"],
+    followUp: ["ctm_derive_fetch_market_snapshot", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveSearchInstrumentsSummary" },
+    inputZod: mcpDeriveSearchInstrumentsInputSchema,
+    outputZod: mcpDeriveSearchInstrumentsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_market_snapshot",
+    actionId: "derive.fetch-market-snapshot",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Live Derive ticker: mark, index, bid/ask, greeks. Throws if no live price.",
+    prerequisites: ["instrumentName from fetch_option_chain"],
+    followUp: ["ctm_derive_fetch_ohlcv", "ctm_derive_order_quote", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchMarketSnapshotSummary" },
+    inputZod: mcpDeriveFetchMarketSnapshotInputSchema,
+    outputZod: mcpDeriveFetchMarketSnapshotOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_ohlcv",
+    actionId: "derive.fetch-ohlcv",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: 'OHLCV for a Derive option (instrumentName) or underlying index (currency + marketKind index). Default is ~96 bars for the interval (not a 14-day dump). Envelope { ohlcv, dataSource: "derive" }. Then continuum__prepare_chart_from_rows if the user wants a chart.',
+    prerequisites: ["instrumentName or currency"],
+    followUp: ["continuum__prepare_chart_from_rows", "ctm_derive_fetch_market_snapshot"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOhlcvSummary" },
+    inputZod: mcpDeriveFetchOhlcvInputSchema,
+    outputZod: mcpDeriveFetchOhlcvOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_order_quote",
+    actionId: "derive.order-quote",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Dry-run Derive fill / margin preview (public/order_quote).",
+    prerequisites: ["instrumentName", "direction", "amount", "limitPrice"],
+    followUp: ["ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveOrderQuoteSummary" },
+    inputZod: mcpDeriveOrderQuoteInputSchema,
+    outputZod: mcpDeriveOrderQuoteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_risk_universes",
+    actionId: "derive.fetch-risk-universes",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "List Derive risk universes (manager_id + collaterals). Required before the first deposit. Pick a manager that lists ETH options and USDC (or the row currency).",
+    prerequisites: ["activate_tool_group defi:derive:options"],
+    followUp: [
+      "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"
+    ],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchRiskUniversesSummary" },
+    inputZod: mcpDeriveFetchRiskUniversesInputSchema,
+    outputZod: mcpDeriveFetchRiskUniversesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_pending_deposits",
+    actionId: "derive.fetch-pending-deposits",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Poll public/get_pending_deposits for the KeyGen wallet. credited:false means wait; then call fetch_subaccounts. First deposit is L1, Socket (ETH/OP/Base/Arb), or HyperEVM HYPE.",
+    prerequisites: ["wallet / executorAddress"],
+    followUp: ["ctm_derive_fetch_subaccounts"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchPendingDepositsSummary" },
+    inputZod: mcpDeriveFetchPendingDepositsInputSchema,
+    outputZod: mcpDeriveFetchPendingDepositsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_register_deposit_address",
+    actionId: "derive.register-deposit-address",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "public/register_deposit_address \u2014 deterministic Ethereum L1 deposit address for this wallet. Then transfer the token with ctm_derive_build_deposit_address_transfer_multisign. Do not send from Base/Arb to this address.",
+    prerequisites: ["wallet", "managerId (new subaccount) or subaccountId (existing)"],
+    followUp: ["ctm_derive_build_deposit_address_transfer_multisign", "ctm_derive_fetch_pending_deposits"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveRegisterDepositAddress" },
+    inputZod: mcpDeriveRegisterDepositAddressInputSchema,
+    outputZod: mcpDeriveRegisterDepositAddressOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_subaccounts",
+    actionId: "derive.fetch-subaccounts",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "List Derive subaccount ids for the KeyGen executor. Empty list returns funded:false and notes to deposit from a fundable logo row (L1 / Socket / HYPE vault). Two ids after first credit is normal (trading + fallback manager 0).",
+    prerequisites: ["wallet / executorAddress", "node-cached EIP-191 login"],
+    followUp: ["ctm_derive_fetch_portfolio", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchSubaccountsSummary" },
+    inputZod: mcpDeriveFetchSubaccountsInputSchema,
+    outputZod: mcpDeriveFetchSubaccountsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_portfolio",
+    actionId: "derive.fetch-portfolio",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Derive private/get_subaccount portfolio for a funded subaccountId.",
+    prerequisites: ["subaccountId from ctm_derive_fetch_subaccounts"],
+    followUp: ["ctm_derive_fetch_positions", "ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchPortfolioSummary" },
+    inputZod: mcpDeriveFetchPortfolioInputSchema,
+    outputZod: mcpDeriveFetchPortfolioOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_positions",
+    actionId: "derive.fetch-positions",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Open Derive option positions for a subaccountId from fetch_subaccounts.",
+    prerequisites: ["subaccountId from ctm_derive_fetch_subaccounts"],
+    followUp: ["ctm_derive_build_place_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchPositionsSummary" },
+    inputZod: mcpDeriveFetchPositionsInputSchema,
+    outputZod: mcpDeriveFetchPositionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_derive_fetch_open_orders",
+    actionId: "derive.fetch-open-orders",
+    protocolId: "derive",
+    chainCategory: "evm",
+    description: "Open Derive orders for a subaccountId. Follow with cancel/replace.",
+    prerequisites: ["subaccountId from ctm_derive_fetch_subaccounts"],
+    followUp: ["ctm_derive_build_cancel_multisign", "ctm_derive_build_replace_order_multisign"],
+    handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOpenOrdersSummary" },
+    inputZod: mcpDeriveFetchOpenOrdersInputSchema,
+    outputZod: mcpDeriveFetchOpenOrdersOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -9534,7 +10301,26 @@ var hyperliquidProtocolModule = {
         dex: { type: "string", required: false, description: "HIP-3 dex name when applicable" },
         takeProfitTriggerPxHuman: { type: "string", required: false, description: "TP trigger \u2014 enables L1 bracket with SL" },
         stopLossTriggerPxHuman: { type: "string", required: false, description: "SL trigger \u2014 enables L1 bracket with TP" },
-        tpslExecMode: { type: "string", required: false, description: "limit_at_trigger (default) or market" }
+        tpslExecMode: { type: "string", required: false, description: "limit_at_trigger (default) or market" },
+        trailingOffsetHuman: { type: "string", required: false, description: "Trailing retracement \u2014 EIP-712 trailingStop (cannot combine with SL)" },
+        trailingOffsetType: { type: "string", required: false, description: "price or percentage" },
+        trailingActivationPxHuman: { type: "string", required: false, description: "Optional activation mark price" }
+      }
+    },
+    {
+      id: "hyperliquid.trailingStop",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Place a Hyperliquid perp trailing stop via L1 trailingStop action (EIP-712 /exchange)",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        coin: { type: "string", required: true, description: "Perp coin" },
+        isBuy: { type: "boolean", required: true, description: "false closes a long / opens a short" },
+        szHuman: { type: "string", required: true, description: "Size in coin units" },
+        trailingOffsetHuman: { type: "string", required: true, description: "Retracement distance or percent" },
+        trailingOffsetType: { type: "string", required: false, description: "price or percentage (default)" },
+        trailingActivationPxHuman: { type: "string", required: false, description: "Optional activation mark price" },
+        reduceOnly: { type: "boolean", required: false, description: "true (default) reduces a position" }
       }
     },
     {
@@ -10488,6 +11274,7 @@ var continuumDaoProtocolModule = {
     { id: "continuum-dao.cancel", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cancel a proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "Catalog id or governor proposal hash" } } },
     { id: "continuum-dao.fetch-live-proposals", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List live/pending/succeeded proposals with on-chain state overlay", commonParams: [], params: { chainId: { type: "number", required: false, description: "Linea chain id" }, rpcUrl: { type: "string", required: false, description: "Linea RPC for state overlay" } } },
     { id: "continuum-dao.explain-proposal", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Deconstruct a proposal into a readable briefing (actions, C3, no-ops, risks)", commonParams: [], params: { id: { type: "string", required: false, description: "Backend proposal id" }, onchainId: { type: "string", required: false, description: "Governor proposal id" } } },
+    { id: "continuum-dao.fetch-proposal-votes", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Who voted on a proposal and how (VoteCast / VoteCastWithParams)", commonParams: [], params: { proposalId: { type: "string", required: true, description: "Catalog id or governor proposal hash" } } },
     { id: "continuum-dao.forum-sign-in", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "EIP-712 forum login (veCTM gate first)", commonParams: ["keyGen", "purposeText"], params: { nodeKey: { type: "string", required: false, description: "Attached node key" }, username: { type: "string", required: false, description: "Username when there is no node key" } } },
     { id: "continuum-dao.forum-sign-in-eligible", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Check veCTM forum login eligibility", commonParams: [], params: { address: { type: "string", required: true, description: "KeyGen or wallet address" } } },
     { id: "continuum-dao.forum-sign-out", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Revoke forum ticket and sessions", commonParams: [], params: { ticket: { type: "string", required: true, description: "Forum write ticket" } } },
@@ -11530,6 +12317,305 @@ var pendleProtocolModule = {
   ]
 };
 registerProtocolModule(pendleProtocolModule);
+
+// src/protocols/evm/derive/constants.ts
+var DERIVE_PROTOCOL_ID = "derive";
+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";
+function deriveNetworkFromChainId(chainId) {
+  return chainId === 11155111 ? "testnet" : "mainnet";
+}
+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;
+}
+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: viem.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.";
+}
+
+// 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
+    });
+  }
+}
+
+// src/protocols/evm/derive/assets.ts
+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 [];
+}
+
+// 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);
 var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('catalog.cjs', document.baseURI).href)))), "skills");
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
@@ -11549,6 +12635,7 @@ var SKILL_PROTOCOL_IDS = [
   "pendle",
   "continuum-dao",
   "compound-v3",
+  "derive",
   "yield-compare"
 ];
 function getToolsForProtocol(protocolId) {
@@ -11977,7 +13064,7 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       if (ve) tokens.push({ address: ve, symbol: "veCTM", roles: ["position_nft"] });
       return {
         tokens,
-        notes: tokens.length === 0 ? "ContinuumDAO addresses are placeholders until redeploy. Lock/attach/governance stay Linea-only. Create lock needs >= 1 CTM (live minimumLock) and 1\u2013208 weeks. Prefer live GET /protocol/dao. For \u201Cwhat proposals are live now?\u201D use ctm_continuum_dao_fetch_live_proposals (not fetch_proposals). Propose requires getVotes >= live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Bravo empty actions insert a KeyGen no-op; Delta votes need nOptions+1 weights (last is NOTA). No billing legs. After propose is mined, ctm_continuum_dao_register_proposal. Queue is not implemented." : `Default ContinuumDAO assets: ${listContinuumDaoDefaultAssets().filter((a) => a.chainId === chainId).map((a) => a.symbol).join(", ")}. Lock/attach/governance stay Linea-only. Create lock needs >= 1 CTM (live minimumLock) and 1\u2013208 weeks. For \u201Cwhat proposals are live now?\u201D use ctm_continuum_dao_fetch_live_proposals. Propose requires getVotes >= live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Bravo empty actions insert a KeyGen no-op; Delta votes need nOptions+1 weights (last is NOTA). No billing legs. After propose is mined, ctm_continuum_dao_register_proposal. Queue is not implemented.`
+        notes: tokens.length === 0 ? "ContinuumDAO addresses are placeholders until redeploy. Lock/attach/governance stay Linea-only. Create lock needs >= 1 CTM (live minimumLock) and 1\u2013208 weeks. Prefer live GET /protocol/dao. For \u201Cwhat proposals are live now?\u201D use ctm_continuum_dao_fetch_live_proposals (not fetch_proposals). After naming a proposal, offer ctm_continuum_dao_fetch_proposal_votes to see who voted and how. Propose requires getVotes >= live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Bravo empty actions insert a KeyGen no-op; Delta votes need nOptions+1 weights (last is NOTA). No billing legs. After propose is mined, ctm_continuum_dao_register_proposal. Queue is not implemented." : `Default ContinuumDAO assets: ${listContinuumDaoDefaultAssets().filter((a) => a.chainId === chainId).map((a) => a.symbol).join(", ")}. Lock/attach/governance stay Linea-only. Create lock needs >= 1 CTM (live minimumLock) and 1\u2013208 weeks. For \u201Cwhat proposals are live now?\u201D use ctm_continuum_dao_fetch_live_proposals. After naming a proposal, offer ctm_continuum_dao_fetch_proposal_votes to see who voted and how. Propose requires getVotes >= live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Bravo empty actions insert a KeyGen no-op; Delta votes need nOptions+1 weights (last is NOTA). No billing legs. After propose is mined, ctm_continuum_dao_register_proposal. Queue is not implemented.`
       };
     }
   }),
@@ -12088,6 +13175,45 @@ var PROTOCOL_SUPPORT_ADVISORS = {
         notes: "Arcus on Robinhood Chain (4663): perps via fetch_markets; spot Stock Tokens via spot_fetch_markets. Custody is secp256k1 on 4663; API signing uses paired ed25519 KeyGen (same GroupId)."
       };
     }
+  }),
+  [DERIVE_PROTOCOL_ID]: advisor(DERIVE_PROTOCOL_ID, "api_underlyings", {
+    async supportedChainIds() {
+      return [...DERIVE_ASSET_ROW_CHAIN_IDS];
+    },
+    async supportedTokens(chainId) {
+      if (!isDeriveChainSupported(chainId)) {
+        return { tokens: [], notes: "Derive logo rows are fundable chains only: Ethereum, OP, Base, Arbitrum, HyperEVM, Sepolia." };
+      }
+      const mapped = deriveMappedTokensForChain(chainId);
+      let tokens = mapped;
+      try {
+        const currencies = await deriveFetchCurrenciesRaw({ network: deriveNetworkFromChainId(chainId) });
+        const symbols = new Set(
+          currencies.map((c) => String(c.currency ?? "").toUpperCase()).filter(Boolean)
+        );
+        if (symbols.size > 0) {
+          tokens = mapped.filter((t) => {
+            const s = t.symbol.toUpperCase();
+            return symbols.has(s) || s === "WETH" && symbols.has("ETH") || s === "WBTC" && symbols.has("BTC") || s === "HYPE" || s === "WHYPE";
+          });
+        }
+      } catch {
+      }
+      return {
+        tokens,
+        nativeWrapped: deriveNativeWrappedForChain(chainId),
+        notes: deriveAdvisorNotes()
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      if (!isDeriveChainSupported(chainId)) return false;
+      try {
+        const normalized = viem.getAddress(address).toLowerCase();
+        return deriveMappedTokensForChain(chainId).some((t) => t.address.toLowerCase() === normalized);
+      } catch {
+        return false;
+      }
+    }
   })
 };
 function getProtocolSupportAdvisor(protocolId) {
@@ -12116,6 +13242,7 @@ registerProtocolModule(aerodromeProtocolModule);
 registerProtocolModule(continuumDaoProtocolModule);
 registerProtocolModule(compoundV3ProtocolModule);
 registerProtocolModule(pendleProtocolModule);
+registerProtocolModule(deriveProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -12142,6 +13269,7 @@ function getAgentCatalog() {
     continuumDao: continuumDaoProtocolModule,
     compoundV3: compoundV3ProtocolModule,
     pendle: pendleProtocolModule,
+    derive: deriveProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -12270,6 +13398,8 @@ exports.mcpContinuumDaoFetchProposalInputSchema = mcpContinuumDaoFetchProposalIn
 exports.mcpContinuumDaoFetchProposalOutputSchema = mcpContinuumDaoFetchProposalOutputSchema;
 exports.mcpContinuumDaoFetchProposalStateInputSchema = mcpContinuumDaoFetchProposalStateInputSchema;
 exports.mcpContinuumDaoFetchProposalStateOutputSchema = mcpContinuumDaoFetchProposalStateOutputSchema;
+exports.mcpContinuumDaoFetchProposalVotesInputSchema = mcpContinuumDaoFetchProposalVotesInputSchema;
+exports.mcpContinuumDaoFetchProposalVotesOutputSchema = mcpContinuumDaoFetchProposalVotesOutputSchema;
 exports.mcpContinuumDaoFetchProposalsInputSchema = mcpContinuumDaoFetchProposalsInputSchema;
 exports.mcpContinuumDaoFetchProposalsOutputSchema = mcpContinuumDaoFetchProposalsOutputSchema;
 exports.mcpContinuumDaoFetchVotingPowerInputSchema = mcpContinuumDaoFetchVotingPowerInputSchema;
@@ -12329,6 +13459,7 @@ exports.mcpContinuumDaoMpaMailboxSendOutputSchema = mcpContinuumDaoMpaMailboxSen
 exports.mcpContinuumDaoMpaRetractInputSchema = mcpContinuumDaoMpaRetractInputSchema;
 exports.mcpContinuumDaoMpaRetractOutputSchema = mcpContinuumDaoMpaRetractOutputSchema;
 exports.mcpContinuumDaoProposalIdInputSchema = mcpContinuumDaoProposalIdInputSchema;
+exports.mcpContinuumDaoProposalVoteRowSchema = mcpContinuumDaoProposalVoteRowSchema;
 exports.mcpContinuumDaoProposeBravoInputSchema = mcpContinuumDaoProposeBravoInputSchema;
 exports.mcpContinuumDaoProposeDeltaInputSchema = mcpContinuumDaoProposeDeltaInputSchema;
 exports.mcpContinuumDaoRegisterProposalInputSchema = mcpContinuumDaoRegisterProposalInputSchema;
@@ -12356,6 +13487,42 @@ exports.mcpCurveDaoQuoteInputSchema = mcpCurveDaoQuoteInputSchema;
 exports.mcpCurveDaoQuoteOutputSchema = mcpCurveDaoQuoteOutputSchema;
 exports.mcpCurveDaoQuoteRemoveLiquidityInputSchema = mcpCurveDaoQuoteRemoveLiquidityInputSchema;
 exports.mcpCurveDaoQuoteRemoveLiquidityOutputSchema = mcpCurveDaoQuoteRemoveLiquidityOutputSchema;
+exports.mcpDeriveCancelInputSchema = mcpDeriveCancelInputSchema;
+exports.mcpDeriveDepositAddressTransferInputSchema = mcpDeriveDepositAddressTransferInputSchema;
+exports.mcpDeriveDepositNewSubaccountInputSchema = mcpDeriveDepositNewSubaccountInputSchema;
+exports.mcpDeriveFetchCurrenciesInputSchema = mcpDeriveFetchCurrenciesInputSchema;
+exports.mcpDeriveFetchCurrenciesOutputSchema = mcpDeriveFetchCurrenciesOutputSchema;
+exports.mcpDeriveFetchMarketSnapshotInputSchema = mcpDeriveFetchMarketSnapshotInputSchema;
+exports.mcpDeriveFetchMarketSnapshotOutputSchema = mcpDeriveFetchMarketSnapshotOutputSchema;
+exports.mcpDeriveFetchOhlcvInputSchema = mcpDeriveFetchOhlcvInputSchema;
+exports.mcpDeriveFetchOhlcvOutputSchema = mcpDeriveFetchOhlcvOutputSchema;
+exports.mcpDeriveFetchOpenOrdersInputSchema = mcpDeriveFetchOpenOrdersInputSchema;
+exports.mcpDeriveFetchOpenOrdersOutputSchema = mcpDeriveFetchOpenOrdersOutputSchema;
+exports.mcpDeriveFetchOptionChainInputSchema = mcpDeriveFetchOptionChainInputSchema;
+exports.mcpDeriveFetchOptionChainOutputSchema = mcpDeriveFetchOptionChainOutputSchema;
+exports.mcpDeriveFetchPendingDepositsInputSchema = mcpDeriveFetchPendingDepositsInputSchema;
+exports.mcpDeriveFetchPendingDepositsOutputSchema = mcpDeriveFetchPendingDepositsOutputSchema;
+exports.mcpDeriveFetchPortfolioInputSchema = mcpDeriveFetchPortfolioInputSchema;
+exports.mcpDeriveFetchPortfolioOutputSchema = mcpDeriveFetchPortfolioOutputSchema;
+exports.mcpDeriveFetchPositionsInputSchema = mcpDeriveFetchPositionsInputSchema;
+exports.mcpDeriveFetchPositionsOutputSchema = mcpDeriveFetchPositionsOutputSchema;
+exports.mcpDeriveFetchRiskUniversesInputSchema = mcpDeriveFetchRiskUniversesInputSchema;
+exports.mcpDeriveFetchRiskUniversesOutputSchema = mcpDeriveFetchRiskUniversesOutputSchema;
+exports.mcpDeriveFetchSubaccountsInputSchema = mcpDeriveFetchSubaccountsInputSchema;
+exports.mcpDeriveFetchSubaccountsOutputSchema = mcpDeriveFetchSubaccountsOutputSchema;
+exports.mcpDeriveFetchTickersInputSchema = mcpDeriveFetchTickersInputSchema;
+exports.mcpDeriveFetchTickersOutputSchema = mcpDeriveFetchTickersOutputSchema;
+exports.mcpDeriveHypeVaultDepositInputSchema = mcpDeriveHypeVaultDepositInputSchema;
+exports.mcpDeriveOrderQuoteInputSchema = mcpDeriveOrderQuoteInputSchema;
+exports.mcpDeriveOrderQuoteOutputSchema = mcpDeriveOrderQuoteOutputSchema;
+exports.mcpDerivePlaceOrderInputSchema = mcpDerivePlaceOrderInputSchema;
+exports.mcpDeriveRegisterDepositAddressInputSchema = mcpDeriveRegisterDepositAddressInputSchema;
+exports.mcpDeriveRegisterDepositAddressOutputSchema = mcpDeriveRegisterDepositAddressOutputSchema;
+exports.mcpDeriveReplaceOrderInputSchema = mcpDeriveReplaceOrderInputSchema;
+exports.mcpDeriveSearchInstrumentsInputSchema = mcpDeriveSearchInstrumentsInputSchema;
+exports.mcpDeriveSearchInstrumentsOutputSchema = mcpDeriveSearchInstrumentsOutputSchema;
+exports.mcpDeriveSocketDepositInputSchema = mcpDeriveSocketDepositInputSchema;
+exports.mcpDeriveTransferSpotInputSchema = mcpDeriveTransferSpotInputSchema;
 exports.mcpEthenaClaimInputSchema = mcpEthenaClaimInputSchema;
 exports.mcpEthenaCooldownInputSchema = mcpEthenaCooldownInputSchema;
 exports.mcpEthenaFetchSusdeApyInputSchema = mcpEthenaFetchSusdeApyInputSchema;
@@ -12437,6 +13604,7 @@ exports.mcpHyperliquidLimitOrderInputSchema = mcpHyperliquidLimitOrderInputSchem
 exports.mcpHyperliquidSearchMarketsInputSchema = mcpHyperliquidSearchMarketsInputSchema;
 exports.mcpHyperliquidSearchMarketsOutputSchema = mcpHyperliquidSearchMarketsOutputSchema;
 exports.mcpHyperliquidStakeInputSchema = mcpHyperliquidStakeInputSchema;
+exports.mcpHyperliquidTrailingStopInputSchema = mcpHyperliquidTrailingStopInputSchema;
 exports.mcpHyperliquidUndelegateInputSchema = mcpHyperliquidUndelegateInputSchema;
 exports.mcpHyperliquidUnstakeInputSchema = mcpHyperliquidUnstakeInputSchema;
 exports.mcpHyperliquidUpdateLeverageInputSchema = mcpHyperliquidUpdateLeverageInputSchema;