@continuumdao/ctm-mpc-defi 0.2.50 → 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");
     [
@@ -2755,7 +2764,12 @@ var MCP_NON_SUBMIT_TOOL_NAMES = /* @__PURE__ */ new Set([
   "ctm_trueo_search_markets",
   "ctm_trueo_fetch_market",
   "ctm_trueo_fetch_chance_series",
-  "ctm_trueo_fetch_orderbook"
+  "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
@@ -5405,7 +5419,7 @@ var mcpSearchPredictionMarketsInputSchema = zod.z.object({
     "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. v1: trueo"),
+  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."
   ),
@@ -5467,8 +5481,8 @@ var mcpListMyPredictionMarketsInputSchema = zod.z.object({
 });
 var mcpListMyPredictionMarketsOutputSchema = mcpSearchPredictionMarketsOutputSchema;
 var mcpGetPredictionMarketInputSchema = zod.z.object({
-  venue: zod.z.string().optional().describe("Default trueo"),
-  venueMarketId: zod.z.string().min(1).describe("Venue id (Trueo: market address)")
+  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({
@@ -5866,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) {
@@ -7250,6 +7389,430 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     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"
   })
 ];
 
@@ -9704,12 +10267,72 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     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 for MPA chat. v1 adapter is Trueo on Base. Pass the operator topic verbatim as query (case-insensitive title substring). Do not substitute a category or synonym. Do not set trending when query is set. Empty query lists trending (max 10; cannot page). If hasMore, call again with offset/nextOffset, trending=false, indexBase=nextIndexBase, excludeAddresses of listed venueMarketIds. Default: live and recently finished (14 days) \u2014 do not pass includeAll unless the operator asked for closed or historical markets. If the live board is empty, say so. After a pick, get_prediction_market. Writes (mint / limit / burn / redeem / Yes-No swap) are not in the opening catalog \u2014 load_defi_protocol({ protocolId: "trueo" }) then get_defi_protocol_skill or search_continuum_tools for ctm_trueo_build_*.',
+    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" },
@@ -9721,7 +10344,7 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     actionId: "prediction-markets.get",
     protocolId: "prediction-markets",
     chainCategory: "evm",
-    description: 'Full selected prediction market (rules, Yes/No, volume, TVL, expiry). Use after search_prediction_markets pick #N. Does not require load_defi_protocol. Writes stay behind load_defi_protocol({ protocolId: "trueo" }): ctm_trueo_build_wrap_tyd_multisign, ctm_trueo_build_unwrap_tyd_multisign, ctm_trueo_build_mint_multisign, ctm_trueo_build_create_order_multisign, ctm_trueo_build_burn_multisign, ctm_trueo_build_redeem_multisign, ctm_trueo_build_swap_multisign. Discover via get_defi_protocol_skill or search_continuum_tools \u2014 they are not on the opening chat catalog.',
+    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",
@@ -9838,7 +10461,8 @@ var CORE_MCP_TOOL_DEFINITIONS = [
 ];
 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 = {};
@@ -11659,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",
@@ -13058,6 +13722,9 @@ 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,
@@ -13137,6 +13804,71 @@ var trueoProtocolModule = {
   ]
 };
 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",
@@ -13155,9 +13887,11 @@ var SKILL_PROTOCOL_IDS = [
   "aerodrome",
   "pendle",
   "continuum-dao",
+  "continuum-dao-marketplace",
   "compound-v3",
   "derive",
   "trueo",
+  "hyperliquidOutcome",
   "yield-compare"
 ];
 function getToolsForProtocol(protocolId) {
@@ -13526,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];
@@ -13590,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();
@@ -13773,26 +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);
-registerProtocolModule(trueoProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -13821,6 +14562,7 @@ function getAgentCatalog() {
     pendle: pendleProtocolModule,
     derive: deriveProtocolModule,
     trueo: trueoProtocolModule,
+    hyperliquidOutcome: hyperliquidOutcomeProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };