@continuumdao/ctm-mpc-defi 0.2.49 → 0.2.51

package/dist/agent/catalog.cjs

@@ -538,6 +538,10 @@ function votingEscrowAddressOnEvmChain(chainId) {
   const ve = continuumDaoDeployment(chainId)?.votingEscrow;
   return ve && isConfiguredAddress(ve) ? viem.getAddress(ve) : null;
 }
+function votingEscrowMarketplaceAddressOnEvmChain(chainId) {
+  if (chainId !== CONTINUUM_DAO_LINEA_CHAIN_ID) return null;
+  return VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS;
+}
 function listContinuumDaoDefaultAssets() {
   const out = [];
   for (const chainId of [
@@ -569,7 +573,7 @@ function listContinuumDaoDefaultAssets() {
   }
   return out;
 }
-var CONTINUUM_DAO_PROTOCOL_ID, CONTINUUM_DAO_ETHEREUM_CHAIN_ID, CONTINUUM_DAO_LINEA_CHAIN_ID, CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID, CTM_TOKEN_NAME, CTM_TOKEN_SYMBOL, VECTM_TOKEN_NAME, VECTM_TOKEN_SYMBOL, CTM_TOKEN_DECIMALS, UNSET, CTM_TOKEN_ADDRESS, VOTING_ESCROW_LINEA_ADDRESS, CONTINUUM_DAO_DEPLOYMENTS;
+var CONTINUUM_DAO_PROTOCOL_ID, CONTINUUM_DAO_ETHEREUM_CHAIN_ID, CONTINUUM_DAO_LINEA_CHAIN_ID, CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID, CTM_TOKEN_NAME, CTM_TOKEN_SYMBOL, VECTM_TOKEN_NAME, VECTM_TOKEN_SYMBOL, CTM_TOKEN_DECIMALS, UNSET, CTM_TOKEN_ADDRESS, VOTING_ESCROW_LINEA_ADDRESS, VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS, CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, CONTINUUM_DAO_DEPLOYMENTS;
 var init_constants2 = __esm({
   "src/protocols/evm/continuum-dao/constants.ts"() {
     CONTINUUM_DAO_PROTOCOL_ID = "continuum-dao";
@@ -590,6 +594,11 @@ var init_constants2 = __esm({
     };
     CTM_TOKEN_ADDRESS = viem.getAddress("0x2026027054F5beBCEB650aBD62dC623e327658e7");
     VOTING_ESCROW_LINEA_ADDRESS = viem.getAddress("0x221EC90B3B083A8501A37bdeb7035CeaedF3C31f");
+    viem.getAddress("0x4ebd7cCBe32a51d1638cFE90E8eD1c4BdF42f729");
+    VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS = viem.getAddress("0x92557d38beAe4658d3c03A02F349FFB60c3bfFA5");
+    viem.getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f");
+    viem.getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff");
+    CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID = "continuum-dao-marketplace";
     viem.getAddress("0x76FF2CB03175900F1D83328C82D27EA9aeaF2355");
     viem.getAddress("0x4800F9f1dC1b6daCA841B71E0531F547D374168E");
     [
@@ -2747,7 +2756,20 @@ var MCP_NON_SUBMIT_TOOL_NAMES = /* @__PURE__ */ new Set([
   "ctm_uniswap_v4_limit_order_quote",
   "ctm_uniswap_v4_fetch_limit_orders",
   "ctm_uniswap_v4_check_permissions",
-  "ctm_uniswap_v4_kyc_apply_link"
+  "ctm_uniswap_v4_kyc_apply_link",
+  "search_prediction_markets",
+  "get_prediction_market",
+  "ctm_trueo_fetch_categories",
+  "ctm_trueo_fetch_trending",
+  "ctm_trueo_search_markets",
+  "ctm_trueo_fetch_market",
+  "ctm_trueo_fetch_chance_series",
+  "ctm_trueo_fetch_orderbook",
+  "ctm_hyperliquid_outcome_fetch_markets",
+  "ctm_hyperliquid_outcome_fetch_market",
+  "ctm_hyperliquid_outcome_fetch_orderbook",
+  "ctm_hyperliquid_outcome_fetch_positions",
+  "ctm_hyperliquid_outcome_fetch_open_orders"
 ]);
 
 // src/agent/schemas/protocols.ts
@@ -5288,6 +5310,213 @@ var mcpArcusBuildWithdrawMultisignInputSchema = withMultisignKeySourceRefine(
     product: arcusFundProductSchema
   })
 );
+var mcpTrueoFetchCategoriesInputSchema = zod.z.object({}).passthrough();
+var mcpTrueoFetchCategoriesOutputSchema = zod.z.object({
+  categories: zod.z.array(zod.z.object({ id: zod.z.number(), name: zod.z.string() })),
+  chainId: zod.z.number()
+});
+var mcpTrueoMarketRowSchema = zod.z.object({
+  address: zod.z.string(),
+  question: zod.z.string(),
+  rules: zod.z.string(),
+  source: zod.z.string(),
+  categories: zod.z.array(zod.z.string()),
+  size: zod.z.string(),
+  tvl: zod.z.number().nullable(),
+  yesTokenAddress: zod.z.string(),
+  noTokenAddress: zod.z.string(),
+  yesPoolAddress: zod.z.string(),
+  noPoolAddress: zod.z.string(),
+  paymentTokenAddress: zod.z.string(),
+  paymentTokenSymbol: zod.z.string(),
+  paymentTokenDecimals: zod.z.number(),
+  endOfTrading: zod.z.number(),
+  status: zod.z.number(),
+  outcome: zod.z.number().optional(),
+  statusUpdatedAt: zod.z.string().nullable().optional(),
+  imageUrl: zod.z.string().nullable(),
+  yesPoolTick: zod.z.number().nullable(),
+  noPoolTick: zod.z.number().nullable(),
+  yesPoolSqrtPriceX96: zod.z.string().nullable(),
+  noPoolSqrtPriceX96: zod.z.string().nullable(),
+  yesPrice: zod.z.number().nullable(),
+  noPrice: zod.z.number().nullable(),
+  yesPriceLabel: zod.z.string().nullable(),
+  noPriceLabel: zod.z.string().nullable(),
+  expiresAt: zod.z.string().nullable(),
+  expiresAtLabel: zod.z.string().nullable(),
+  chainId: zod.z.number(),
+  network: zod.z.string()
+});
+var mcpTrueoFetchTrendingInputSchema = zod.z.object({
+  limit: zod.z.number().int().positive().optional(),
+  includeAll: agentOptionalBooleanSchema().describe(
+    "If true, include older closed/resolved markets. Default: live and recently finished (14 days)."
+  )
+});
+var mcpTrueoFetchTrendingOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpTrueoMarketRowSchema),
+  notes: zod.z.string(),
+  hasMore: zod.z.boolean().optional(),
+  nextOffset: zod.z.number().int().nonnegative().optional()
+});
+var mcpTrueoSearchMarketsInputSchema = zod.z.object({
+  query: zod.z.string().optional().describe("Search haystack: question, rules, categories, address"),
+  category: zod.z.string().optional().describe("Category name from fetch_categories, e.g. Politics"),
+  limit: zod.z.number().int().positive().optional(),
+  offset: zod.z.number().int().nonnegative().optional(),
+  includeAll: agentOptionalBooleanSchema().describe(
+    "If true, include older closed/resolved markets. Default: live and recently finished (14 days)."
+  ),
+  excludeAddresses: zod.z.array(zod.z.string()).optional().describe("Skip these market addresses (after trending, pass the listed addresses).")
+});
+var mcpTrueoSearchMarketsOutputSchema = mcpTrueoFetchTrendingOutputSchema;
+var mcpTrueoFetchMarketInputSchema = zod.z.object({
+  marketAddress: evmAddressSchema.describe("Trueo market address")
+});
+var mcpTrueoFetchMarketOutputSchema = mcpTrueoMarketRowSchema;
+var mcpTrueoFetchChanceSeriesInputSchema = zod.z.object({
+  poolId: zod.z.string().min(1).describe("Yes or No pool id from fetch_market"),
+  from: zod.z.number().optional(),
+  to: zod.z.number().optional(),
+  resolution: zod.z.string().optional().describe("Sample step in seconds (3600 = hourly). 1H/1D/1W/All coerce to hourly \u2014 Trueo rejects calendar 1D/1W."),
+  lookbackDays: zod.z.number().optional()
+});
+var mcpTrueoFetchChanceSeriesOutputSchema = zod.z.object({
+  poolId: zod.z.string(),
+  bars: zod.z.array(
+    zod.z.object({
+      timestamp: zod.z.number(),
+      open: zod.z.number(),
+      high: zod.z.number(),
+      low: zod.z.number(),
+      close: zod.z.number()
+    })
+  ),
+  from: zod.z.number(),
+  to: zod.z.number(),
+  resolution: zod.z.string(),
+  notes: zod.z.string().optional()
+});
+var mcpTrueoFetchOrderbookInputSchema = zod.z.object({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]).optional(),
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpTrueoFetchOrderbookOutputSchema = zod.z.object({
+  marketAddress: zod.z.string(),
+  side: zod.z.enum(["yes", "no"]),
+  poolId: zod.z.string(),
+  currentTick: zod.z.number().nullable(),
+  impliedPrice: zod.z.number().nullable(),
+  impliedPriceLabel: zod.z.string().nullable(),
+  levels: zod.z.array(zod.z.record(zod.z.unknown())),
+  recentTrades: zod.z.array(zod.z.record(zod.z.unknown())),
+  notes: zod.z.string()
+});
+var mcpSearchPredictionMarketsInputSchema = zod.z.object({
+  query: zod.z.string().optional().describe(
+    "Pass the operator topic verbatim (case-insensitive title substring). Do not substitute a category name. Empty lists trending."
+  ),
+  category: zod.z.string().optional().describe("Venue category, e.g. Politics"),
+  venues: zod.z.array(zod.z.string()).optional().describe('Optional venue filter. Omit to search trueo and hyperliquid. Restrict with ["trueo"] or ["hyperliquid"].'),
+  trending: agentOptionalBooleanSchema().describe(
+    "Trending board only when query and category are empty. Ignored when query is set."
+  ),
+  includeAll: agentOptionalBooleanSchema().describe(
+    "If true, include older closed/resolved markets. Default: live and recently finished (14 days)."
+  ),
+  limit: zod.z.number().int().positive().optional().describe("Page size. Default 10 (trending API max)."),
+  offset: zod.z.number().int().nonnegative().optional().describe("Search offset for the next page. Trending is page 1 only."),
+  indexBase: zod.z.number().int().nonnegative().optional().describe("Start #N at indexBase+1 so pages continue 11, 12, \u2026"),
+  excludeAddresses: zod.z.array(zod.z.string()).optional().describe("Skip these venueMarketIds (after trending, pass the listed ids).")
+});
+var mcpPredictionMarketRowSchema = zod.z.object({
+  venue: zod.z.string(),
+  venueMarketId: zod.z.string(),
+  question: zod.z.string(),
+  categories: zod.z.array(zod.z.string()),
+  yesPrice: zod.z.number().nullable(),
+  noPrice: zod.z.number().nullable(),
+  yesPriceLabel: zod.z.string().nullable(),
+  noPriceLabel: zod.z.string().nullable(),
+  volume: zod.z.string(),
+  tvl: zod.z.number().nullable(),
+  expiresAt: zod.z.string().nullable(),
+  expiresAtLabel: zod.z.string().nullable(),
+  tradingEndsLabel: zod.z.string().optional(),
+  endOfTrading: zod.z.number().optional(),
+  status: zod.z.string(),
+  outcome: zod.z.number().optional(),
+  statusUpdatedAt: zod.z.string().nullable().optional(),
+  resolutionLabel: zod.z.string().nullable().optional(),
+  chainId: zod.z.number(),
+  paymentSymbol: zod.z.string(),
+  tradable: zod.z.boolean(),
+  index: zod.z.number().int().positive().optional(),
+  rules: zod.z.string().optional(),
+  source: zod.z.string().optional(),
+  imageUrl: zod.z.string().nullable().optional(),
+  ohlc: zod.z.array(
+    zod.z.object({
+      timestamp: zod.z.number(),
+      open: zod.z.number(),
+      high: zod.z.number(),
+      low: zod.z.number(),
+      close: zod.z.number()
+    })
+  ).optional().describe("Hourly Yes-chance samples for the Mini App graph (get_prediction_market).")
+});
+var mcpSearchPredictionMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpPredictionMarketRowSchema),
+  notes: zod.z.string(),
+  hasMore: zod.z.boolean().optional(),
+  nextOffset: zod.z.number().int().nonnegative().optional(),
+  nextIndexBase: zod.z.number().int().nonnegative().optional(),
+  includeAll: zod.z.boolean().optional()
+});
+var mcpListMyPredictionMarketsInputSchema = zod.z.object({
+  tokenAddresses: zod.z.array(zod.z.string()).optional().describe("YES/NO token addresses from get_token_registry (or added after a bet)."),
+  marketAddresses: zod.z.array(zod.z.string()).optional().describe("Trueo market addresses from prior bets.")
+});
+var mcpListMyPredictionMarketsOutputSchema = mcpSearchPredictionMarketsOutputSchema;
+var mcpGetPredictionMarketInputSchema = zod.z.object({
+  venue: zod.z.string().optional().describe("trueo (default) or hyperliquid"),
+  venueMarketId: zod.z.string().min(1).describe("Trueo market address, or Hyperliquid outcome id")
+});
+var mcpGetPredictionMarketOutputSchema = mcpPredictionMarketRowSchema.passthrough();
+var mcpTrueoWrapTydInputSchema = mcpMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("USDC amount to deposit into the TYD vault")
+});
+var mcpTrueoUnwrapTydInputSchema = mcpMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("TYD share amount to redeem for USDC")
+});
+var mcpTrueoMintInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  amountHuman: zod.z.string().min(1).describe("TYD (or USDC when paymentKind=usdc) amount"),
+  paymentKind: zod.z.enum(["tyd", "usdc"]).optional()
+});
+var mcpTrueoBurnInputSchema = mcpTrueoMintInputSchema;
+var mcpTrueoRedeemInputSchema = mcpTrueoMintInputSchema;
+var mcpTrueoSwapInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]),
+  amountHuman: zod.z.string().min(1).describe("TYD amount in"),
+  amountOutMinimumHuman: zod.z.string().optional()
+});
+var mcpTrueoCreateOrderInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]),
+  amountHuman: zod.z.string().min(1),
+  tickLower: zod.z.number().int(),
+  tickUpper: zod.z.number().int(),
+  enablePartialFill: agentOptionalBooleanSchema()
+});
+var mcpTrueoCancelOrderInputSchema = mcpMultisignInput({
+  marketAddress: evmAddressSchema,
+  side: zod.z.enum(["yes", "no"]),
+  orderId: zod.z.number().int().nonnegative()
+});
 function mcpDeriveMultisignInput(fields) {
   return withMultisignKeySourceRefine(evmMultisignCommonInputSchema.extend(fields));
 }
@@ -5651,6 +5880,131 @@ var mcpCctpBuildBurnMultisignInputSchema = mcpMultisignInput({
   minFinalityThreshold: agentCoercedOptionalIntSchema(zod.z.number().int().positive()),
   feeSnapshot: jsonObjectSchema.optional().describe("Optional output from ctm_cctp_fetch_burn_fees")
 });
+var outcomeIdSchema = zod.z.number().int().nonnegative();
+var sideSchema = zod.z.enum(["yes", "no"]);
+var mcpHyperliquidOutcomeFetchMarketsInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive().optional().describe("999 mainnet or 998 testnet. Default 999."),
+  query: zod.z.string().optional().describe("Case-insensitive substring of the question, description, or outcome id."),
+  limit: zod.z.number().int().positive().optional(),
+  offset: zod.z.number().int().nonnegative().optional()
+});
+var mcpHyperliquidOutcomeMarketSchema = zod.z.object({
+  outcome: zod.z.number(),
+  question: zod.z.string(),
+  description: zod.z.string(),
+  questionId: zod.z.number().nullable(),
+  sideNames: zod.z.tuple([zod.z.string(), zod.z.string()]),
+  quoteToken: zod.z.string(),
+  yesCoin: zod.z.string(),
+  noCoin: zod.z.string(),
+  yesAssetId: zod.z.number(),
+  noAssetId: zod.z.number(),
+  yesPrice: zod.z.number().nullable(),
+  noPrice: zod.z.number().nullable(),
+  yesPriceLabel: zod.z.string().nullable(),
+  noPriceLabel: zod.z.string().nullable(),
+  expiresAt: zod.z.string().nullable(),
+  endOfTrading: zod.z.number(),
+  status: zod.z.enum(["live", "closed"]),
+  tradable: zod.z.boolean(),
+  categories: zod.z.array(zod.z.string())
+});
+var mcpHyperliquidOutcomeFetchMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpHyperliquidOutcomeMarketSchema),
+  notes: zod.z.string(),
+  hasMore: zod.z.boolean(),
+  nextOffset: zod.z.number()
+});
+var mcpHyperliquidOutcomeFetchMarketInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive().optional(),
+  outcome: outcomeIdSchema.describe("outcome id from outcomeMeta / search venueMarketId")
+});
+var mcpHyperliquidOutcomeBookSchema = zod.z.object({
+  coin: zod.z.string(),
+  bids: zod.z.array(zod.z.object({ px: zod.z.string(), sz: zod.z.string(), n: zod.z.number() })),
+  asks: zod.z.array(zod.z.object({ px: zod.z.string(), sz: zod.z.string(), n: zod.z.number() }))
+});
+var mcpHyperliquidOutcomeFetchMarketOutputSchema = mcpHyperliquidOutcomeMarketSchema.extend({
+  yesBook: mcpHyperliquidOutcomeBookSchema,
+  noBook: mcpHyperliquidOutcomeBookSchema,
+  notes: zod.z.string()
+});
+var mcpHyperliquidOutcomeFetchOrderbookInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive().optional(),
+  outcome: outcomeIdSchema,
+  side: sideSchema.optional().describe("Default yes")
+});
+var mcpHyperliquidOutcomeFetchOrderbookOutputSchema = zod.z.object({
+  outcome: zod.z.number(),
+  side: sideSchema,
+  book: mcpHyperliquidOutcomeBookSchema,
+  notes: zod.z.string()
+});
+var mcpHyperliquidOutcomeFetchAccountInputSchema = zod.z.object({
+  chainId: zod.z.number().int().positive().optional(),
+  user: zod.z.string().min(1).describe("HyperCore account address (the MPA ethereum address).")
+});
+var mcpHyperliquidOutcomeFetchPositionsOutputSchema = zod.z.object({
+  quoteBalances: zod.z.array(zod.z.object({ coin: zod.z.string(), total: zod.z.string(), hold: zod.z.string() })),
+  outcomeBalances: zod.z.array(
+    zod.z.object({
+      coin: zod.z.string(),
+      total: zod.z.string(),
+      hold: zod.z.string(),
+      outcome: zod.z.number().nullable(),
+      side: zod.z.enum(["yes", "no"]).nullable()
+    })
+  ),
+  notes: zod.z.string()
+});
+var mcpHyperliquidOutcomeFetchOpenOrdersOutputSchema = zod.z.object({
+  openOrders: zod.z.array(
+    zod.z.object({
+      coin: zod.z.string(),
+      side: zod.z.string(),
+      limitPx: zod.z.string(),
+      sz: zod.z.string(),
+      oid: zod.z.number(),
+      timestamp: zod.z.number(),
+      outcome: zod.z.number().nullable(),
+      outcomeSide: zod.z.enum(["yes", "no"]).nullable()
+    })
+  ),
+  notes: zod.z.string()
+});
+var mcpHyperliquidOutcomeOrderInputSchema = mcpMultisignInput({
+  outcome: outcomeIdSchema,
+  side: sideSchema,
+  isBuy: zod.z.boolean().describe("true buys the side, false sells it"),
+  limitPxHuman: zod.z.string().min(1).describe("Limit price in quote per share, typically 0 to 1"),
+  szHuman: zod.z.string().min(1).describe("Share size"),
+  tif: zod.z.enum(["gtc", "ioc", "alo"]).optional().describe("Default gtc. ioc crosses the book."),
+  reduceOnly: agentOptionalBooleanSchema()
+});
+var mcpHyperliquidOutcomeCancelInputSchema = mcpMultisignInput({
+  outcome: outcomeIdSchema,
+  side: sideSchema,
+  oid: zod.z.number().int().positive()
+});
+var mcpHyperliquidOutcomeSplitInputSchema = mcpMultisignInput({
+  outcome: outcomeIdSchema,
+  amountHuman: zod.z.string().min(1).describe("Quote amount to split into equal Yes and No shares")
+});
+var mcpHyperliquidOutcomeMergeInputSchema = mcpMultisignInput({
+  outcome: outcomeIdSchema,
+  amountHuman: zod.z.string().optional().describe("Yes+No amount to merge. Omit or amountMax for the maximum."),
+  amountMax: agentOptionalBooleanSchema()
+});
+var mcpHyperliquidOutcomeMergeQuestionInputSchema = mcpMultisignInput({
+  question: outcomeIdSchema.describe("question id from outcomeMeta.questions"),
+  amountHuman: zod.z.string().optional(),
+  amountMax: agentOptionalBooleanSchema()
+});
+var mcpHyperliquidOutcomeNegateInputSchema = mcpMultisignInput({
+  question: outcomeIdSchema,
+  outcome: outcomeIdSchema,
+  amountHuman: zod.z.string().min(1)
+});
 
 // src/agent/mcpProtocolTools.ts
 function defineProtocolMcpTool(def) {
@@ -6955,6 +7309,510 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     ],
     handler: { importPath: "protocols/evm/derive", exportName: "buildDeriveTransferSpotMultisign" },
     inputZod: mcpDeriveTransferSpotInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_wrap_tyd_multisign",
+    actionId: "trueo.wrap-tyd",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Mint TYD by depositing Base USDC into the Yearn ERC-4626 vault. Not a market bet. No marketAddress. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "amountHuman (USDC)"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoWrapTyd" },
+    inputZod: mcpTrueoWrapTydInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_unwrap_tyd_multisign",
+    actionId: "trueo.unwrap-tyd",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Redeem TYD shares back to Base USDC via the Yearn ERC-4626 vault. Not a market bet. No marketAddress. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "amountHuman (TYD)"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoUnwrapTyd" },
+    inputZod: mcpTrueoUnwrapTydInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_mint_multisign",
+    actionId: "trueo.mint",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Mint YES+NO from TYD (default) or USDC via TruthMarketAdapter. Base 8453. Not a bet \u2014 allowed near market close. 30-minute multiSign expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress from ctm_trueo_fetch_market", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoMint" },
+    inputZod: mcpTrueoMintInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_burn_multisign",
+    actionId: "trueo.burn",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Burn equal YES+NO back to TYD (or USDC via adapter). Not a bet. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoBurn" },
+    inputZod: mcpTrueoBurnInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_redeem_multisign",
+    actionId: "trueo.redeem",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Redeem winning outcome tokens after resolution. Not a bet. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoRedeem" },
+    inputZod: mcpTrueoRedeemInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_swap_multisign",
+    actionId: "trueo.swap",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Buy Yes or No with TYD via UniversalRouterAdapter V4 swap. Refuses if the market closes within 5 minutes. extraJSON stores endOfTrading for Get Sig/Execute. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "side", "amountHuman"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoSwap" },
+    inputZod: mcpTrueoSwapInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_create_order_multisign",
+    actionId: "trueo.create-order",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Create an OrderManager limit order (Yes or No). Refuses if the market closes within 5 minutes. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "side", "amountHuman", "tickLower", "tickUpper"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoCreateOrder" },
+    inputZod: mcpTrueoCreateOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_trueo_build_cancel_order_multisign",
+    actionId: "trueo.cancel-order",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Cancel an OrderManager order. Not a bet \u2014 allowed after close. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 8453", "marketAddress", "side", "orderId"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "buildEvmMultisignBodyTrueoCancelOrder" },
+    inputZod: mcpTrueoCancelOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_outcome_build_order_multisign",
+    actionId: "hyperliquidOutcome.order",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Limit buy or sell a Hyperliquid HIP-4 outcome side. Asset id is 100000000 + 10*outcome + side (yes=0, no=1). EIP-712 Agent signature, no gas. IOC crosses the book. 30-minute expiry.",
+    prerequisites: ["keyGenId", "chainId 999", "outcome id", "side yes|no", "isBuy", "limitPxHuman", "szHuman", "purposeText"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "buildEvmMultisignBodyHyperliquidOutcomeOrder" },
+    inputZod: mcpHyperliquidOutcomeOrderInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_outcome_build_cancel_multisign",
+    actionId: "hyperliquidOutcome.cancel",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Cancel a resting Hyperliquid outcome order by oid. EIP-712, no gas.",
+    prerequisites: ["keyGenId", "chainId 999", "outcome", "side", "oid", "purposeText"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "buildEvmMultisignBodyHyperliquidOutcomeCancel" },
+    inputZod: mcpHyperliquidOutcomeCancelInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_outcome_build_split_multisign",
+    actionId: "hyperliquidOutcome.split",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Split quote tokens into equal Yes and No shares (userOutcome splitOutcome). EIP-712, no gas.",
+    prerequisites: ["keyGenId", "chainId 999", "outcome", "amountHuman", "purposeText"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "buildEvmMultisignBodyHyperliquidOutcomeSplit" },
+    inputZod: mcpHyperliquidOutcomeSplitInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_outcome_build_merge_multisign",
+    actionId: "hyperliquidOutcome.merge",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Merge Yes and No shares back into quote (userOutcome mergeOutcome). Omit amount or set amountMax to merge the maximum. EIP-712, no gas.",
+    prerequisites: ["keyGenId", "chainId 999", "outcome", "purposeText"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "buildEvmMultisignBodyHyperliquidOutcomeMerge" },
+    inputZod: mcpHyperliquidOutcomeMergeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_outcome_build_merge_question_multisign",
+    actionId: "hyperliquidOutcome.merge-question",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Merge Yes shares across one question into quote tokens. EIP-712, no gas.",
+    prerequisites: ["keyGenId", "chainId 999", "question id", "purposeText"],
+    handler: {
+      importPath: "protocols/evm/hyperliquidOutcome",
+      exportName: "buildEvmMultisignBodyHyperliquidOutcomeMergeQuestion"
+    },
+    inputZod: mcpHyperliquidOutcomeMergeQuestionInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_hyperliquid_outcome_build_negate_multisign",
+    actionId: "hyperliquidOutcome.negate",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Convert No shares of one outcome into Yes shares of the other outcomes in the question. EIP-712, no gas.",
+    prerequisites: ["keyGenId", "chainId 999", "question", "outcome", "amountHuman", "purposeText"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "buildEvmMultisignBodyHyperliquidOutcomeNegate" },
+    inputZod: mcpHyperliquidOutcomeNegateInputSchema
+  })
+];
+var catalogQuery = {
+  apiBase: zod.z.string().optional().describe("Override https://app-api.continuumdao.org"),
+  rpcUrl: zod.z.string().optional().describe("Linea RPC used when the marketplace API is offline"),
+  chainId: zod.z.number().int().optional().describe("59144"),
+  includeInactive: zod.z.boolean().optional().describe("Include closed sales, offers, and settled auctions"),
+  paymentToken: evmAddressSchema.optional(),
+  tokenId: zod.z.string().optional(),
+  creator: evmAddressSchema.optional(),
+  seller: evmAddressSchema.optional(),
+  viewer: evmAddressSchema.optional(),
+  limit: zod.z.number().int().optional(),
+  cursor: zod.z.string().optional().describe("nextCursor from the previous page")
+};
+var mcpContinuumDaoMarketplaceSearchInputSchema = zod.z.object({
+  apiBase: catalogQuery.apiBase,
+  rpcUrl: catalogQuery.rpcUrl,
+  chainId: catalogQuery.chainId,
+  kind: zod.z.enum(["listing", "auction", "both"]).optional().describe("Default listing. Use auction or both only when the user wants to bid."),
+  paymentToken: evmAddressSchema.optional().describe("Required when ranking by price and more than one payment token is listed"),
+  minLockedCtm: zod.z.string().optional().describe('Minimum locked CTM, human amount such as "1000"'),
+  maxLockedCtm: zod.z.string().optional().describe("Maximum locked CTM, human amount"),
+  unlockBefore: zod.z.string().optional().describe("ISO date or unix seconds"),
+  unlockAfter: zod.z.string().optional().describe("ISO date or unix seconds"),
+  maxUnlockMonths: zod.z.number().optional().describe("Still locked, and unlocks within this many 30-day months"),
+  sort: zod.z.enum(["pricePerLockedCtm", "price", "locked", "unlock", "deadline"]).optional().describe("Default pricePerLockedCtm, cheapest first. locked defaults to most CTM. unlock and deadline default to soonest."),
+  sortDirection: zod.z.enum(["asc", "desc"]).optional(),
+  limit: zod.z.number().int().min(1).max(25).optional().describe("Ranked rows to return, default 10"),
+  executor: evmAddressSchema.optional().describe("KeyGen address. veCTMs this address sells are omitted."),
+  excludeOwned: zod.z.boolean().optional()
+});
+var mcpContinuumDaoMarketplaceFeeAlternativeInputSchema = zod.z.object({
+  apiBase: catalogQuery.apiBase,
+  rpcUrl: zod.z.string().min(1).describe("Linea RPC. Required to read the monthly fee, threshold, and voting power."),
+  chainId: catalogQuery.chainId,
+  payment: zod.z.enum(["fee", "ctm"]).optional().describe("fee matches a USDC month. ctm matches a CTM month. Default fee."),
+  executor: evmAddressSchema.optional().describe("KeyGen address. veCTMs this address sells are omitted.")
+});
+var mcpContinuumDaoMarketplaceFetchListingsInputSchema = zod.z.object(catalogQuery);
+var mcpContinuumDaoMarketplaceFetchOfferingsInputSchema = zod.z.object(catalogQuery);
+var mcpContinuumDaoMarketplaceFetchAuctionsInputSchema = zod.z.object(catalogQuery);
+var mcpContinuumDaoMarketplaceFetchConfigInputSchema = zod.z.object({
+  apiBase: catalogQuery.apiBase,
+  rpcUrl: catalogQuery.rpcUrl,
+  chainId: catalogQuery.chainId
+});
+var mcpContinuumDaoMarketplaceFetchTokenInputSchema = zod.z.object({
+  apiBase: catalogQuery.apiBase,
+  rpcUrl: catalogQuery.rpcUrl,
+  chainId: catalogQuery.chainId,
+  tokenId: zod.z.string().min(1),
+  viewer: catalogQuery.viewer
+});
+var mcpContinuumDaoMarketplaceFetchActivityInputSchema = zod.z.object({
+  apiBase: catalogQuery.apiBase,
+  rpcUrl: catalogQuery.rpcUrl,
+  chainId: catalogQuery.chainId,
+  address: evmAddressSchema,
+  limit: catalogQuery.limit
+});
+var mcpContinuumDaoMarketplaceFetchFeePreviewInputSchema = zod.z.object({
+  apiBase: catalogQuery.apiBase,
+  rpcUrl: catalogQuery.rpcUrl,
+  chainId: catalogQuery.chainId,
+  tokenId: zod.z.string().min(1),
+  price: zod.z.string().min(1).describe("Price in payment-token wei")
+});
+var source = zod.z.enum(["api", "logs"]);
+var loose = zod.z.record(zod.z.unknown());
+var mcpContinuumDaoMarketplaceFeeAlternativeOutputSchema = zod.z.object({
+  payment: zod.z.enum(["fee", "ctm"]),
+  thresholdHuman: zod.z.string(),
+  monthlyFeeHuman: zod.z.string(),
+  monthlyFeeSymbol: zod.z.string(),
+  annualFeeHuman: zod.z.string(),
+  annualFeeCtmHuman: zod.z.string(),
+  example: loose.nullable(),
+  summary: zod.z.string(),
+  source
+}).passthrough();
+var mcpContinuumDaoMarketplaceSearchOutputSchema = zod.z.object({
+  sort: zod.z.string(),
+  sortDirection: zod.z.enum(["asc", "desc"]),
+  paymentToken: zod.z.string().nullable(),
+  scanned: zod.z.number(),
+  truncated: zod.z.boolean(),
+  items: zod.z.array(loose),
+  source
+}).passthrough();
+var mcpContinuumDaoMarketplaceListOutputSchema = zod.z.object({
+  items: zod.z.array(loose),
+  nextCursor: zod.z.string().nullable().optional(),
+  source
+}).passthrough();
+var mcpContinuumDaoMarketplaceConfigOutputSchema = zod.z.object({ source }).passthrough();
+var mcpContinuumDaoMarketplaceTokenOutputSchema = zod.z.object({ source }).passthrough();
+var mcpContinuumDaoMarketplaceActivityOutputSchema = zod.z.object({
+  address: zod.z.string(),
+  orders: zod.z.array(loose),
+  auctions: zod.z.array(loose),
+  source
+}).passthrough();
+var mcpContinuumDaoMarketplaceFeeOutputSchema = zod.z.object({ source }).passthrough();
+var wei = zod.z.union([zod.z.string(), zod.z.number()]);
+var deadline = zod.z.union([zod.z.string(), zod.z.number()]).describe("Unix seconds");
+var mcpContinuumDaoMarketplaceCreateListingInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  paymentToken: evmAddressSchema,
+  askWei: wei,
+  deadline
+});
+var mcpContinuumDaoMarketplaceDelistInputSchema = mcpMultisignInput({ tokenId: wei });
+var mcpContinuumDaoMarketplaceFulfillListingInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  seller: evmAddressSchema,
+  paymentToken: evmAddressSchema,
+  priceWei: wei
+});
+var mcpContinuumDaoMarketplaceCreateOfferingInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  paymentToken: evmAddressSchema,
+  bidWei: wei,
+  deadline
+});
+var mcpContinuumDaoMarketplaceRescindInputSchema = mcpMultisignInput({ tokenId: wei });
+var mcpContinuumDaoMarketplaceFulfillOfferingInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  buyer: evmAddressSchema,
+  paymentToken: evmAddressSchema,
+  priceWei: wei
+});
+var mcpContinuumDaoMarketplaceCreateAuctionInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  paymentToken: evmAddressSchema,
+  deadline,
+  reserveWei: wei,
+  minIncrementWei: wei
+});
+var mcpContinuumDaoMarketplaceCancelAuctionInputSchema = mcpMultisignInput({ tokenId: wei });
+var mcpContinuumDaoMarketplaceAuctionBidInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  seller: evmAddressSchema,
+  priceWei: wei
+});
+var mcpContinuumDaoMarketplaceSettleAuctionInputSchema = mcpMultisignInput({
+  tokenId: wei,
+  seller: evmAddressSchema
+});
+
+// src/agent/mcpMarketplaceTools.ts
+var PROTOCOL = "continuum-dao-marketplace";
+var IMPORT_PATH = "protocols/evm/continuum-dao";
+function defineRead(def) {
+  return {
+    name: def.name,
+    actionId: def.actionId,
+    protocolId: PROTOCOL,
+    chainCategory: "evm",
+    description: def.description,
+    prerequisites: def.prerequisites,
+    followUp: def.followUp,
+    handler: { importPath: IMPORT_PATH, exportName: def.exportName },
+    inputZod: def.inputZod,
+    outputZod: def.outputZod,
+    inputSchema: zodSchemaToMcpJsonSchema(def.inputZod),
+    outputSchema: zodSchemaToMcpJsonSchema(def.outputZod),
+    parseInput: (data) => def.inputZod.parse(data),
+    parseOutput: (data) => def.outputZod.parse(data)
+  };
+}
+function defineWrite(def) {
+  const meta = withMultisignSubmitMcpMeta(def.description, MCP_MULTISIGN_SUBMIT_FOLLOW_UP);
+  const handler = { importPath: IMPORT_PATH, exportName: def.exportName };
+  return {
+    name: def.name,
+    actionId: def.actionId,
+    protocolId: PROTOCOL,
+    chainCategory: "evm",
+    description: meta.description,
+    prerequisites: def.prerequisites,
+    followUp: meta.followUp,
+    handler,
+    inputZod: def.inputZod,
+    outputZod: mcpServerSubmitOutputSchema,
+    inputSchema: agentFacingMultisignJsonSchema(def.inputZod),
+    outputSchema: zodSchemaToMcpJsonSchema(mcpServerSubmitOutputSchema),
+    parseInput: (data) => def.inputZod.parse(data),
+    parseOutput: (data) => mcpServerSubmitOutputSchema.parse(data)
+  };
+}
+var MCP_MARKETPLACE_TOOL_DEFINITIONS = [
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_config",
+    actionId: "continuum-dao-marketplace.fetch-config",
+    description: "Marketplace config: payment tokens, WETH, duration bounds, fee tiers. Falls back to the Linea contract when the API is down.",
+    prerequisites: ["chainId 59144", "rpcUrl when the API may be offline"],
+    followUp: ["ctm_continuum_dao_marketplace_search", "ctm_continuum_dao_marketplace_fetch_listings", "ctm_continuum_dao_marketplace_fetch_auctions"],
+    inputZod: mcpContinuumDaoMarketplaceFetchConfigInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceConfigOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceConfig"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fee_alternative",
+    actionId: "continuum-dao-marketplace.fee-alternative",
+    description: "Alternative to paying a KeyGen month in the fee token or CTM. Returns the live monthly fee, 12 times that fee, the veCTM threshold, and one direct listing whose locked CTM and voting power are both above the threshold. Auctions are excluded. Relay the summary, then continue the paid month. Buy the listing only if the user chooses it. Skip this when the month is already waived.",
+    prerequisites: ["rpcUrl", "payment fee or ctm"],
+    followUp: ["ctm_continuum_dao_marketplace_build_fulfill_listing_multisign"],
+    inputZod: mcpContinuumDaoMarketplaceFeeAlternativeInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceFeeAlternativeOutputSchema,
+    exportName: "quoteContinuumDaoMarketplaceFeeAlternative"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_search",
+    actionId: "continuum-dao-marketplace.search",
+    description: "Rank veCTMs for sale. Returns a short list already sorted by price per locked CTM, price, locked CTM, unlock, or deadline. Filters: min/max locked CTM, unlock window, maxUnlockMonths. Pass paymentToken to compare prices. Pass executor to drop veCTMs this KeyGen sells. Use this to choose a buy. Do not fetch the raw listing page and then offer to sort it.",
+    prerequisites: ["chainId 59144", "rpcUrl when lock snapshots are missing"],
+    followUp: ["ctm_continuum_dao_marketplace_build_fulfill_listing_multisign", "ctm_continuum_dao_marketplace_build_auction_bid_multisign"],
+    inputZod: mcpContinuumDaoMarketplaceSearchInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceSearchOutputSchema,
+    exportName: "searchContinuumDaoMarketplace"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_listings",
+    actionId: "continuum-dao-marketplace.fetch-listings",
+    description: "Unfiltered page of open veCTM listings, created order, up to 100, with nextCursor. includeInactive adds past sales. To choose a buy by price, locked CTM, or unlock time, use search instead.",
+    prerequisites: ["chainId 59144"],
+    followUp: ["ctm_continuum_dao_marketplace_build_fulfill_listing_multisign"],
+    inputZod: mcpContinuumDaoMarketplaceFetchListingsInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceListOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceListings"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_offerings",
+    actionId: "continuum-dao-marketplace.fetch-offerings",
+    description: "Open veCTM offerings. includeInactive adds fulfilled and rescinded rows. API first, then marketplace logs.",
+    prerequisites: ["chainId 59144"],
+    followUp: ["ctm_continuum_dao_marketplace_build_fulfill_offering_multisign"],
+    inputZod: mcpContinuumDaoMarketplaceFetchOfferingsInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceListOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceOfferings"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_auctions",
+    actionId: "continuum-dao-marketplace.fetch-auctions",
+    description: "Live veCTM auctions (Pending, Active, Complete). includeInactive adds sold, canceled, and expired. Each auction includes bids.",
+    prerequisites: ["chainId 59144"],
+    followUp: ["ctm_continuum_dao_marketplace_build_auction_bid_multisign", "ctm_continuum_dao_marketplace_build_settle_auction_multisign"],
+    inputZod: mcpContinuumDaoMarketplaceFetchAuctionsInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceListOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceAuctions"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_token",
+    actionId: "continuum-dao-marketplace.fetch-token",
+    description: "One veCTM: live listing, offerings, and auction, plus history of closed sales and auctions with bids.",
+    prerequisites: ["tokenId"],
+    followUp: ["ctm_continuum_dao_marketplace_fetch_auctions"],
+    inputZod: mcpContinuumDaoMarketplaceFetchTokenInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceTokenOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceToken"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_activity",
+    actionId: "continuum-dao-marketplace.fetch-activity",
+    description: "One address\u2019s marketplace orders and auctions, including past sales and bids.",
+    prerequisites: ["address"],
+    followUp: ["ctm_continuum_dao_marketplace_fetch_token"],
+    inputZod: mcpContinuumDaoMarketplaceFetchActivityInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceActivityOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceActivity"
+  }),
+  defineRead({
+    name: "ctm_continuum_dao_marketplace_fetch_fee_preview",
+    actionId: "continuum-dao-marketplace.fetch-fee-preview",
+    description: "Protocol fee for a veCTM price. Uses the API, then on-chain fee tiers.",
+    prerequisites: ["tokenId", "price wei"],
+    followUp: ["ctm_continuum_dao_marketplace_build_create_listing_multisign"],
+    inputZod: mcpContinuumDaoMarketplaceFetchFeePreviewInputSchema,
+    outputZod: mcpContinuumDaoMarketplaceFeeOutputSchema,
+    exportName: "fetchContinuumDaoMarketplaceFeePreview"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_create_listing_multisign",
+    actionId: "continuum-dao-marketplace.create-listing",
+    description: "List a veCTM. Approves the marketplace for the token id when needed. Linea only.",
+    prerequisites: ["keyGen", "tokenId owned by the KeyGen", "askWei", "deadline"],
+    inputZod: mcpContinuumDaoMarketplaceCreateListingInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceCreateListing"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_delist_multisign",
+    actionId: "continuum-dao-marketplace.delist",
+    description: "Delist this KeyGen\u2019s open veCTM listing.",
+    prerequisites: ["keyGen", "tokenId"],
+    inputZod: mcpContinuumDaoMarketplaceDelistInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceDelist"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_fulfill_listing_multisign",
+    actionId: "continuum-dao-marketplace.fulfill-listing",
+    description: "Buy a listed veCTM. Refuses when this KeyGen already owns it or is the seller. WETH sends msg.value.",
+    prerequisites: ["keyGen", "tokenId", "seller", "priceWei"],
+    inputZod: mcpContinuumDaoMarketplaceFulfillListingInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceFulfillListing"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_create_offering_multisign",
+    actionId: "continuum-dao-marketplace.create-offering",
+    description: "Offer on a veCTM this KeyGen does not own. WETH sends msg.value and still approves WETH for later fulfillment.",
+    prerequisites: ["keyGen", "tokenId", "bidWei", "deadline"],
+    inputZod: mcpContinuumDaoMarketplaceCreateOfferingInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceCreateOffering"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_rescind_multisign",
+    actionId: "continuum-dao-marketplace.rescind",
+    description: "Rescind this KeyGen\u2019s open offering.",
+    prerequisites: ["keyGen", "tokenId"],
+    inputZod: mcpContinuumDaoMarketplaceRescindInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceRescind"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_fulfill_offering_multisign",
+    actionId: "continuum-dao-marketplace.fulfill-offering",
+    description: "Accept an offering on a veCTM this KeyGen owns. Refuses an attached KeyGen.",
+    prerequisites: ["keyGen", "tokenId", "buyer", "priceWei"],
+    inputZod: mcpContinuumDaoMarketplaceFulfillOfferingInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceFulfillOffering"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_create_auction_multisign",
+    actionId: "continuum-dao-marketplace.create-auction",
+    description: "Start an auction and escrow the veCTM. Refuses an attached KeyGen.",
+    prerequisites: ["keyGen", "tokenId", "reserveWei", "minIncrementWei", "deadline"],
+    inputZod: mcpContinuumDaoMarketplaceCreateAuctionInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceCreateAuction"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_cancel_auction_multisign",
+    actionId: "continuum-dao-marketplace.cancel-auction",
+    description: "Cancel a pending auction that has no bids. The veCTM returns to the seller.",
+    prerequisites: ["keyGen", "tokenId"],
+    inputZod: mcpContinuumDaoMarketplaceCancelAuctionInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceCancelAuction"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_auction_bid_multisign",
+    actionId: "continuum-dao-marketplace.auction-bid",
+    description: "Bid on a live auction. Refuses when this KeyGen is the seller or already owns the veCTM.",
+    prerequisites: ["keyGen", "tokenId", "seller", "priceWei"],
+    inputZod: mcpContinuumDaoMarketplaceAuctionBidInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceAuctionBid"
+  }),
+  defineWrite({
+    name: "ctm_continuum_dao_marketplace_build_settle_auction_multisign",
+    actionId: "continuum-dao-marketplace.settle-auction",
+    description: "Settle a completed or expired auction. A completed auction transfers the veCTM to the highest bidder.",
+    prerequisites: ["keyGen", "tokenId", "seller"],
+    inputZod: mcpContinuumDaoMarketplaceSettleAuctionInputSchema,
+    exportName: "buildEvmMultisignBodyContinuumDaoMarketplaceSettleAuction"
   })
 ];
 
@@ -9408,11 +10266,203 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/derive", exportName: "deriveFetchOpenOrdersSummary" },
     inputZod: mcpDeriveFetchOpenOrdersInputSchema,
     outputZod: mcpDeriveFetchOpenOrdersOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_outcome_fetch_markets",
+    actionId: "hyperliquidOutcome.fetch-markets",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Live Hyperliquid HIP-4 outcome markets from outcomeMeta, with Yes/No mids. Optional query substring. Chain 999.",
+    prerequisites: ["load_defi_protocol hyperliquidOutcome"],
+    followUp: ["ctm_hyperliquid_outcome_fetch_market", "ctm_hyperliquid_outcome_build_order_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "hyperliquidOutcomeFetchMarketsSummary" },
+    inputZod: mcpHyperliquidOutcomeFetchMarketsInputSchema,
+    outputZod: mcpHyperliquidOutcomeFetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_outcome_fetch_market",
+    actionId: "hyperliquidOutcome.fetch-market",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "One Hyperliquid outcome market plus both Yes and No order books.",
+    prerequisites: ["load_defi_protocol hyperliquidOutcome", "outcome id"],
+    followUp: ["ctm_hyperliquid_outcome_build_order_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "hyperliquidOutcomeFetchMarketSummary" },
+    inputZod: mcpHyperliquidOutcomeFetchMarketInputSchema,
+    outputZod: mcpHyperliquidOutcomeFetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_outcome_fetch_orderbook",
+    actionId: "hyperliquidOutcome.fetch-orderbook",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "l2Book for one Hyperliquid outcome side (default yes).",
+    prerequisites: ["load_defi_protocol hyperliquidOutcome", "outcome id"],
+    followUp: ["ctm_hyperliquid_outcome_build_order_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "hyperliquidOutcomeFetchOrderbookSummary" },
+    inputZod: mcpHyperliquidOutcomeFetchOrderbookInputSchema,
+    outputZod: mcpHyperliquidOutcomeFetchOrderbookOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_outcome_fetch_positions",
+    actionId: "hyperliquidOutcome.fetch-positions",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Quote balances and HIP-4 share balances (+encoding) for a HyperCore address. Not ERC20s \u2014 do not add_to_token_registry.",
+    prerequisites: ["load_defi_protocol hyperliquidOutcome", "user address"],
+    followUp: ["ctm_hyperliquid_outcome_build_merge_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "hyperliquidOutcomeFetchPositionsSummary" },
+    inputZod: mcpHyperliquidOutcomeFetchAccountInputSchema,
+    outputZod: mcpHyperliquidOutcomeFetchPositionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_hyperliquid_outcome_fetch_open_orders",
+    actionId: "hyperliquidOutcome.fetch-open-orders",
+    protocolId: "hyperliquidOutcome",
+    chainCategory: "evm",
+    description: "Open Hyperliquid outcome orders (#encoding coins) for a user.",
+    prerequisites: ["load_defi_protocol hyperliquidOutcome", "user address"],
+    followUp: ["ctm_hyperliquid_outcome_build_cancel_multisign"],
+    handler: { importPath: "protocols/evm/hyperliquidOutcome", exportName: "hyperliquidOutcomeFetchOpenOrdersSummary" },
+    inputZod: mcpHyperliquidOutcomeFetchAccountInputSchema,
+    outputZod: mcpHyperliquidOutcomeFetchOpenOrdersOutputSchema
+  }),
+  defineMcpTool({
+    name: "search_prediction_markets",
+    actionId: "prediction-markets.search",
+    protocolId: "prediction-markets",
+    chainCategory: "evm",
+    description: 'Venue-agnostic prediction market search (Trueo on Base and Hyperliquid outcome markets). Pass the operator topic verbatim as query. Omit venues to search both. Restrict with venues ["trueo"] or ["hyperliquid"]. Do not set trending when query is set. If hasMore, page Trueo with offset/nextOffset. Hyperliquid matches are included on the first page. After a pick, get_prediction_market (venue from the row). Trueo writes: load_defi_protocol trueo. Hyperliquid bets: load_defi_protocol hyperliquidOutcome.',
+    prerequisites: [],
+    followUp: ["get_prediction_market", "load_defi_protocol", "get_defi_protocol_skill"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "searchPredictionMarketsSummary" },
+    inputZod: mcpSearchPredictionMarketsInputSchema,
+    outputZod: mcpSearchPredictionMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "get_prediction_market",
+    actionId: "prediction-markets.get",
+    protocolId: "prediction-markets",
+    chainCategory: "evm",
+    description: "Full selected prediction market. venue defaults to trueo (market address). For Hyperliquid pass venue hyperliquid and venueMarketId = outcome id. Does not require load_defi_protocol. Trueo writes stay behind load_defi_protocol trueo. Hyperliquid bets stay behind load_defi_protocol hyperliquidOutcome (ctm_hyperliquid_outcome_build_order_multisign). Yes/No Hyperliquid shares are not ERC20s \u2014 do not add_to_token_registry.",
+    prerequisites: ["venueMarketId from search_prediction_markets"],
+    followUp: [
+      "load_defi_protocol",
+      "get_defi_protocol_skill",
+      "ctm_trueo_build_wrap_tyd_multisign",
+      "ctm_trueo_build_mint_multisign",
+      "ctm_trueo_build_create_order_multisign",
+      "ctm_trueo_build_swap_multisign",
+      "ctm_trueo_build_burn_multisign",
+      "ctm_trueo_build_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/trueo", exportName: "getPredictionMarketSummary" },
+    inputZod: mcpGetPredictionMarketInputSchema,
+    outputZod: mcpGetPredictionMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "list_my_prediction_markets",
+    actionId: "prediction-markets.my-holdings",
+    protocolId: "prediction-markets",
+    chainCategory: "evm",
+    description: "Live Yes/No, trading window, and resolution for markets the user has bet on. Pass YES/NO tokenAddresses from get_token_registry and/or marketAddresses from prior bets. Does not require load_defi_protocol. After a bet, add_to_token_registry for the YES or NO token so it shows here. Exit: load_defi_protocol trueo then ctm_trueo_build_burn_multisign or ctm_trueo_build_redeem_multisign.",
+    prerequisites: [],
+    followUp: [
+      "get_prediction_market",
+      "add_to_token_registry",
+      "load_defi_protocol",
+      "ctm_trueo_build_burn_multisign",
+      "ctm_trueo_build_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/trueo", exportName: "listMyPredictionMarketsSummary" },
+    inputZod: mcpListMyPredictionMarketsInputSchema,
+    outputZod: mcpListMyPredictionMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_categories",
+    actionId: "trueo.fetch-categories",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Trueo category chips (Politics, Crypto, Sports, \u2026). Use as category on search.",
+    prerequisites: ["load_defi_protocol trueo"],
+    followUp: ["ctm_trueo_search_markets", "ctm_trueo_fetch_trending"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchCategoriesSummary" },
+    inputZod: mcpTrueoFetchCategoriesInputSchema,
+    outputZod: mcpTrueoFetchCategoriesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_trending",
+    actionId: "trueo.fetch-trending",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Trueo trending on Base (max 10; API does not page). More markets: ctm_trueo_search_markets with offset=0. Default: live and recently finished (14 days).",
+    prerequisites: ["load_defi_protocol trueo"],
+    followUp: ["ctm_trueo_fetch_market"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchTrendingSummary" },
+    inputZod: mcpTrueoFetchTrendingInputSchema,
+    outputZod: mcpTrueoFetchTrendingOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_search_markets",
+    actionId: "trueo.search-markets",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Trueo-only search (query + category), pages of 10. Same rows as search_prediction_markets. If hasMore, pass nextOffset and excludeAddresses of listed addresses. Default: live and recently finished (14 days).",
+    prerequisites: ["load_defi_protocol trueo"],
+    followUp: ["ctm_trueo_fetch_market"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoSearchMarketsSummary" },
+    inputZod: mcpTrueoSearchMarketsInputSchema,
+    outputZod: mcpTrueoSearchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_market",
+    actionId: "trueo.fetch-market",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Selected Trueo market: rules, source, Yes/No %, TVL, size, tokens, pools, endOfTrading. Copy address for build_*. Writes: ctm_trueo_build_mint_multisign, ctm_trueo_build_create_order_multisign, ctm_trueo_build_swap_multisign, ctm_trueo_build_burn_multisign, ctm_trueo_build_redeem_multisign (after load_defi_protocol trueo).",
+    prerequisites: ["marketAddress from search or trending"],
+    followUp: [
+      "ctm_trueo_fetch_chance_series",
+      "ctm_trueo_fetch_orderbook",
+      "ctm_trueo_build_mint_multisign",
+      "ctm_trueo_build_create_order_multisign",
+      "ctm_trueo_build_swap_multisign",
+      "ctm_trueo_build_burn_multisign",
+      "ctm_trueo_build_redeem_multisign"
+    ],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchMarketSummary" },
+    inputZod: mcpTrueoFetchMarketInputSchema,
+    outputZod: mcpTrueoFetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_chance_series",
+    actionId: "trueo.fetch-chance-series",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Yes/No chance samples for a pool id from fetch_market. Not candlesticks. Default hourly (3600s) over 14 days. 1H/1D/1W/All coerce to hourly.",
+    prerequisites: ["poolId from ctm_trueo_fetch_market"],
+    followUp: ["ctm_trueo_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchChanceSeriesSummary" },
+    inputZod: mcpTrueoFetchChanceSeriesInputSchema,
+    outputZod: mcpTrueoFetchChanceSeriesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_trueo_fetch_orderbook",
+    actionId: "trueo.fetch-orderbook",
+    protocolId: "trueo",
+    chainCategory: "evm",
+    description: "Yes/No depth: live tick, implied price, OrderManager pending rows when rpcUrl is set, recent trades.",
+    prerequisites: ["marketAddress from ctm_trueo_fetch_market"],
+    followUp: ["ctm_trueo_build_swap_multisign", "ctm_trueo_build_create_order_multisign"],
+    handler: { importPath: "protocols/evm/trueo", exportName: "trueoFetchOrderbookSummary" },
+    inputZod: mcpTrueoFetchOrderbookInputSchema,
+    outputZod: mcpTrueoFetchOrderbookOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
   ...CORE_MCP_TOOL_DEFINITIONS,
-  ...MCP_PROTOCOL_TOOL_DEFINITIONS
+  ...MCP_PROTOCOL_TOOL_DEFINITIONS,
+  ...MCP_MARKETPLACE_TOOL_DEFINITIONS
 ];
 function buildToolSchemaMap(kind) {
   const out = {};
@@ -11233,12 +12283,52 @@ registerProtocolModule(aerodromeProtocolModule);
 
 // src/protocols/evm/continuum-dao/index.ts
 init_constants2();
+
+// src/protocols/evm/continuum-dao/marketplaceModule.ts
+init_constants2();
+var common = ["keyGen", "purposeText", "useCustomGas"];
+var continuumDaoMarketplaceProtocolModule = {
+  id: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    return n === CONTINUUM_DAO_LINEA_CHAIN_ID;
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "erc20" || token.kind === "erc721");
+  },
+  actions: [
+    { id: "continuum-dao-marketplace.fetch-config", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Marketplace payment tokens, durations, and fees", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.search", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Rank veCTMs for sale by price, locked CTM, or unlock time", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.fee-alternative", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "One qualifying direct listing beside 12 times the KeyGen monthly fee", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.fetch-listings", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Open listings, or past sales when includeInactive is set", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.fetch-offerings", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Open offerings, or closed offers when includeInactive is set", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.fetch-auctions", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Live auctions, or settled auctions when includeInactive is set. Each row includes bids.", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.fetch-token", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "One veCTM: live orders plus history of sales and auctions", commonParams: [], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.fetch-activity", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "An address\u2019s sales, buys, and auctions including bids", commonParams: [], params: { address: { type: "string", required: true, description: "KeyGen or wallet" } } },
+    { id: "continuum-dao-marketplace.fetch-fee-preview", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Protocol fee for a price and veCTM", commonParams: [], params: {} },
+    { id: "continuum-dao-marketplace.create-listing", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Approve veCTM if needed and create a listing", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, askWei: { type: "string", required: true, description: "Ask in payment-token wei" } } },
+    { id: "continuum-dao-marketplace.delist", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Delist an open listing", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.fulfill-listing", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Buy a listed veCTM", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.create-offering", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Make an offering on a veCTM", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.rescind", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Rescind an open offering", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.fulfill-offering", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Accept an offering on a veCTM you own", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.create-auction", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Escrow a veCTM into an auction", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.cancel-auction", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Cancel a pending auction with no bids", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.auction-bid", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Bid on a live auction", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao-marketplace.settle-auction", protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, chainCategory: "evm", description: "Settle a completed or expired auction", commonParams: [...common], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } }
+  ]
+};
+
+// src/protocols/evm/continuum-dao/index.ts
 init_constants2();
 init_governance();
 init_simulateProposal();
 init_foundryProposalScript();
 init_explainProposal();
 init_forum();
+registerProtocolModule(continuumDaoMarketplaceProtocolModule);
 var continuumDaoProtocolModule = {
   id: CONTINUUM_DAO_PROTOCOL_ID,
   chainCategory: "evm",
@@ -12616,6 +13706,169 @@ var deriveProtocolModule = {
   ]
 };
 registerProtocolModule(deriveProtocolModule);
+var TRUEO_PROTOCOL_ID = "trueo";
+var TRUEO_BASE_CHAIN_ID = 8453;
+var TRUEO_CHAIN_IDS = [TRUEO_BASE_CHAIN_ID];
+var TRUEO_TYD = viem.getAddress("0xb13CF163d916917d9cD6E836905cA5f12a1dEF4B");
+var TRUEO_TRUE = viem.getAddress("0x21CFCFc3d8F98fC728f48341D10Ad8283F6EB7AB");
+var TRUEO_USDC = viem.getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
+viem.getAddress("0x61A98Bef11867c69489B91f340fE545eEfc695d7");
+viem.getAddress("0x1cdB1C43eB64e99780EA9d3C7162C23432C59a1A");
+viem.getAddress("0x0A1AFc2121B4441127a02DEF72928F61f564034a");
+viem.getAddress("0x6E08d24AEf78F6d1a97503F64E84fDF65f8125E1");
+viem.getAddress("0x3E83479B2276EcFb7C7181F67b5d092d3511e0C4");
+viem.getAddress("0x000000000022D473030F116dDEE9F6B43aC78BA3");
+function isTrueoChainSupported(chainId) {
+  return TRUEO_CHAIN_IDS.includes(chainId);
+}
+
+// src/protocols/evm/hyperliquidOutcome/api.ts
+var HYPERLIQUID_OUTCOME_PROTOCOL_ID = "hyperliquidOutcome";
+
+// src/protocols/evm/trueo/index.ts
+var trueoProtocolModule = {
+  id: TRUEO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    const id = typeof ctx.chainId === "string" ? Number(ctx.chainId) : ctx.chainId;
+    return ctx.chainCategory === "evm" && isTrueoChainSupported(id);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "erc20" || token.kind === "ctmerc20");
+  },
+  actions: [
+    {
+      id: "trueo.wrap-tyd",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint TYD by depositing Base USDC into the Yearn ERC-4626 vault",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.unwrap-tyd",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Redeem TYD shares back to Base USDC",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.mint",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint YES+NO from TYD (or USDC via adapter)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.burn",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Burn equal YES+NO back to TYD",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.redeem",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Redeem winning outcome tokens after resolution",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.swap",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Buy Yes or No with TYD via UniversalRouterAdapter V4 swap",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.create-order",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Create an on-chain OrderManager limit order",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "trueo.cancel-order",
+      protocolId: TRUEO_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel an on-chain OrderManager order",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(trueoProtocolModule);
+
+// src/protocols/evm/hyperliquidOutcome/index.ts
+var hyperliquidOutcomeProtocolModule = {
+  id: HYPERLIQUID_OUTCOME_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) && isHyperliquidChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "native";
+  },
+  actions: [
+    {
+      id: "hyperliquidOutcome.order",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Limit buy or sell a HIP-4 outcome side via Hyperliquid /exchange",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.cancel",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel a resting HIP-4 outcome order",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.split",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Split quote tokens into Yes and No shares",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.merge",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Merge Yes and No shares back into quote tokens",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.merge-question",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Merge Yes shares across a question into quote tokens",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.negate",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Convert No shares of one outcome into Yes shares of the other outcomes",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(hyperliquidOutcomeProtocolModule);
 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",
@@ -12634,8 +13887,11 @@ var SKILL_PROTOCOL_IDS = [
   "aerodrome",
   "pendle",
   "continuum-dao",
+  "continuum-dao-marketplace",
   "compound-v3",
   "derive",
+  "trueo",
+  "hyperliquidOutcome",
   "yield-compare"
 ];
 function getToolsForProtocol(protocolId) {
@@ -13004,6 +14260,17 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       }
     }
   }),
+  hyperliquidOutcome: advisor("hyperliquidOutcome", "api_underlyings", {
+    async supportedChainIds() {
+      return [...HYPERLIQUID_SUPPORTED_CHAIN_IDS];
+    },
+    async supportedTokens() {
+      return {
+        tokens: [],
+        notes: 'HIP-4 outcome markets on HyperCore (chainId 999). Yes/No shares are exchange balances, not ERC20s. Search with search_prediction_markets venues ["hyperliquid"].'
+      };
+    }
+  }),
   hyperliquid: advisor("hyperliquid", "api_underlyings", {
     async supportedChainIds() {
       return [...HYPERLIQUID_SUPPORTED_CHAIN_IDS];
@@ -13068,6 +14335,22 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       };
     }
   }),
+  [CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID]: advisor(CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, "fixed_addresses", {
+    async supportedChainIds() {
+      return [59144];
+    },
+    async supportedTokens(chainId) {
+      const ve = votingEscrowAddressOnEvmChain(chainId);
+      const market = votingEscrowMarketplaceAddressOnEvmChain(chainId);
+      const tokens = [];
+      if (ve) tokens.push({ address: ve, symbol: "veCTM", roles: ["position_nft"] });
+      if (market) tokens.push({ address: market, symbol: "veCTM-market", roles: ["protocol"] });
+      return {
+        tokens,
+        notes: "Linea veCTM marketplace. Load continuum-dao-marketplace, not continuum-dao. Search ranks buys by locked CTM, unlock time, or price per CTM and returns a short list. fetch_listings is the unfiltered page. fetch_auctions is the live book; includeInactive adds settled auctions and each row includes bids. Do not buy or bid a veCTM this KeyGen already owns."
+      };
+    }
+  }),
   [COMPOUND_V3_PROTOCOL_ID]: advisor(COMPOUND_V3_PROTOCOL_ID, "api_underlyings", {
     async supportedChainIds() {
       return listCompoundV3SupportedChainIds();
@@ -13214,6 +14497,33 @@ var PROTOCOL_SUPPORT_ADVISORS = {
         return false;
       }
     }
+  }),
+  [TRUEO_PROTOCOL_ID]: advisor(TRUEO_PROTOCOL_ID, "fixed_addresses", {
+    async supportedChainIds() {
+      return [TRUEO_BASE_CHAIN_ID];
+    },
+    async supportedTokens(chainId) {
+      if (chainId !== TRUEO_BASE_CHAIN_ID) {
+        return { tokens: [], notes: "Trueo is Base-only (chainId 8453)." };
+      }
+      return {
+        tokens: [
+          { address: TRUEO_TYD, symbol: "TYD", decimals: 6, roles: ["payment"] },
+          { address: TRUEO_TRUE, symbol: "TRUE", decimals: 18, roles: ["governance"] },
+          { address: TRUEO_USDC, symbol: "USDC", decimals: 6, roles: ["adapter_asset"] }
+        ],
+        notes: "Trueo prediction markets on Base. Payment is TYD. Outcome YES/NO tokens are per-market \u2014 use ctm_trueo_search_markets / fetch_market. Chat search: search_prediction_markets (no load required; default live/recent, includeAll for closed)."
+      };
+    },
+    async isTokenSupported(chainId, address) {
+      if (chainId !== TRUEO_BASE_CHAIN_ID) return false;
+      try {
+        const n = viem.getAddress(address).toLowerCase();
+        return n === TRUEO_TYD.toLowerCase() || n === TRUEO_TRUE.toLowerCase() || n === TRUEO_USDC.toLowerCase();
+      } catch {
+        return false;
+      }
+    }
   })
 };
 function getProtocolSupportAdvisor(protocolId) {
@@ -13224,25 +14534,6 @@ function listProtocolSupportAdvisorIds() {
 }
 
 // src/agent/catalog.ts
-registerProtocolModule(uniswapV4ProtocolModule);
-registerProtocolModule(curveDaoProtocolModule);
-registerProtocolModule(lidoProtocolModule);
-registerProtocolModule(ethenaProtocolModule);
-registerProtocolModule(mapleProtocolModule);
-registerProtocolModule(skyProtocolModule);
-registerProtocolModule(aaveV4ProtocolModule);
-registerProtocolModule(eulerV2ProtocolModule);
-registerProtocolModule(gmxProtocolModule);
-registerProtocolModule(hyperliquidProtocolModule);
-registerProtocolModule(arcusProtocolModule);
-registerProtocolModule(morphoProtocolModule);
-registerProtocolModule(circleCctpProtocolModule);
-registerProtocolModule(veniceProtocolModule);
-registerProtocolModule(aerodromeProtocolModule);
-registerProtocolModule(continuumDaoProtocolModule);
-registerProtocolModule(compoundV3ProtocolModule);
-registerProtocolModule(pendleProtocolModule);
-registerProtocolModule(deriveProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -13270,6 +14561,8 @@ function getAgentCatalog() {
     compoundV3: compoundV3ProtocolModule,
     pendle: pendleProtocolModule,
     derive: deriveProtocolModule,
+    trueo: trueoProtocolModule,
+    hyperliquidOutcome: hyperliquidOutcomeProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -13284,6 +14577,7 @@ exports.MCP_TOOL_OUTPUT_SCHEMAS = MCP_TOOL_OUTPUT_SCHEMAS;
 exports.MULTISIGN_OUTPUT_DOC = MULTISIGN_OUTPUT_DOC;
 exports.MULTISIGN_SUBMIT_OUTPUT_DOC = MULTISIGN_SUBMIT_OUTPUT_DOC;
 exports.PROTOCOL_SUPPORT_ADVISORS = PROTOCOL_SUPPORT_ADVISORS;
+exports.agentEvmChainIdSchema = agentEvmChainIdSchema;
 exports.chainDetailSchema = chainDetailSchema;
 exports.evmAddressSchema = evmAddressSchema;
 exports.evmMultisignCommonInputSchema = evmMultisignCommonInputSchema;
@@ -13540,6 +14834,8 @@ exports.mcpEulerV2IsolatedBorrowInputSchema = mcpEulerV2IsolatedBorrowInputSchem
 exports.mcpEulerV2IsolatedLendInputSchema = mcpEulerV2IsolatedLendInputSchema;
 exports.mcpEulerV2MerklClaimInputSchema = mcpEulerV2MerklClaimInputSchema;
 exports.mcpEulerV2VaultWithdrawInputSchema = mcpEulerV2VaultWithdrawInputSchema;
+exports.mcpGetPredictionMarketInputSchema = mcpGetPredictionMarketInputSchema;
+exports.mcpGetPredictionMarketOutputSchema = mcpGetPredictionMarketOutputSchema;
 exports.mcpGmxCancelInputSchema = mcpGmxCancelInputSchema;
 exports.mcpGmxDecreaseInputSchema = mcpGmxDecreaseInputSchema;
 exports.mcpGmxFetchGmApyInputSchema = mcpGmxFetchGmApyInputSchema;
@@ -13618,6 +14914,8 @@ exports.mcpLidoRequestWithdrawalsInputSchema = mcpLidoRequestWithdrawalsInputSch
 exports.mcpLidoSubmitInputSchema = mcpLidoSubmitInputSchema;
 exports.mcpLidoUnwrapWstEthInputSchema = mcpLidoUnwrapWstEthInputSchema;
 exports.mcpLidoWrapStEthInputSchema = mcpLidoWrapStEthInputSchema;
+exports.mcpListMyPredictionMarketsInputSchema = mcpListMyPredictionMarketsInputSchema;
+exports.mcpListMyPredictionMarketsOutputSchema = mcpListMyPredictionMarketsOutputSchema;
 exports.mcpMapleDepositInputSchema = mcpMapleDepositInputSchema;
 exports.mcpMapleFetchMarketInputSchema = mcpMapleFetchMarketInputSchema;
 exports.mcpMapleFetchMarketOutputSchema = mcpMapleFetchMarketOutputSchema;
@@ -13685,6 +14983,9 @@ exports.mcpPendleQuoteRemoveLiquidityInputSchema = mcpPendleQuoteRemoveLiquidity
 exports.mcpPendleQuoteSwapInputSchema = mcpPendleQuoteSwapInputSchema;
 exports.mcpPendleSearchAssetsInputSchema = mcpPendleSearchAssetsInputSchema;
 exports.mcpPendleSearchAssetsOutputSchema = mcpPendleSearchAssetsOutputSchema;
+exports.mcpPredictionMarketRowSchema = mcpPredictionMarketRowSchema;
+exports.mcpSearchPredictionMarketsInputSchema = mcpSearchPredictionMarketsInputSchema;
+exports.mcpSearchPredictionMarketsOutputSchema = mcpSearchPredictionMarketsOutputSchema;
 exports.mcpServerCommonInputSchema = mcpServerCommonInputSchema;
 exports.mcpServerMultisignInput = mcpServerMultisignInput;
 exports.mcpServerSubmitOutputSchema = mcpServerSubmitOutputSchema;
@@ -13697,6 +14998,27 @@ exports.mcpSkyLockstakeStakeInputSchema = mcpSkyLockstakeStakeInputSchema;
 exports.mcpSkyLockstakeWipeInputSchema = mcpSkyLockstakeWipeInputSchema;
 exports.mcpSkySusdsDepositInputSchema = mcpSkySusdsDepositInputSchema;
 exports.mcpSkySusdsRedeemInputSchema = mcpSkySusdsRedeemInputSchema;
+exports.mcpTrueoBurnInputSchema = mcpTrueoBurnInputSchema;
+exports.mcpTrueoCancelOrderInputSchema = mcpTrueoCancelOrderInputSchema;
+exports.mcpTrueoCreateOrderInputSchema = mcpTrueoCreateOrderInputSchema;
+exports.mcpTrueoFetchCategoriesInputSchema = mcpTrueoFetchCategoriesInputSchema;
+exports.mcpTrueoFetchCategoriesOutputSchema = mcpTrueoFetchCategoriesOutputSchema;
+exports.mcpTrueoFetchChanceSeriesInputSchema = mcpTrueoFetchChanceSeriesInputSchema;
+exports.mcpTrueoFetchChanceSeriesOutputSchema = mcpTrueoFetchChanceSeriesOutputSchema;
+exports.mcpTrueoFetchMarketInputSchema = mcpTrueoFetchMarketInputSchema;
+exports.mcpTrueoFetchMarketOutputSchema = mcpTrueoFetchMarketOutputSchema;
+exports.mcpTrueoFetchOrderbookInputSchema = mcpTrueoFetchOrderbookInputSchema;
+exports.mcpTrueoFetchOrderbookOutputSchema = mcpTrueoFetchOrderbookOutputSchema;
+exports.mcpTrueoFetchTrendingInputSchema = mcpTrueoFetchTrendingInputSchema;
+exports.mcpTrueoFetchTrendingOutputSchema = mcpTrueoFetchTrendingOutputSchema;
+exports.mcpTrueoMarketRowSchema = mcpTrueoMarketRowSchema;
+exports.mcpTrueoMintInputSchema = mcpTrueoMintInputSchema;
+exports.mcpTrueoRedeemInputSchema = mcpTrueoRedeemInputSchema;
+exports.mcpTrueoSearchMarketsInputSchema = mcpTrueoSearchMarketsInputSchema;
+exports.mcpTrueoSearchMarketsOutputSchema = mcpTrueoSearchMarketsOutputSchema;
+exports.mcpTrueoSwapInputSchema = mcpTrueoSwapInputSchema;
+exports.mcpTrueoUnwrapTydInputSchema = mcpTrueoUnwrapTydInputSchema;
+exports.mcpTrueoWrapTydInputSchema = mcpTrueoWrapTydInputSchema;
 exports.mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema = mcpUniswapV4BuildAllowlistFinalizeMultisignInputSchema;
 exports.mcpUniswapV4BuildCollectFeesMultisignInputSchema = mcpUniswapV4BuildCollectFeesMultisignInputSchema;
 exports.mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema = mcpUniswapV4BuildDecreaseLiquidityMultisignInputSchema;