@continuumdao/ctm-mpc-defi 0.2.49 → 0.2.51

package/dist/protocols/evm/continuum-dao/index.js

@@ -1,4 +1,4 @@
-import { parseAbi, parseAbiItem, getAddress, zeroAddress, encodeFunctionData, keccak256, encodePacked, padHex, toHex, createPublicClient, defineChain, parseUnits, isAddress, formatUnits, hashTypedData, http, stringToHex, parseGwei, serializeTransaction } from 'viem';
+import { parseAbi, parseAbiItem, getAddress, zeroAddress, encodeFunctionData, keccak256, encodePacked, padHex, toHex, createPublicClient, defineChain, parseUnits, isAddress, formatUnits, hashTypedData, http, decodeEventLog, stringToHex, parseGwei, serializeTransaction } from 'viem';
 import { getClientIdFromKeyGenResult, fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase } from '@continuumdao/continuum-node-sdk';
 
 var __defProp = Object.defineProperty;
@@ -38,19 +38,19 @@ var init_chainIdParse = __esm({
   "src/chains/evm/chainIdParse.ts"() {
   }
 });
-function isContinuumDaoCommitteeProposer(addr) {
-  if (!addr || !isConfiguredAddress(addr)) return false;
+function isContinuumDaoCommitteeProposer(addr2) {
+  if (!addr2 || !isConfiguredAddress(addr2)) return false;
   try {
-    const a = getAddress(addr);
+    const a = getAddress(addr2);
     return CONTINUUM_DAO_COMMITTEE_PROPOSERS.some((c) => c === a);
   } catch {
     return false;
   }
 }
-function isConfiguredAddress(addr) {
-  if (!addr?.trim()) return false;
+function isConfiguredAddress(addr2) {
+  if (!addr2?.trim()) return false;
   try {
-    return getAddress(addr) !== zeroAddress;
+    return getAddress(addr2) !== zeroAddress;
   } catch {
     return false;
   }
@@ -72,6 +72,10 @@ function votingEscrowAddressOnEvmChain(chainId) {
   const ve = continuumDaoDeployment(chainId)?.votingEscrow;
   return ve && isConfiguredAddress(ve) ? getAddress(ve) : null;
 }
+function votingEscrowMarketplaceAddressOnEvmChain(chainId) {
+  if (chainId !== CONTINUUM_DAO_LINEA_CHAIN_ID) return null;
+  return VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS;
+}
 function governorAddressOnEvmChain(chainId) {
   const gov = continuumDaoDeployment(chainId)?.governor;
   return gov && isConfiguredAddress(gov) ? getAddress(gov) : null;
@@ -134,7 +138,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, WEEK_SECONDS, MAXTIME_SECONDS, VECTM_MAX_LOCK_WEEKS, VECTM_DEFAULT_MINIMUM_LOCK_WEI, VECTM_LIQ_MIN_LOCKED_WEI, VECTM_LIQ_PENALTY_NUM, VECTM_LIQ_PENALTY_DEN, UNSET, CTM_TOKEN_ADDRESS, VOTING_ESCROW_LINEA_ADDRESS, CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS, CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS, CONTINUUM_DAO_COMMITTEE_PROPOSERS, CONTINUUM_DAO_DEPLOYMENTS, CONTINUUM_DAO_GOVERNANCE_API;
+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, WEEK_SECONDS, MAXTIME_SECONDS, VECTM_MAX_LOCK_WEEKS, VECTM_DEFAULT_MINIMUM_LOCK_WEI, VECTM_LIQ_MIN_LOCKED_WEI, VECTM_LIQ_PENALTY_NUM, VECTM_LIQ_PENALTY_DEN, UNSET, CTM_TOKEN_ADDRESS, VOTING_ESCROW_LINEA_ADDRESS, MULTISIGN_AGENT_WALLET_LINEA_ADDRESS, CTM_FEE_RATE_SCALE, VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS, VOTING_ESCROW_MARKETPLACE_START_BLOCK, MARKETPLACE_WETH_LINEA_ADDRESS, MARKETPLACE_USDC_LINEA_ADDRESS, CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS, CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS, CONTINUUM_DAO_COMMITTEE_PROPOSERS, CONTINUUM_DAO_DEPLOYMENTS, CONTINUUM_DAO_GOVERNANCE_API, CONTINUUM_DAO_MARKETPLACE_API;
 var init_constants = __esm({
   "src/protocols/evm/continuum-dao/constants.ts"() {
     init_chainIdParse();
@@ -163,6 +167,13 @@ var init_constants = __esm({
     };
     CTM_TOKEN_ADDRESS = getAddress("0x2026027054F5beBCEB650aBD62dC623e327658e7");
     VOTING_ESCROW_LINEA_ADDRESS = getAddress("0x221EC90B3B083A8501A37bdeb7035CeaedF3C31f");
+    MULTISIGN_AGENT_WALLET_LINEA_ADDRESS = getAddress("0x4ebd7cCBe32a51d1638cFE90E8eD1c4BdF42f729");
+    CTM_FEE_RATE_SCALE = 1000n;
+    VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS = getAddress("0x92557d38beAe4658d3c03A02F349FFB60c3bfFA5");
+    VOTING_ESCROW_MARKETPLACE_START_BLOCK = 32100001n;
+    MARKETPLACE_WETH_LINEA_ADDRESS = getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f");
+    MARKETPLACE_USDC_LINEA_ADDRESS = getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff");
+    CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID = "continuum-dao-marketplace";
     CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS = getAddress("0x76FF2CB03175900F1D83328C82D27EA9aeaF2355");
     CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS = getAddress("0x4800F9f1dC1b6daCA841B71E0531F547D374168E");
     CONTINUUM_DAO_COMMITTEE_PROPOSERS = [
@@ -183,6 +194,7 @@ var init_constants = __esm({
       }
     };
     CONTINUUM_DAO_GOVERNANCE_API = "https://app-api.continuumdao.org";
+    CONTINUUM_DAO_MARKETPLACE_API = CONTINUUM_DAO_GOVERNANCE_API;
   }
 });
 function defiEvmTransport(rpcUrl, opts) {
@@ -604,25 +616,25 @@ async function forumFetch(path, init = {}) {
   return body;
 }
 async function continuumDaoForumResolve(args) {
-  const qs = new URLSearchParams();
-  if (args.url) qs.set("url", String(args.url));
-  if (args.tid != null) qs.set("tid", String(args.tid));
-  return forumFetch(`/api/continuum/forum/resolve?${qs}`, { forumUrl: args.forumUrl });
+  const qs2 = new URLSearchParams();
+  if (args.url) qs2.set("url", String(args.url));
+  if (args.tid != null) qs2.set("tid", String(args.tid));
+  return forumFetch(`/api/continuum/forum/resolve?${qs2}`, { forumUrl: args.forumUrl });
 }
 async function continuumDaoForumFetchThread(args) {
-  const qs = new URLSearchParams();
-  if (args.url) qs.set("url", String(args.url));
-  if (args.tid != null) qs.set("tid", String(args.tid));
-  if (args.index != null) qs.set("index", String(args.index));
-  if (args.start != null) qs.set("start", String(args.start));
-  if (args.limit != null) qs.set("limit", String(args.limit));
-  return forumFetch(`/api/continuum/forum/thread?${qs}`, { forumUrl: args.forumUrl });
+  const qs2 = new URLSearchParams();
+  if (args.url) qs2.set("url", String(args.url));
+  if (args.tid != null) qs2.set("tid", String(args.tid));
+  if (args.index != null) qs2.set("index", String(args.index));
+  if (args.start != null) qs2.set("start", String(args.start));
+  if (args.limit != null) qs2.set("limit", String(args.limit));
+  return forumFetch(`/api/continuum/forum/thread?${qs2}`, { forumUrl: args.forumUrl });
 }
 async function continuumDaoForumReplyCount(args) {
-  const qs = new URLSearchParams();
-  if (args.url) qs.set("url", String(args.url));
-  if (args.tid != null) qs.set("tid", String(args.tid));
-  return forumFetch(`/api/continuum/forum/thread/replies?${qs}`, { forumUrl: args.forumUrl });
+  const qs2 = new URLSearchParams();
+  if (args.url) qs2.set("url", String(args.url));
+  if (args.tid != null) qs2.set("tid", String(args.tid));
+  return forumFetch(`/api/continuum/forum/thread/replies?${qs2}`, { forumUrl: args.forumUrl });
 }
 async function continuumDaoForumFetchPost(args) {
   return forumFetch(`/api/continuum/forum/post?pid=${encodeURIComponent(String(args.pid))}`, {
@@ -648,22 +660,22 @@ function assertContinuumDaoForumRecentInput(args) {
 }
 async function continuumDaoForumSearch(args) {
   assertContinuumDaoForumSearchInput(args);
-  const qs = new URLSearchParams();
-  if (args.query?.trim()) qs.set("query", args.query.trim());
-  if (args.hours != null) qs.set("hours", String(args.hours));
-  if (args.since?.trim()) qs.set("since", args.since.trim());
-  if (args.start != null) qs.set("start", String(args.start));
-  if (args.limit != null) qs.set("limit", String(args.limit));
-  return forumFetch(`/api/continuum/forum/search?${qs}`, { forumUrl: args.forumUrl });
+  const qs2 = new URLSearchParams();
+  if (args.query?.trim()) qs2.set("query", args.query.trim());
+  if (args.hours != null) qs2.set("hours", String(args.hours));
+  if (args.since?.trim()) qs2.set("since", args.since.trim());
+  if (args.start != null) qs2.set("start", String(args.start));
+  if (args.limit != null) qs2.set("limit", String(args.limit));
+  return forumFetch(`/api/continuum/forum/search?${qs2}`, { forumUrl: args.forumUrl });
 }
 async function continuumDaoForumRecent(args) {
   assertContinuumDaoForumRecentInput(args);
-  const qs = new URLSearchParams();
-  if (args.hours != null) qs.set("hours", String(args.hours));
-  if (args.since?.trim()) qs.set("since", args.since.trim());
-  if (args.start != null) qs.set("start", String(args.start));
-  if (args.limit != null) qs.set("limit", String(args.limit));
-  return forumFetch(`/api/continuum/forum/recent?${qs}`, {
+  const qs2 = new URLSearchParams();
+  if (args.hours != null) qs2.set("hours", String(args.hours));
+  if (args.since?.trim()) qs2.set("since", args.since.trim());
+  if (args.start != null) qs2.set("start", String(args.start));
+  if (args.limit != null) qs2.set("limit", String(args.limit));
+  return forumFetch(`/api/continuum/forum/recent?${qs2}`, {
     forumUrl: args.forumUrl,
     ticket: args.ticket
   });
@@ -697,10 +709,10 @@ async function continuumDaoForumDelete(args) {
   });
 }
 async function continuumDaoForumUserPostIds(args) {
-  const qs = new URLSearchParams({ username: args.username });
-  if (args.start != null) qs.set("start", String(args.start));
-  if (args.limit != null) qs.set("limit", String(args.limit));
-  return forumFetch(`/api/continuum/forum/user/posts?${qs}`, { forumUrl: args.forumUrl });
+  const qs2 = new URLSearchParams({ username: args.username });
+  if (args.start != null) qs2.set("start", String(args.start));
+  if (args.limit != null) qs2.set("limit", String(args.limit));
+  return forumFetch(`/api/continuum/forum/user/posts?${qs2}`, { forumUrl: args.forumUrl });
 }
 async function continuumDaoForumReply(args) {
   return forumFetch("/api/continuum/forum/reply", {
@@ -771,11 +783,11 @@ async function continuumDaoForumUnread(args) {
   if (!args.ticket?.trim()) {
     throw new Error("ticket is required to list unread forum topics");
   }
-  const qs = new URLSearchParams();
-  if (args.filter?.trim()) qs.set("filter", args.filter.trim());
-  if (args.start != null) qs.set("start", String(args.start));
-  if (args.limit != null) qs.set("limit", String(args.limit));
-  const suffix = qs.toString() ? `?${qs}` : "";
+  const qs2 = new URLSearchParams();
+  if (args.filter?.trim()) qs2.set("filter", args.filter.trim());
+  if (args.start != null) qs2.set("start", String(args.start));
+  if (args.limit != null) qs2.set("limit", String(args.limit));
+  const suffix = qs2.toString() ? `?${qs2}` : "";
   return forumFetch(`/api/continuum/forum/unread${suffix}`, {
     forumUrl: args.forumUrl,
     ticket: args.ticket
@@ -924,12 +936,12 @@ async function continuumDaoForumSignInEligible(args) {
   };
 }
 async function continuumDaoForumSignInNonce(args) {
-  const qs = new URLSearchParams({
+  const qs2 = new URLSearchParams({
     address: args.address,
     nodeKey: args.nodeKey || "",
     username: args.username || ""
   });
-  return forumFetch(`/api/continuum/eip712/nonce?${qs}`, { forumUrl: args.forumUrl });
+  return forumFetch(`/api/continuum/eip712/nonce?${qs2}`, { forumUrl: args.forumUrl });
 }
 async function buildEvmMultisignBodyContinuumDaoForumSignIn(args) {
   const owner = getAddress(args.executorAddress);
@@ -2293,9 +2305,9 @@ function parseBackendProposal(raw) {
     committeeProposer: proposer ? isContinuumDaoCommitteeProposer(proposer) : void 0
   };
 }
-function isLegacyContinuumDaoGovernor(addr) {
-  if (!addr || !isConfiguredAddress(addr)) return false;
-  return getAddress(addr) === CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS;
+function isLegacyContinuumDaoGovernor(addr2) {
+  if (!addr2 || !isConfiguredAddress(addr2)) return false;
+  return getAddress(addr2) === CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS;
 }
 function summarizeLiveProposals(result) {
   if (result.overlay === "backend-only") {
@@ -2472,6 +2484,45 @@ function registerProtocolModule(mod) {
 
 // src/protocols/evm/continuum-dao/index.ts
 init_constants();
+
+// src/protocols/evm/continuum-dao/marketplaceModule.ts
+init_constants();
+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_constants();
 
 // src/protocols/evm/continuum-dao/escrowRules.ts
@@ -2767,13 +2818,13 @@ async function readVeCtmLockState(args) {
   let attached = false;
   if (isConfiguredAddress(nodeProperties)) {
     try {
-      const attachedKey = await client.readContract({
+      const attachedKey2 = await client.readContract({
         address: getAddress(nodeProperties),
         abi: nodePropsAbi,
         functionName: "attachedKeyGen",
         args: [args.tokenId]
       });
-      attached = attachedKey !== zeroAddress;
+      attached = attachedKey2 !== zeroAddress;
     } catch {
       attached = false;
     }
@@ -2941,7 +2992,7 @@ async function preflightAttachVeCtm(args) {
   }
   if (isConfiguredAddress(nodeProperties)) {
     const np = getAddress(nodeProperties);
-    const [attachedKey, attachedForKey] = await Promise.all([
+    const [attachedKey2, attachedForKey] = await Promise.all([
       client.readContract({
         address: np,
         abi: nodePropsAbi,
@@ -2955,7 +3006,7 @@ async function preflightAttachVeCtm(args) {
         args: [executor]
       })
     ]);
-    if (attachedKey !== zeroAddress) {
+    if (attachedKey2 !== zeroAddress) {
       throw new Error(`veCTM #${args.tokenId} is already attached. You cannot replace an attached NFT.`);
     }
     if (attachedForKey !== 0n) {
@@ -2972,7 +3023,7 @@ async function preflightAttachVeCtm(args) {
 }
 async function preflightRequestDetach(args) {
   const client = publicClient(args.rpcUrl, args.chainId);
-  const [attachedKey, alreadyRequested] = await Promise.all([
+  const [attachedKey2, alreadyRequested] = await Promise.all([
     client.readContract({
       address: args.nodeProperties,
       abi: nodePropsAbi,
@@ -2986,7 +3037,7 @@ async function preflightRequestDetach(args) {
       args: [args.tokenId]
     })
   ]);
-  if (attachedKey === zeroAddress) {
+  if (attachedKey2 === zeroAddress) {
     throw new Error(`veCTM #${args.tokenId} is not attached to a node.`);
   }
   if (alreadyRequested) {
@@ -2994,9 +3045,9 @@ async function preflightRequestDetach(args) {
       `Detach already requested for veCTM #${args.tokenId}. The NFT stays attached until governance executes detach.`
     );
   }
-  if (getAddress(attachedKey) !== getAddress(args.owner)) {
+  if (getAddress(attachedKey2) !== getAddress(args.owner)) {
     throw new Error(
-      `Request detach from the attached KeyGen (${getAddress(attachedKey)}).`
+      `Request detach from the attached KeyGen (${getAddress(attachedKey2)}).`
     );
   }
 }
@@ -3850,8 +3901,8 @@ function extractAbiFromSourcifyFiles(data) {
     if (!label.includes("metadata.json") && f.name !== "metadata.json") continue;
     if (typeof f.content !== "string") continue;
     try {
-      const meta3 = JSON.parse(f.content);
-      const abi = extractAbiFromUnknown(meta3);
+      const meta4 = JSON.parse(f.content);
+      const abi = extractAbiFromUnknown(meta4);
       if (abi) return abi;
     } catch {
       continue;
@@ -4711,6 +4762,2112 @@ async function continuumDaoFetchProposalVotes(args, deps) {
 
 // src/protocols/evm/continuum-dao/index.ts
 init_forum();
+
+// src/protocols/evm/continuum-dao/marketplaceTypes.ts
+var MARKET_ORDER_STATUS = [
+  "NonExistent",
+  "Open",
+  "Fulfilled",
+  "Expired",
+  "DelistedOrRescinded",
+  "LockAmountDecreased",
+  "LockEndIncreased",
+  "TokenApprovalRequired",
+  "PaymentApprovalRequired",
+  "KeyGenAttached"
+];
+var AUCTION_STATUS = [
+  "NonExistent",
+  "Pending",
+  "Active",
+  "Complete",
+  "Sold",
+  "Canceled",
+  "Expired"
+];
+var FEE_TIER_NAMES = ["Black", "Gold", "Silver", "Bronze", "Blue"];
+function orderStatusName(code) {
+  return MARKET_ORDER_STATUS[code] ?? "NonExistent";
+}
+function auctionStatusName(code) {
+  return AUCTION_STATUS[code] ?? "NonExistent";
+}
+function addr(value) {
+  try {
+    return getAddress(value);
+  } catch {
+    return value;
+  }
+}
+function same(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+function deadlineAt(unix) {
+  const n = Number(unix);
+  if (!Number.isFinite(n) || n <= 0) return "";
+  return new Date(n * 1e3).toISOString();
+}
+function blankOrder(kind, tokenId, creator, index) {
+  return {
+    kind,
+    tokenId,
+    onchainIndex: index,
+    creator: addr(creator),
+    paymentToken: zeroAddress,
+    price: "0",
+    deadlineUnix: "0",
+    deadlineAt: "",
+    snapshotAmount: "0",
+    snapshotEnd: "0",
+    storedStatus: "Open",
+    protocolStatus: "Open"
+  };
+}
+function blankAuction(tokenId, seller, index) {
+  return {
+    tokenId,
+    onchainIndex: index,
+    seller: addr(seller),
+    paymentToken: zeroAddress,
+    reservePrice: "0",
+    minimumBidIncrement: "0",
+    highestBid: "0",
+    highestBidder: null,
+    deadlineUnix: "0",
+    deadlineAt: "",
+    storedStatus: "Pending",
+    derivedStatus: "Pending",
+    needsSettle: false,
+    bids: []
+  };
+}
+function latestOpenOrder(rows, kind, tokenId, creator) {
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const row = rows[i];
+    if (row.kind === kind && row.tokenId === tokenId && same(row.creator, creator) && row.storedStatus === "Open") {
+      return row;
+    }
+  }
+  return void 0;
+}
+function latestAuction(rows, tokenId, seller) {
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const row = rows[i];
+    if (row.tokenId === tokenId && same(row.seller, seller)) return row;
+  }
+  return void 0;
+}
+function applyMarketplaceEvent(book, ev) {
+  const listingSeq = book.listings.reduce((max, row) => Math.max(max, Number(row.onchainIndex) || 0), 0);
+  const offeringSeq = book.offerings.reduce((max, row) => Math.max(max, Number(row.onchainIndex) || 0), 0);
+  const auctionSeq = book.auctions.reduce((max, row) => Math.max(max, Number(row.onchainIndex) || 0), 0);
+  const next = (seq) => String(seq + 1);
+  if (ev.name === "ListingCreated" || ev.name === "OfferingCreated") {
+    const kind = ev.name === "ListingCreated" ? "Listing" : "Offering";
+    const rows = kind === "Listing" ? book.listings : book.offerings;
+    const prev = latestOpenOrder(rows, kind, ev.tokenId, ev.actor);
+    if (prev) {
+      prev.storedStatus = "DelistedOrRescinded";
+      prev.protocolStatus = "DelistedOrRescinded";
+      prev.closedTx = ev.tx;
+      prev.closedBlock = ev.block;
+    }
+    const row = blankOrder(kind, ev.tokenId, ev.actor, next(kind === "Listing" ? listingSeq : offeringSeq));
+    row.paymentToken = addr(ev.paymentToken);
+    row.price = ev.amount;
+    row.deadlineUnix = ev.deadline;
+    row.deadlineAt = deadlineAt(ev.deadline);
+    row.createdTx = ev.tx;
+    row.createdBlock = ev.block;
+    if (kind === "Listing") row.seller = addr(ev.actor);
+    else row.buyer = addr(ev.actor);
+    rows.push(row);
+    return;
+  }
+  if (ev.name === "Delisted" || ev.name === "Rescinded") {
+    const kind = ev.name === "Delisted" ? "Listing" : "Offering";
+    const row = latestOpenOrder(kind === "Listing" ? book.listings : book.offerings, kind, ev.tokenId, ev.actor);
+    if (row) {
+      row.storedStatus = "DelistedOrRescinded";
+      row.protocolStatus = "DelistedOrRescinded";
+      row.closedTx = ev.tx;
+      row.closedBlock = ev.block;
+    }
+    return;
+  }
+  if (ev.name === "ListingFulfilled" || ev.name === "OfferingFulfilled") {
+    const kind = ev.name === "ListingFulfilled" ? "Listing" : "Offering";
+    const actor = kind === "Listing" ? ev.seller : ev.buyer;
+    const row = latestOpenOrder(kind === "Listing" ? book.listings : book.offerings, kind, ev.tokenId, actor);
+    if (row) {
+      row.storedStatus = "Fulfilled";
+      row.protocolStatus = "Fulfilled";
+      row.counterparty = addr(kind === "Listing" ? ev.buyer : ev.seller);
+      row.seller = addr(ev.seller);
+      row.buyer = addr(ev.buyer);
+      row.fee = ev.fee;
+      row.net = ev.net;
+      row.closedTx = ev.tx;
+      row.closedBlock = ev.block;
+    }
+    return;
+  }
+  if (ev.name === "AuctionCreated") {
+    const prev = latestAuction(book.auctions, ev.tokenId, ev.actor);
+    if (prev && (prev.storedStatus === "Pending" || prev.storedStatus === "Active")) {
+      prev.storedStatus = "Canceled";
+      prev.derivedStatus = "Canceled";
+      prev.closedTx = ev.tx;
+      prev.closedBlock = ev.block;
+    }
+    const row = blankAuction(ev.tokenId, ev.actor, next(auctionSeq));
+    row.paymentToken = addr(ev.paymentToken);
+    row.reservePrice = ev.amount;
+    row.minimumBidIncrement = ev.minIncrement;
+    row.deadlineUnix = ev.deadline;
+    row.deadlineAt = deadlineAt(ev.deadline);
+    row.createdTx = ev.tx;
+    row.createdBlock = ev.block;
+    book.auctions.push(row);
+    return;
+  }
+  if (ev.name === "AuctionCanceled") {
+    const row = latestAuction(book.auctions, ev.tokenId, ev.actor);
+    if (row && row.storedStatus === "Pending") {
+      row.storedStatus = "Canceled";
+      row.derivedStatus = "Canceled";
+      row.closedTx = ev.tx;
+      row.closedBlock = ev.block;
+    }
+    return;
+  }
+  if (ev.name === "AuctionBid") {
+    const row = latestAuction(book.auctions, ev.tokenId, ev.seller);
+    if (!row || row.storedStatus !== "Pending" && row.storedStatus !== "Active") return;
+    row.bids = [
+      ...row.bids,
+      {
+        bidder: addr(ev.buyer),
+        price: ev.price,
+        tx: ev.tx,
+        timestamp: ev.timestamp ?? "0",
+        logIndex: String(ev.logIndex),
+        block: ev.block
+      }
+    ];
+    row.highestBid = ev.price;
+    row.highestBidder = addr(ev.buyer);
+    row.storedStatus = "Active";
+    row.derivedStatus = "Active";
+    return;
+  }
+  if (ev.name === "AuctionSettled") {
+    const row = latestAuction(book.auctions, ev.tokenId, ev.seller);
+    if (!row) return;
+    const name = auctionStatusName(ev.finalStatus);
+    row.storedStatus = name;
+    row.derivedStatus = name;
+    row.needsSettle = false;
+    row.closedTx = ev.tx;
+    row.closedBlock = ev.block;
+    return;
+  }
+  if (ev.name === "AuctionSuccessful") {
+    const row = latestAuction(book.auctions, ev.tokenId, ev.seller);
+    if (!row) return;
+    row.storedStatus = "Sold";
+    row.derivedStatus = "Sold";
+    row.buyer = addr(ev.buyer);
+    row.highestBidder = addr(ev.buyer);
+    row.highestBid = ev.price;
+    row.fee = ev.fee;
+    row.net = ev.net;
+    row.needsSettle = false;
+    row.closedTx = ev.tx;
+    row.closedBlock = ev.block;
+  }
+}
+function foldMarketplaceEvents(events, initial) {
+  const book = {
+    listings: [...initial?.listings ?? []],
+    offerings: [...initial?.offerings ?? []],
+    auctions: (initial?.auctions ?? []).map((row) => ({ ...row, bids: [...row.bids] }))
+  };
+  for (const ev of events) applyMarketplaceEvent(book, ev);
+  return book;
+}
+function deriveAuctionStatus(auction, nowUnix) {
+  const deadline = Number(auction.deadlineUnix);
+  if (auction.storedStatus === "Pending" && Number.isFinite(deadline) && nowUnix >= deadline) return "Expired";
+  if (auction.storedStatus === "Active" && Number.isFinite(deadline) && nowUnix >= deadline) return "Complete";
+  return auction.derivedStatus || auction.storedStatus;
+}
+function applyDerivedStatuses(book, nowUnix) {
+  return {
+    listings: book.listings.map((row) => {
+      const deadline = Number(row.deadlineUnix);
+      if (row.storedStatus === "Open" && Number.isFinite(deadline) && nowUnix >= deadline) {
+        return { ...row, protocolStatus: "Expired" };
+      }
+      return row;
+    }),
+    offerings: book.offerings.map((row) => {
+      const deadline = Number(row.deadlineUnix);
+      if (row.storedStatus === "Open" && Number.isFinite(deadline) && nowUnix >= deadline) {
+        return { ...row, protocolStatus: "Expired" };
+      }
+      return row;
+    }),
+    auctions: book.auctions.map((row) => {
+      const derived = deriveAuctionStatus(row, nowUnix);
+      const needsSettle = derived === "Complete" || derived === "Expired";
+      return { ...row, derivedStatus: derived, needsSettle };
+    })
+  };
+}
+function isLiveAuctionStatus(status) {
+  return status === "Pending" || status === "Active" || status === "Complete";
+}
+function isOpenOrder(row) {
+  return row.storedStatus === "Open" && row.protocolStatus === "Open";
+}
+var marketplaceAbi = parseAbi([
+  "function weth() view returns (address)",
+  "function ve() view returns (address)",
+  "function np() view returns (address)",
+  "function gov() view returns (address)",
+  "function minimumDuration() view returns (uint256)",
+  "function maximumDuration() view returns (uint256)",
+  "function isValidPaymentToken(address) view returns (bool)",
+  "function feeLimitByTier(uint8) view returns (uint256)",
+  "function feeRateByTier(uint8) view returns (uint256)",
+  "function listingIndexByTokenSeller(uint256,address) view returns (uint256)",
+  "function listingsByToken(uint256,uint256) view returns (uint256 price, uint256 deadline, uint256 snapshotAmount, uint256 snapshotEnd, address creator, address paymentToken, uint8 status, uint8 kind)",
+  "function offeringIndexByTokenBuyer(uint256,address) view returns (uint256)",
+  "function offeringsByToken(uint256,uint256) view returns (uint256 price, uint256 deadline, uint256 snapshotAmount, uint256 snapshotEnd, address creator, address paymentToken, uint8 status, uint8 kind)",
+  "function auctionIndexByTokenSeller(uint256,address) view returns (uint256)",
+  "function auctionsByToken(uint256,uint256) view returns (uint256 reservePrice, uint256 minimumBidIncrement, uint256 deadline, address seller, address paymentToken, address highestBidder, uint256 highestBid, uint8 status)",
+  "function marketOrderStatus((uint256,uint256,uint256,uint256,address,address,uint8,uint8),uint256,uint256,address,uint256) view returns (uint8)",
+  "function auctionStatus((uint256,uint256,uint256,address,address,address,uint256,uint8)) view returns (uint8)",
+  "function createListing(uint256,address,uint256,uint256)",
+  "function delist(uint256)",
+  "function fulfillListing(uint256,address,address,uint256) payable",
+  "function createOffering(uint256,address,uint256,uint256) payable",
+  "function rescind(uint256)",
+  "function fulfillOffering(uint256,address,address,uint256)",
+  "function createAuction(uint256,address,uint256,uint256,uint256)",
+  "function cancelAuction(uint256)",
+  "function auctionBid(uint256,address,uint256) payable",
+  "function settleAuction(uint256,address)",
+  "event ListingCreated(uint256 indexed _tokenId, address indexed _listedBy, address indexed _paymentToken, uint256 _ask, uint256 _deadline)",
+  "event ListingFulfilled(uint256 indexed _tokenId, address indexed _buyer, address indexed _seller, uint256 _ask, uint256 _netPrice, uint256 _fee)",
+  "event Delisted(uint256 indexed _tokenId, address indexed _seller)",
+  "event OfferingCreated(uint256 indexed _tokenId, address indexed _offeredBy, address indexed _paymentToken, uint256 _bid, uint256 _deadline)",
+  "event OfferingFulfilled(uint256 indexed _tokenId, address indexed _buyer, address indexed _seller, uint256 _bid, uint256 _netPrice, uint256 _fee)",
+  "event Rescinded(uint256 indexed _tokenId, address indexed _buyer)",
+  "event AuctionCreated(uint256 indexed _tokenId, address indexed _createdBy, address indexed _paymentToken, uint256 _reservePrice, uint256 _minimumBidIncrement, uint256 _deadline)",
+  "event AuctionCanceled(uint256 indexed _tokenId, address indexed _seller)",
+  "event AuctionBid(uint256 indexed _tokenId, address indexed _seller, address indexed _buyer, uint256 _price)",
+  "event AuctionSettled(uint256 indexed _tokenId, address indexed _seller, uint8 indexed _finalStatus)",
+  "event AuctionSuccessful(uint256 indexed _tokenId, address indexed _seller, address indexed _buyer, uint256 _price, uint256 _fee, uint256 _net)"
+]);
+var marketplaceReadAbi = parseAbi([
+  "function ownerOf(uint256) view returns (address)",
+  "function getApproved(uint256) view returns (address)",
+  "function isApprovedForAll(address,address) view returns (bool)",
+  "function approve(address,uint256)",
+  "function locked(uint256) view returns (int128 amount, uint256 end)",
+  "function allowance(address,address) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)",
+  "function attachedKeyGen(uint256) view returns (address)"
+]);
+
+// src/protocols/evm/continuum-dao/marketplacePlan.ts
+var MARKETPLACE_APPROVE_FALLBACK = 80000n;
+var MARKETPLACE_LISTING_FALLBACK = 280000n;
+var MARKETPLACE_FULFILL_FALLBACK = 450000n;
+var MARKETPLACE_OFFERING_FALLBACK = 320000n;
+var MARKETPLACE_AUCTION_CREATE_FALLBACK = 380000n;
+var MARKETPLACE_BID_FALLBACK = 280000n;
+var MARKETPLACE_SETTLE_FALLBACK = 400000n;
+function same2(a, b) {
+  try {
+    return getAddress(a) === getAddress(b);
+  } catch {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+}
+function isWeth(snap, token) {
+  return same2(token, snap.weth);
+}
+function keyGenOwnsVeCtm(snap, seller) {
+  if (same2(snap.owner, snap.executor)) return true;
+  if (seller && same2(seller, snap.executor)) return true;
+  if (snap.executorOpenListing && same2(snap.owner, snap.executor)) return true;
+  if (snap.executorLiveAuction) return true;
+  return false;
+}
+function assertNotOwn(snap, seller, tokenId) {
+  if (same2(snap.owner, snap.executor) || seller && same2(seller, snap.executor) || snap.executorLiveAuction) {
+    throw new Error(`This KeyGen already owns veCTM #${tokenId.toString()} and cannot buy or bid on it.`);
+  }
+}
+function assertDeadline(snap, deadline) {
+  const min = snap.now + snap.minimumDuration;
+  const max = snap.now + snap.maximumDuration;
+  if (deadline < min || deadline > max) {
+    throw new Error(`Deadline must be between ${min.toString()} and ${max.toString()} (unix seconds).`);
+  }
+}
+function assertPayment(snap) {
+  if (!snap.paymentTokenValid) throw new Error("This payment token is not accepted by the marketplace.");
+}
+function assertNotAttached(snap, tokenId) {
+  if (snap.attachedKeyGen !== zeroAddress) {
+    throw new Error(`veCTM #${tokenId.toString()} has a KeyGen attached.`);
+  }
+}
+function nftApproveStep(snap, tokenId) {
+  if (snap.nftApproved) return null;
+  return {
+    to: snap.votingEscrow,
+    data: encodeFunctionData({
+      abi: marketplaceReadAbi,
+      functionName: "approve",
+      args: [snap.marketplace, tokenId]
+    }),
+    value: 0n,
+    fallbackGas: MARKETPLACE_APPROVE_FALLBACK,
+    evmType: "continuum_dao_marketplace_nft_approve",
+    name: "VotingEscrow.approve",
+    extra: { tokenId: tokenId.toString(), operator: snap.marketplace }
+  };
+}
+function parseApproveAbi() {
+  return [
+    {
+      type: "function",
+      name: "approve",
+      stateMutability: "nonpayable",
+      inputs: [
+        { name: "spender", type: "address" },
+        { name: "amount", type: "uint256" }
+      ],
+      outputs: [{ name: "", type: "bool" }]
+    }
+  ];
+}
+function erc20Approve(snap, token, amount) {
+  if (snap.allowance >= amount) return null;
+  return {
+    to: token,
+    data: encodeFunctionData({
+      abi: parseApproveAbi(),
+      functionName: "approve",
+      args: [snap.marketplace, amount]
+    }),
+    value: 0n,
+    fallbackGas: MARKETPLACE_APPROVE_FALLBACK,
+    evmType: "continuum_dao_marketplace_approve",
+    name: "ERC20.approve",
+    extra: { spender: snap.marketplace, amountWei: amount.toString(), token }
+  };
+}
+function withApprovals(steps) {
+  return steps.filter((s) => s != null);
+}
+function planMarketplaceSteps(input, snap) {
+  const m = snap.marketplace;
+  switch (input.action) {
+    case "createListing": {
+      assertPayment(snap);
+      assertDeadline(snap, input.deadline);
+      if (!same2(snap.owner, snap.executor)) throw new Error("Only the veCTM owner can create a listing.");
+      return withApprovals([
+        nftApproveStep(snap, input.tokenId),
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "createListing",
+            args: [input.tokenId, input.paymentToken, input.askWei, input.deadline]
+          }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_LISTING_FALLBACK,
+          evmType: "continuum_dao_marketplace_create_listing",
+          name: "VotingEscrowMarketplace.createListing",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            paymentToken: input.paymentToken,
+            askWei: input.askWei.toString(),
+            deadline: input.deadline.toString()
+          }
+        }
+      ]);
+    }
+    case "delist": {
+      if (!snap.listing || snap.listing.status !== 1) throw new Error("No open listing for this KeyGen.");
+      return [
+        {
+          to: m,
+          data: encodeFunctionData({ abi: marketplaceAbi, functionName: "delist", args: [input.tokenId] }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_LISTING_FALLBACK,
+          evmType: "continuum_dao_marketplace_delist",
+          name: "VotingEscrowMarketplace.delist",
+          extra: { tokenId: input.tokenId.toString() }
+        }
+      ];
+    }
+    case "fulfillListing": {
+      assertNotOwn(snap, input.seller, input.tokenId);
+      const listing = snap.listing;
+      if (!listing || !same2(listing.creator, input.seller)) throw new Error("No open listing for this seller.");
+      if (!same2(listing.paymentToken, input.paymentToken) || listing.price !== input.priceWei) {
+        throw new Error("Listing price or payment token changed. Refresh and try again.");
+      }
+      const weth = isWeth(snap, listing.paymentToken);
+      return withApprovals([
+        weth ? null : erc20Approve(snap, listing.paymentToken, listing.price),
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "fulfillListing",
+            args: [input.tokenId, input.seller, listing.paymentToken, listing.price]
+          }),
+          value: weth ? listing.price : 0n,
+          fallbackGas: MARKETPLACE_FULFILL_FALLBACK,
+          evmType: "continuum_dao_marketplace_fulfill_listing",
+          name: "VotingEscrowMarketplace.fulfillListing",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            seller: input.seller,
+            paymentToken: listing.paymentToken,
+            priceWei: listing.price.toString(),
+            recipient: snap.executor
+          }
+        }
+      ]);
+    }
+    case "createOffering": {
+      assertNotOwn(snap, void 0, input.tokenId);
+      assertPayment(snap);
+      assertDeadline(snap, input.deadline);
+      const weth = isWeth(snap, input.paymentToken);
+      return withApprovals([
+        erc20Approve(snap, input.paymentToken, input.bidWei),
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "createOffering",
+            args: [input.tokenId, input.paymentToken, input.bidWei, input.deadline]
+          }),
+          value: weth ? input.bidWei : 0n,
+          fallbackGas: MARKETPLACE_OFFERING_FALLBACK,
+          evmType: "continuum_dao_marketplace_create_offering",
+          name: "VotingEscrowMarketplace.createOffering",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            paymentToken: input.paymentToken,
+            bidWei: input.bidWei.toString(),
+            deadline: input.deadline.toString()
+          }
+        }
+      ]);
+    }
+    case "rescind": {
+      if (!snap.offering || snap.offering.status !== 1) throw new Error("No open offering for this KeyGen.");
+      return [
+        {
+          to: m,
+          data: encodeFunctionData({ abi: marketplaceAbi, functionName: "rescind", args: [input.tokenId] }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_OFFERING_FALLBACK,
+          evmType: "continuum_dao_marketplace_rescind",
+          name: "VotingEscrowMarketplace.rescind",
+          extra: { tokenId: input.tokenId.toString() }
+        }
+      ];
+    }
+    case "fulfillOffering": {
+      assertNotAttached(snap, input.tokenId);
+      if (!same2(snap.owner, snap.executor)) throw new Error("Only the veCTM owner can accept an offering.");
+      const offering = snap.offering;
+      if (!offering || !same2(offering.creator, input.buyer)) throw new Error("No open offering for this buyer.");
+      if (!same2(offering.paymentToken, input.paymentToken) || offering.price !== input.priceWei) {
+        throw new Error("Offering price or payment token changed. Refresh and try again.");
+      }
+      return withApprovals([
+        nftApproveStep(snap, input.tokenId),
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "fulfillOffering",
+            args: [input.tokenId, input.buyer, offering.paymentToken, offering.price]
+          }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_FULFILL_FALLBACK,
+          evmType: "continuum_dao_marketplace_fulfill_offering",
+          name: "VotingEscrowMarketplace.fulfillOffering",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            buyer: input.buyer,
+            paymentToken: offering.paymentToken,
+            priceWei: offering.price.toString()
+          }
+        }
+      ]);
+    }
+    case "createAuction": {
+      assertNotAttached(snap, input.tokenId);
+      assertPayment(snap);
+      assertDeadline(snap, input.deadline);
+      if (input.reserveWei <= 0n) throw new Error("Reserve price must be greater than zero.");
+      if (!same2(snap.owner, snap.executor)) throw new Error("Only the veCTM owner can start an auction.");
+      if (snap.executorLiveAuction) throw new Error("A live auction already exists for this token.");
+      return withApprovals([
+        nftApproveStep(snap, input.tokenId),
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "createAuction",
+            args: [input.tokenId, input.paymentToken, input.deadline, input.reserveWei, input.minIncrementWei]
+          }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_AUCTION_CREATE_FALLBACK,
+          evmType: "continuum_dao_marketplace_create_auction",
+          name: "VotingEscrowMarketplace.createAuction",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            paymentToken: input.paymentToken,
+            reserveWei: input.reserveWei.toString(),
+            minIncrementWei: input.minIncrementWei.toString(),
+            deadline: input.deadline.toString()
+          }
+        }
+      ]);
+    }
+    case "cancelAuction": {
+      const auction = snap.auction;
+      if (!auction || !same2(auction.seller, snap.executor)) throw new Error("No auction for this KeyGen.");
+      if (auction.status !== 1) throw new Error("Only a pending auction with no bids can be canceled.");
+      return [
+        {
+          to: m,
+          data: encodeFunctionData({ abi: marketplaceAbi, functionName: "cancelAuction", args: [input.tokenId] }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_AUCTION_CREATE_FALLBACK,
+          evmType: "continuum_dao_marketplace_cancel_auction",
+          name: "VotingEscrowMarketplace.cancelAuction",
+          extra: { tokenId: input.tokenId.toString(), recipient: snap.executor }
+        }
+      ];
+    }
+    case "auctionBid": {
+      assertNotOwn(snap, input.seller, input.tokenId);
+      const auction = snap.auction;
+      if (!auction || !same2(auction.seller, input.seller)) throw new Error("No live auction for this seller.");
+      if (auction.status !== 1 && auction.status !== 2) throw new Error("This auction is not accepting bids.");
+      if (input.priceWei < auction.reservePrice) throw new Error("Bid is below the reserve price.");
+      if (auction.highestBidder !== zeroAddress && input.priceWei < auction.highestBid + auction.minimumBidIncrement) {
+        throw new Error("Bid is below the highest bid plus the minimum increment.");
+      }
+      const weth = isWeth(snap, auction.paymentToken);
+      return withApprovals([
+        weth ? null : erc20Approve(snap, auction.paymentToken, input.priceWei),
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "auctionBid",
+            args: [input.tokenId, input.seller, input.priceWei]
+          }),
+          value: weth ? input.priceWei : 0n,
+          fallbackGas: MARKETPLACE_BID_FALLBACK,
+          evmType: "continuum_dao_marketplace_auction_bid",
+          name: "VotingEscrowMarketplace.auctionBid",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            seller: input.seller,
+            priceWei: input.priceWei.toString(),
+            paymentToken: auction.paymentToken
+          }
+        }
+      ]);
+    }
+    case "settleAuction": {
+      const auction = snap.auction;
+      if (!auction || !same2(auction.seller, input.seller)) throw new Error("Auction not found.");
+      const derived = auction.status === 2 && snap.now >= auction.deadline ? 3 : auction.status === 1 && snap.now >= auction.deadline ? 6 : auction.status;
+      if (derived !== 3 && derived !== 6) throw new Error("This auction is not ready to settle.");
+      const winner = auction.highestBidder;
+      return [
+        {
+          to: m,
+          data: encodeFunctionData({
+            abi: marketplaceAbi,
+            functionName: "settleAuction",
+            args: [input.tokenId, input.seller]
+          }),
+          value: 0n,
+          fallbackGas: MARKETPLACE_SETTLE_FALLBACK,
+          evmType: "continuum_dao_marketplace_settle_auction",
+          name: "VotingEscrowMarketplace.settleAuction",
+          extra: {
+            tokenId: input.tokenId.toString(),
+            seller: input.seller,
+            highestBidder: winner,
+            recipient: derived === 3 ? winner : input.seller
+          }
+        }
+      ];
+    }
+    default:
+      throw new Error("Unknown marketplace action.");
+  }
+}
+
+// src/protocols/evm/continuum-dao/marketplaceChain.ts
+init_defiEvmClient();
+init_constants();
+function marketplacePublicClient(chainId, rpcUrl) {
+  const ch = defineChain({
+    id: chainId,
+    name: "Linea",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return createPublicClient({ chain: ch, transport: defiEvmTransport(rpcUrl) });
+}
+var KNOWN_PAYMENT_TOKENS = [
+  { address: getAddress(CTM_TOKEN_ADDRESS), symbol: "CTM", decimals: 18 },
+  { address: MARKETPLACE_WETH_LINEA_ADDRESS, symbol: "WETH", decimals: 18 },
+  { address: MARKETPLACE_USDC_LINEA_ADDRESS, symbol: "USDC", decimals: 6 }
+];
+function calculateMarketplaceFee(price, lockedAmount, limits, rates) {
+  for (let i = 0; i < 5; i++) {
+    const limit = limits[i] ?? 0n;
+    if (lockedAmount >= limit) {
+      const rateBps = rates[i] ?? 0n;
+      const fee = price * rateBps / 10000n;
+      return {
+        tier: FEE_TIER_NAMES[i] ?? "Blue",
+        tierIndex: i,
+        limit,
+        rateBps,
+        fee,
+        net: price - fee
+      };
+    }
+  }
+  return null;
+}
+async function readMarketplaceConfigFromChain(args) {
+  const marketplace = args.marketplace ?? VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS;
+  const client = marketplacePublicClient(args.chainId, args.rpcUrl);
+  const [weth, ve, gov, np, minimumDuration, maximumDuration] = await Promise.all([
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "weth" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "ve" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "gov" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "np" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "minimumDuration" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "maximumDuration" })
+  ]);
+  const feeLimits = [];
+  const feeRates = [];
+  for (let i = 0; i < 5; i++) {
+    const [limit, rate] = await Promise.all([
+      client.readContract({
+        address: marketplace,
+        abi: marketplaceAbi,
+        functionName: "feeLimitByTier",
+        args: [i]
+      }),
+      client.readContract({
+        address: marketplace,
+        abi: marketplaceAbi,
+        functionName: "feeRateByTier",
+        args: [i]
+      })
+    ]);
+    feeLimits.push(limit);
+    feeRates.push(rate);
+  }
+  const paymentTokens = [];
+  for (const token of KNOWN_PAYMENT_TOKENS) {
+    let isValid = false;
+    try {
+      isValid = await client.readContract({
+        address: marketplace,
+        abi: marketplaceAbi,
+        functionName: "isValidPaymentToken",
+        args: [token.address]
+      });
+    } catch {
+      isValid = false;
+    }
+    if (isValid) paymentTokens.push({ ...token, address: token.address, isValid: true });
+  }
+  return {
+    chainId: args.chainId,
+    marketplace,
+    ve,
+    gov,
+    np,
+    weth,
+    minimumDuration: minimumDuration.toString(),
+    maximumDuration: maximumDuration.toString(),
+    feeLimits: feeLimits.map((n) => n.toString()),
+    feeRates: feeRates.map((n) => n.toString()),
+    feeTiers: FEE_TIER_NAMES.map((name, index) => ({
+      name,
+      index,
+      limit: feeLimits[index].toString(),
+      rateBps: feeRates[index].toString()
+    })),
+    paymentTokens,
+    source: "logs"
+  };
+}
+async function readMarketplaceFeePreviewFromChain(args) {
+  const marketplace = args.marketplace ?? VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS;
+  const ve = args.votingEscrow ?? VOTING_ESCROW_LINEA_ADDRESS;
+  const client = marketplacePublicClient(args.chainId, args.rpcUrl);
+  const locked = await client.readContract({
+    address: ve,
+    abi: marketplaceReadAbi,
+    functionName: "locked",
+    args: [args.tokenId]
+  });
+  const lockedAmount = BigInt(locked[0]);
+  const limits = [];
+  const rates = [];
+  for (let i = 0; i < 5; i++) {
+    limits.push(
+      await client.readContract({
+        address: marketplace,
+        abi: marketplaceAbi,
+        functionName: "feeLimitByTier",
+        args: [i]
+      })
+    );
+    rates.push(
+      await client.readContract({
+        address: marketplace,
+        abi: marketplaceAbi,
+        functionName: "feeRateByTier",
+        args: [i]
+      })
+    );
+  }
+  const fee = calculateMarketplaceFee(args.price, lockedAmount < 0n ? 0n : lockedAmount, limits, rates);
+  if (!fee) throw new Error("Locked CTM is below the minimum fee tier.");
+  return {
+    tokenId: args.tokenId.toString(),
+    lockedAmount: (lockedAmount < 0n ? 0n : lockedAmount).toString(),
+    tier: fee.tier,
+    tierIndex: fee.tierIndex,
+    limit: fee.limit.toString(),
+    rateBps: fee.rateBps.toString(),
+    price: args.price.toString(),
+    fee: fee.fee.toString(),
+    net: fee.net.toString(),
+    source: "logs"
+  };
+}
+async function readOrder(client, marketplace, tokenId, index, kind) {
+  if (index === 0n) return null;
+  const row = kind === "listing" ? await client.readContract({
+    address: marketplace,
+    abi: marketplaceAbi,
+    functionName: "listingsByToken",
+    args: [tokenId, index]
+  }) : await client.readContract({
+    address: marketplace,
+    abi: marketplaceAbi,
+    functionName: "offeringsByToken",
+    args: [tokenId, index]
+  });
+  return {
+    price: row[0],
+    deadline: row[1],
+    snapshotAmount: row[2],
+    snapshotEnd: row[3],
+    creator: row[4],
+    paymentToken: row[5],
+    status: Number(row[6])
+  };
+}
+async function readAuction(client, marketplace, tokenId, index) {
+  if (index === 0n) return null;
+  const row = await client.readContract({
+    address: marketplace,
+    abi: marketplaceAbi,
+    functionName: "auctionsByToken",
+    args: [tokenId, index]
+  });
+  return {
+    reservePrice: row[0],
+    minimumBidIncrement: row[1],
+    deadline: row[2],
+    seller: row[3],
+    paymentToken: row[4],
+    highestBidder: row[5],
+    highestBid: row[6],
+    status: Number(row[7])
+  };
+}
+async function loadMarketplacePlanSnapshot(args) {
+  const marketplace = VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS;
+  const client = marketplacePublicClient(args.chainId, args.rpcUrl);
+  const [weth, ve, np, minimumDuration, maximumDuration, block] = await Promise.all([
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "weth" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "ve" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "np" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "minimumDuration" }),
+    client.readContract({ address: marketplace, abi: marketplaceAbi, functionName: "maximumDuration" }),
+    client.getBlock({ blockTag: "latest" })
+  ]);
+  let owner = zeroAddress;
+  try {
+    owner = await client.readContract({
+      address: ve,
+      abi: marketplaceReadAbi,
+      functionName: "ownerOf",
+      args: [args.tokenId]
+    });
+  } catch {
+    owner = zeroAddress;
+  }
+  const [approved, approvedForAll, attachedKeyGen, listingIndex, offeringIndex, auctionIndex] = await Promise.all([
+    client.readContract({ address: ve, abi: marketplaceReadAbi, functionName: "getApproved", args: [args.tokenId] }).catch(() => zeroAddress),
+    owner === zeroAddress ? Promise.resolve(false) : client.readContract({
+      address: ve,
+      abi: marketplaceReadAbi,
+      functionName: "isApprovedForAll",
+      args: [owner, marketplace]
+    }).catch(() => false),
+    client.readContract({ address: np, abi: marketplaceReadAbi, functionName: "attachedKeyGen", args: [args.tokenId] }).catch(() => zeroAddress),
+    client.readContract({
+      address: marketplace,
+      abi: marketplaceAbi,
+      functionName: "listingIndexByTokenSeller",
+      args: [args.tokenId, args.seller ?? args.executor]
+    }),
+    client.readContract({
+      address: marketplace,
+      abi: marketplaceAbi,
+      functionName: "offeringIndexByTokenBuyer",
+      args: [args.tokenId, args.buyer ?? args.executor]
+    }),
+    client.readContract({
+      address: marketplace,
+      abi: marketplaceAbi,
+      functionName: "auctionIndexByTokenSeller",
+      args: [args.tokenId, args.seller ?? args.executor]
+    })
+  ]);
+  const [listing, offering, auction, executorListingIndex, executorAuctionIndex] = await Promise.all([
+    readOrder(client, marketplace, args.tokenId, listingIndex, "listing"),
+    readOrder(client, marketplace, args.tokenId, offeringIndex, "offering"),
+    readAuction(client, marketplace, args.tokenId, auctionIndex),
+    args.seller && args.seller !== args.executor ? client.readContract({
+      address: marketplace,
+      abi: marketplaceAbi,
+      functionName: "listingIndexByTokenSeller",
+      args: [args.tokenId, args.executor]
+    }) : Promise.resolve(0n),
+    args.seller && args.seller !== args.executor ? client.readContract({
+      address: marketplace,
+      abi: marketplaceAbi,
+      functionName: "auctionIndexByTokenSeller",
+      args: [args.tokenId, args.executor]
+    }) : Promise.resolve(auctionIndex)
+  ]);
+  const executorAuction = executorAuctionIndex === auctionIndex ? auction : await readAuction(client, marketplace, args.tokenId, executorAuctionIndex);
+  const liveAuction = executorAuction != null && (executorAuction.status === 1 || executorAuction.status === 2 || executorAuction.status === 3) && executorAuction.seller.toLowerCase() === args.executor.toLowerCase();
+  let executorOpenListing = false;
+  if (executorListingIndex > 0n) {
+    const row = await readOrder(client, marketplace, args.tokenId, executorListingIndex, "listing");
+    executorOpenListing = row?.status === 1;
+  } else if (!args.seller || args.seller === args.executor) {
+    executorOpenListing = listing?.status === 1 && listing.creator.toLowerCase() === args.executor.toLowerCase();
+  }
+  const paymentToken = args.paymentToken ?? listing?.paymentToken ?? offering?.paymentToken ?? auction?.paymentToken;
+  let paymentTokenValid = true;
+  if (paymentToken) {
+    paymentTokenValid = await client.readContract({
+      address: marketplace,
+      abi: marketplaceAbi,
+      functionName: "isValidPaymentToken",
+      args: [paymentToken]
+    });
+  }
+  const spendToken = paymentToken ?? zeroAddress;
+  const spendFrom = args.buyer && args.buyer !== args.executor ? args.buyer : args.executor;
+  let allowance = 0n;
+  if (spendToken !== zeroAddress && spendToken.toLowerCase() !== weth.toLowerCase()) {
+    allowance = await client.readContract({
+      address: spendToken,
+      abi: marketplaceReadAbi,
+      functionName: "allowance",
+      args: [spendFrom, marketplace]
+    }).catch(() => 0n);
+  } else if (spendToken.toLowerCase() === weth.toLowerCase()) {
+    allowance = await client.readContract({
+      address: spendToken,
+      abi: marketplaceReadAbi,
+      functionName: "allowance",
+      args: [args.executor, marketplace]
+    }).catch(() => 0n);
+  }
+  return {
+    marketplace,
+    votingEscrow: ve,
+    weth,
+    now: block.timestamp,
+    minimumDuration,
+    maximumDuration,
+    executor: args.executor,
+    owner,
+    nftApproved: approvedForAll || approved !== zeroAddress && approved.toLowerCase() === marketplace.toLowerCase(),
+    allowance,
+    attachedKeyGen,
+    paymentTokenValid,
+    executorOpenListing,
+    executorLiveAuction: liveAuction,
+    listing: listing && listing.status === 1 ? listing : listing,
+    offering: offering && offering.status === 1 ? offering : offering,
+    auction
+  };
+}
+init_constants();
+var memoryCache = /* @__PURE__ */ new Map();
+function emptyMarketplaceIndexCache() {
+  return { lastScannedBlock: "0", listings: [], offerings: [], auctions: [] };
+}
+function getMarketplaceIndexMemoryCache(chainId) {
+  return memoryCache.get(chainId) ?? null;
+}
+function setMarketplaceIndexMemoryCache(chainId, cache) {
+  memoryCache.set(chainId, cache);
+}
+function arg(args, key, index) {
+  const value = args[key] ?? args[index];
+  if (typeof value === "bigint") return value.toString();
+  return String(value ?? "");
+}
+function toFoldEvent(log, timestamp) {
+  try {
+    const decoded = decodeEventLog({
+      abi: marketplaceAbi,
+      data: log.data,
+      topics: log.topics
+    });
+    const args = decoded.args;
+    const ref = {
+      tx: log.transactionHash ?? "",
+      block: log.blockNumber != null ? log.blockNumber.toString() : "0",
+      logIndex: log.logIndex ?? 0,
+      timestamp
+    };
+    switch (decoded.eventName) {
+      case "ListingCreated":
+        return {
+          name: "ListingCreated",
+          tokenId: arg(args, "_tokenId", 0),
+          actor: arg(args, "_listedBy", 1),
+          paymentToken: arg(args, "_paymentToken", 2),
+          amount: arg(args, "_ask", 3),
+          deadline: arg(args, "_deadline", 4),
+          ...ref
+        };
+      case "OfferingCreated":
+        return {
+          name: "OfferingCreated",
+          tokenId: arg(args, "_tokenId", 0),
+          actor: arg(args, "_offeredBy", 1),
+          paymentToken: arg(args, "_paymentToken", 2),
+          amount: arg(args, "_bid", 3),
+          deadline: arg(args, "_deadline", 4),
+          ...ref
+        };
+      case "ListingFulfilled":
+        return {
+          name: "ListingFulfilled",
+          tokenId: arg(args, "_tokenId", 0),
+          buyer: arg(args, "_buyer", 1),
+          seller: arg(args, "_seller", 2),
+          price: arg(args, "_ask", 3),
+          net: arg(args, "_netPrice", 4),
+          fee: arg(args, "_fee", 5),
+          ...ref
+        };
+      case "OfferingFulfilled":
+        return {
+          name: "OfferingFulfilled",
+          tokenId: arg(args, "_tokenId", 0),
+          buyer: arg(args, "_buyer", 1),
+          seller: arg(args, "_seller", 2),
+          price: arg(args, "_bid", 3),
+          net: arg(args, "_netPrice", 4),
+          fee: arg(args, "_fee", 5),
+          ...ref
+        };
+      case "Delisted":
+        return { name: "Delisted", tokenId: arg(args, "_tokenId", 0), actor: arg(args, "_seller", 1), ...ref };
+      case "Rescinded":
+        return { name: "Rescinded", tokenId: arg(args, "_tokenId", 0), actor: arg(args, "_buyer", 1), ...ref };
+      case "AuctionCreated":
+        return {
+          name: "AuctionCreated",
+          tokenId: arg(args, "_tokenId", 0),
+          actor: arg(args, "_createdBy", 1),
+          paymentToken: arg(args, "_paymentToken", 2),
+          amount: arg(args, "_reservePrice", 3),
+          minIncrement: arg(args, "_minimumBidIncrement", 4),
+          deadline: arg(args, "_deadline", 5),
+          ...ref
+        };
+      case "AuctionCanceled":
+        return { name: "AuctionCanceled", tokenId: arg(args, "_tokenId", 0), actor: arg(args, "_seller", 1), ...ref };
+      case "AuctionBid":
+        return {
+          name: "AuctionBid",
+          tokenId: arg(args, "_tokenId", 0),
+          seller: arg(args, "_seller", 1),
+          buyer: arg(args, "_buyer", 2),
+          price: arg(args, "_price", 3),
+          ...ref
+        };
+      case "AuctionSettled":
+        return {
+          name: "AuctionSettled",
+          tokenId: arg(args, "_tokenId", 0),
+          seller: arg(args, "_seller", 1),
+          finalStatus: Number(args._finalStatus ?? args[2] ?? 0),
+          ...ref
+        };
+      case "AuctionSuccessful":
+        return {
+          name: "AuctionSuccessful",
+          tokenId: arg(args, "_tokenId", 0),
+          seller: arg(args, "_seller", 1),
+          buyer: arg(args, "_buyer", 2),
+          price: arg(args, "_price", 3),
+          fee: arg(args, "_fee", 4),
+          net: arg(args, "_net", 5),
+          ...ref
+        };
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function getLogsChunked(args) {
+  const logs = [];
+  let chunk = 5000n;
+  let start = args.fromBlock;
+  while (start <= args.toBlock) {
+    const end = start + chunk - 1n > args.toBlock ? args.toBlock : start + chunk - 1n;
+    try {
+      const part = await args.client.getLogs({
+        address: args.address,
+        fromBlock: start,
+        toBlock: end
+      });
+      logs.push(...part);
+      args.onProgress?.(end, args.toBlock);
+      start = end + 1n;
+    } catch (err) {
+      if (chunk <= 200n) throw err;
+      chunk = chunk / 2n < 200n ? 200n : chunk / 2n;
+    }
+  }
+  return logs;
+}
+async function scanMarketplaceLogs(args) {
+  const client = marketplacePublicClient(args.chainId, args.rpcUrl);
+  const head = await client.getBlockNumber();
+  const prior = args.cache ?? getMarketplaceIndexMemoryCache(args.chainId) ?? emptyMarketplaceIndexCache();
+  const scanned = BigInt(prior.lastScannedBlock || "0");
+  const fromBlock = scanned > 0n ? scanned + 1n : VOTING_ESCROW_MARKETPLACE_START_BLOCK;
+  if (fromBlock > head) {
+    const now2 = Number((await client.getBlock({ blockTag: "latest" })).timestamp);
+    const derived2 = applyDerivedStatuses(
+      { listings: prior.listings, offerings: prior.offerings, auctions: prior.auctions },
+      now2
+    );
+    const cache2 = { lastScannedBlock: head.toString(), ...derived2 };
+    setMarketplaceIndexMemoryCache(args.chainId, cache2);
+    return cache2;
+  }
+  const logs = await getLogsChunked({
+    client,
+    address: VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS,
+    fromBlock,
+    toBlock: head,
+    onProgress: args.onProgress
+  });
+  const events = logs.map((log) => toFoldEvent(log)).filter((ev) => ev != null);
+  const folded = foldMarketplaceEvents(events, {
+    listings: prior.listings,
+    offerings: prior.offerings,
+    auctions: prior.auctions
+  });
+  const now = Number((await client.getBlock({ blockTag: "latest" })).timestamp);
+  const derived = applyDerivedStatuses(folded, now);
+  const cache = { lastScannedBlock: head.toString(), ...derived };
+  setMarketplaceIndexMemoryCache(args.chainId, cache);
+  return cache;
+}
+
+// src/protocols/evm/continuum-dao/marketplaceCatalog.ts
+init_constants();
+function apiBase(args) {
+  return (args.apiBase ?? CONTINUUM_DAO_MARKETPLACE_API).replace(/\/$/, "");
+}
+function isOffline(status) {
+  if (status == null || status === 0 || status >= 500) return true;
+  return false;
+}
+async function getJson(url) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return { ok: false, status: res.status, error: new Error(`${url}: ${res.status} ${text}`.trim()) };
+    }
+    return { ok: true, body: await res.json() };
+  } catch (err) {
+    return { ok: false, status: 0, error: err instanceof Error ? err : new Error(String(err)) };
+  }
+}
+function qs(params) {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === "") continue;
+    search.set(key, String(value));
+  }
+  const encoded = search.toString();
+  return encoded ? `?${encoded}` : "";
+}
+async function logsBook(args) {
+  if (!args.rpcUrl?.trim()) throw new Error("Linea RPC is required to index the marketplace while the API is offline.");
+  return scanMarketplaceLogs({
+    chainId: args.chainId ?? CONTINUUM_DAO_LINEA_CHAIN_ID,
+    rpcUrl: args.rpcUrl.trim(),
+    cache: args.cache,
+    onProgress: args.onProgress
+  });
+}
+function matchOrder(row, args, includeInactive) {
+  if (!includeInactive && !isOpenOrder(row)) return false;
+  if (args.tokenId && row.tokenId !== args.tokenId) return false;
+  if (args.paymentToken && row.paymentToken.toLowerCase() !== args.paymentToken.toLowerCase()) return false;
+  if (args.creator && row.creator.toLowerCase() !== args.creator.toLowerCase()) return false;
+  if (args.seller && (row.seller ?? row.creator).toLowerCase() !== args.seller.toLowerCase()) return false;
+  return true;
+}
+function matchAuction(row, args, includeInactive) {
+  if (!includeInactive && !isLiveAuctionStatus(row.derivedStatus)) return false;
+  if (args.tokenId && row.tokenId !== args.tokenId) return false;
+  if (args.paymentToken && row.paymentToken.toLowerCase() !== args.paymentToken.toLowerCase()) return false;
+  if (args.seller && row.seller.toLowerCase() !== args.seller.toLowerCase()) return false;
+  return true;
+}
+function listFrom(items, source) {
+  return { items, nextCursor: null, source };
+}
+async function fetchContinuumDaoMarketplaceConfig(args = {}) {
+  const url = `${apiBase(args)}/marketplace/config`;
+  const res = await getJson(url);
+  if (res.ok && res.body && typeof res.body === "object") {
+    return { ...res.body, source: "api" };
+  }
+  if (!res.ok && !isOffline(res.status)) throw res.error;
+  return readMarketplaceConfigFromChain({
+    chainId: args.chainId ?? CONTINUUM_DAO_LINEA_CHAIN_ID,
+    rpcUrl: args.rpcUrl ?? ""
+  });
+}
+async function fetchContinuumDaoMarketplaceListings(args = {}) {
+  const includeInactive = Boolean(args.includeInactive);
+  const url = `${apiBase(args)}/marketplace/listings${qs({
+    includeInactive,
+    paymentToken: args.paymentToken,
+    tokenId: args.tokenId,
+    creator: args.creator,
+    limit: args.limit ?? 100,
+    cursor: args.cursor,
+    viewer: args.viewer
+  })}`;
+  const res = await getJson(url);
+  if (res.ok) {
+    const body = res.body;
+    return { items: body.items ?? [], nextCursor: body.nextCursor ?? null, source: "api" };
+  }
+  if (args.cursor || !isOffline(res.status)) throw res.error;
+  const book = await logsBook(args);
+  return listFrom(book.listings.filter((row) => matchOrder(row, args, includeInactive)), "logs");
+}
+async function fetchContinuumDaoMarketplaceOfferings(args = {}) {
+  const includeInactive = Boolean(args.includeInactive);
+  const url = `${apiBase(args)}/marketplace/offerings${qs({
+    includeInactive,
+    paymentToken: args.paymentToken,
+    tokenId: args.tokenId,
+    creator: args.creator,
+    limit: args.limit ?? 100,
+    cursor: args.cursor,
+    viewer: args.viewer
+  })}`;
+  const res = await getJson(url);
+  if (res.ok) {
+    const body = res.body;
+    return { items: body.items ?? [], nextCursor: body.nextCursor ?? null, source: "api" };
+  }
+  if (args.cursor || !isOffline(res.status)) throw res.error;
+  const book = await logsBook(args);
+  return listFrom(book.offerings.filter((row) => matchOrder(row, args, includeInactive)), "logs");
+}
+async function fetchContinuumDaoMarketplaceAuctions(args = {}) {
+  const includeInactive = Boolean(args.includeInactive);
+  const url = `${apiBase(args)}/marketplace/auctions${qs({
+    includeInactive,
+    paymentToken: args.paymentToken,
+    tokenId: args.tokenId,
+    seller: args.seller,
+    limit: args.limit ?? 100,
+    cursor: args.cursor,
+    viewer: args.viewer
+  })}`;
+  const res = await getJson(url);
+  if (res.ok) {
+    const body = res.body;
+    return {
+      items: (body.items ?? []).map((row) => ({ ...row, bids: row.bids ?? [] })),
+      nextCursor: body.nextCursor ?? null,
+      source: "api"
+    };
+  }
+  if (args.cursor || !isOffline(res.status)) throw res.error;
+  const book = await logsBook(args);
+  return listFrom(book.auctions.filter((row) => matchAuction(row, args, includeInactive)), "logs");
+}
+async function fetchContinuumDaoMarketplaceToken(args) {
+  const url = `${apiBase(args)}/marketplace/tokens/${encodeURIComponent(args.tokenId)}${qs({ viewer: args.viewer })}`;
+  const res = await getJson(url);
+  if (res.ok && res.body && typeof res.body === "object") {
+    return { ...res.body, source: "api" };
+  }
+  if (!res.ok && !isOffline(res.status)) throw res.error;
+  const book = await logsBook(args);
+  const listings = book.listings.filter((row) => row.tokenId === args.tokenId);
+  const offerings = book.offerings.filter((row) => row.tokenId === args.tokenId);
+  const auctions = book.auctions.filter((row) => row.tokenId === args.tokenId);
+  return {
+    token: { tokenId: args.tokenId },
+    listing: listings.find((row) => isOpenOrder(row)) ?? null,
+    offerings: offerings.filter((row) => isOpenOrder(row)),
+    auction: auctions.find((row) => isLiveAuctionStatus(row.derivedStatus)) ?? null,
+    history: {
+      listings: listings.filter((row) => !isOpenOrder(row)),
+      offerings: offerings.filter((row) => !isOpenOrder(row)),
+      auctions: auctions.filter((row) => !isLiveAuctionStatus(row.derivedStatus))
+    },
+    source: "logs"
+  };
+}
+async function fetchContinuumDaoMarketplaceFeePreview(args) {
+  const url = `${apiBase(args)}/marketplace/fee-preview${qs({ tokenId: args.tokenId, price: args.price })}`;
+  const res = await getJson(url);
+  if (res.ok && res.body && typeof res.body === "object") {
+    return { ...res.body, source: "api" };
+  }
+  if (!res.ok && !isOffline(res.status)) throw res.error;
+  return readMarketplaceFeePreviewFromChain({
+    chainId: args.chainId ?? CONTINUUM_DAO_LINEA_CHAIN_ID,
+    rpcUrl: args.rpcUrl ?? "",
+    tokenId: BigInt(args.tokenId),
+    price: BigInt(args.price)
+  });
+}
+async function fetchContinuumDaoMarketplaceActivity(args) {
+  const url = `${apiBase(args)}/marketplace/users/${encodeURIComponent(args.address)}/activity${qs({ limit: args.limit ?? 50 })}`;
+  const res = await getJson(url);
+  if (res.ok && res.body && typeof res.body === "object") {
+    const body = res.body;
+    return {
+      address: args.address,
+      orders: body.orders ?? [],
+      auctions: (body.auctions ?? []).map((row) => ({ ...row, bids: row.bids ?? [] })),
+      source: "api"
+    };
+  }
+  if (!res.ok && !isOffline(res.status)) throw res.error;
+  const book = await logsBook(args);
+  const address = args.address.toLowerCase();
+  const orders = [...book.listings, ...book.offerings].filter((row) => {
+    return row.creator.toLowerCase() === address || (row.counterparty ?? "").toLowerCase() === address || (row.seller ?? "").toLowerCase() === address || (row.buyer ?? "").toLowerCase() === address;
+  });
+  const auctions = book.auctions.filter((row) => {
+    return row.seller.toLowerCase() === address || (row.buyer ?? "").toLowerCase() === address || (row.highestBidder ?? "").toLowerCase() === address || row.bids.some((bid) => bid.bidder.toLowerCase() === address);
+  });
+  return { address: args.address, orders, auctions, source: "logs" };
+}
+
+// src/protocols/evm/continuum-dao/marketplaceSearch.ts
+init_constants();
+var LOCKED_ABI = [parseAbiItem("function locked(uint256 tokenId) view returns (int128 amount, uint256 end)")];
+var MONTH_SECONDS = 30 * 24 * 60 * 60;
+var PAGE_SIZE = 100;
+var MAX_PAGES = 20;
+var DEFAULT_LIMIT = 10;
+var MAX_LIMIT = 25;
+var DEFAULT_DIRECTION = {
+  pricePerLockedCtm: "asc",
+  price: "asc",
+  locked: "desc",
+  unlock: "asc",
+  deadline: "asc"
+};
+function same3(a, b) {
+  if (!a || !b) return false;
+  try {
+    return getAddress(a) === getAddress(b);
+  } catch {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+}
+function attachedKey(keygen, protocolStatus) {
+  if (protocolStatus === "KeyGenAttached") return true;
+  const value = (keygen ?? "").trim().toLowerCase();
+  return Boolean(value && value !== "0" && !/^0x0+$/.test(value));
+}
+function asBig(value) {
+  try {
+    return BigInt(value || "0");
+  } catch {
+    return 0n;
+  }
+}
+function parseCtm(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return null;
+  return parseUnits(trimmed, 18);
+}
+function parseTime(raw) {
+  const trimmed = raw?.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) {
+    const n = Number(trimmed);
+    if (!Number.isFinite(n)) throw new Error("Unlock bound must be an ISO date or unix seconds.");
+    return n > 1e12 ? Math.floor(n / 1e3) : n;
+  }
+  const ms = Date.parse(trimmed);
+  if (Number.isNaN(ms)) throw new Error("Unlock bound must be an ISO date or unix seconds.");
+  return Math.floor(ms / 1e3);
+}
+function paymentMeta(address) {
+  const lower = address.toLowerCase();
+  if (lower === MARKETPLACE_USDC_LINEA_ADDRESS.toLowerCase()) return { symbol: "USDC", decimals: 6 };
+  if (lower === MARKETPLACE_WETH_LINEA_ADDRESS.toLowerCase()) return { symbol: "WETH", decimals: 18 };
+  if (lower === CTM_TOKEN_ADDRESS.toLowerCase()) return { symbol: "CTM", decimals: 18 };
+  return { symbol: "token", decimals: 18 };
+}
+function trimDecimal(value) {
+  return value.replace(/(\.\d*?[1-9])0+$/, "$1").replace(/\.0+$/, "");
+}
+function humanAmount(wei, decimals) {
+  return trimDecimal(formatUnits(wei, decimals));
+}
+function positive(value) {
+  const trimmed = (value ?? "").trim();
+  return trimmed && trimmed !== "0" ? trimmed : "";
+}
+function unlockUnixFrom(row) {
+  const iso2 = positive(row.unlockTimeAt);
+  if (iso2) {
+    const ms = Date.parse(iso2);
+    if (!Number.isNaN(ms)) return Math.floor(ms / 1e3);
+  }
+  const unix = positive(row.unlockTime) || positive(row.snapshotEnd);
+  return unix ? Number(unix) : 0;
+}
+function lockedFrom(row) {
+  return asBig(positive(row.lockedCTM) || positive(row.currentLockedAmount) || positive(row.snapshotAmount));
+}
+function listingCandidate(row) {
+  const attached = attachedKey(row.keygen, row.protocolStatus);
+  const open = row.protocolStatus === "Open" || row.storedStatus === "Open";
+  return {
+    kind: "listing",
+    tokenId: row.tokenId,
+    onchainIndex: row.onchainIndex,
+    seller: row.seller ?? row.creator,
+    paymentToken: row.paymentToken,
+    price: asBig(row.price),
+    priceBasis: "ask",
+    locked: lockedFrom(row),
+    unlockUnix: unlockUnixFrom(row),
+    deadlineUnix: Number(row.deadlineUnix || "0") || 0,
+    attached,
+    fillable: open && !attached,
+    protocolStatus: row.protocolStatus,
+    storedStatus: row.storedStatus,
+    keygen: row.keygen
+  };
+}
+function auctionCandidate(row) {
+  const attached = attachedKey(row.keygen, row.storedStatus);
+  const bid = asBig(row.highestBid);
+  const reserve = asBig(row.reservePrice);
+  const live = row.derivedStatus === "Pending" || row.derivedStatus === "Active";
+  return {
+    kind: "auction",
+    tokenId: row.tokenId,
+    onchainIndex: row.onchainIndex,
+    seller: row.seller,
+    paymentToken: row.paymentToken,
+    price: bid > 0n ? bid : reserve,
+    priceBasis: bid > 0n ? "highestBid" : "reserve",
+    locked: lockedFrom(row),
+    unlockUnix: unlockUnixFrom(row),
+    deadlineUnix: Number(row.deadlineUnix || "0") || 0,
+    attached,
+    fillable: live && !attached,
+    protocolStatus: row.derivedStatus,
+    storedStatus: row.storedStatus,
+    keygen: row.keygen
+  };
+}
+function applyLock(row, lock) {
+  if (row.locked > 0n && row.unlockUnix > 0) return row;
+  if (!lock) return row;
+  return {
+    ...row,
+    locked: row.locked > 0n ? row.locked : lock.amount,
+    unlockUnix: row.unlockUnix > 0 ? row.unlockUnix : lock.end
+  };
+}
+function rankMarketplaceSearchHits(rows, query, nowUnix = Math.floor(Date.now() / 1e3)) {
+  const sort = query.sort ?? "pricePerLockedCtm";
+  const direction = query.sortDirection ?? DEFAULT_DIRECTION[sort];
+  const minLocked = parseCtm(query.minLockedCtm);
+  const maxLocked = parseCtm(query.maxLockedCtm);
+  const unlockAfter = parseTime(query.unlockAfter);
+  const unlockBefore = parseTime(query.unlockBefore);
+  const monthCap = query.maxUnlockMonths != null && Number.isFinite(query.maxUnlockMonths) ? nowUnix + Math.floor(query.maxUnlockMonths * MONTH_SECONDS) : null;
+  const executor = query.executor?.trim();
+  const excludeOwned = query.excludeOwned !== false && Boolean(executor);
+  let matched = rows.filter((row) => {
+    if (query.paymentToken && !same3(row.paymentToken, query.paymentToken)) return false;
+    if (excludeOwned && same3(row.seller, executor)) return false;
+    if (minLocked != null && row.locked < minLocked) return false;
+    if (maxLocked != null && row.locked > maxLocked) return false;
+    if (unlockAfter != null && row.unlockUnix < unlockAfter) return false;
+    if (unlockBefore != null && (row.unlockUnix <= 0 || row.unlockUnix > unlockBefore)) return false;
+    if (monthCap != null && (row.unlockUnix <= nowUnix || row.unlockUnix > monthCap)) return false;
+    return true;
+  });
+  const priceSort = sort === "price" || sort === "pricePerLockedCtm";
+  if (priceSort && !query.paymentToken) {
+    const tokens = new Set(matched.map((row) => row.paymentToken.toLowerCase()));
+    if (tokens.size > 1) {
+      const symbols = [...tokens].map((token) => paymentMeta(token).symbol).join(", ");
+      throw new Error(`Pass paymentToken to rank by price. These rows use ${symbols}.`);
+    }
+  }
+  const asc = direction === "asc";
+  const key = (row) => {
+    if (sort === "locked") return row.locked;
+    if (sort === "unlock") return BigInt(row.unlockUnix || 0);
+    if (sort === "deadline") return BigInt(row.deadlineUnix || 0);
+    if (sort === "pricePerLockedCtm") return row.locked > 0n ? row.price * 10n ** 18n / row.locked : 2n ** 255n - 1n;
+    return row.price;
+  };
+  matched = [...matched].sort((a, b) => {
+    if (a.fillable !== b.fillable) return a.fillable ? -1 : 1;
+    if (sort === "pricePerLockedCtm" && a.locked <= 0n !== b.locked <= 0n) return a.locked <= 0n ? 1 : -1;
+    const cmp = key(a) === key(b) ? 0 : key(a) < key(b) ? -1 : 1;
+    if (cmp !== 0) return asc ? cmp : -cmp;
+    return a.tokenId.localeCompare(b.tokenId);
+  });
+  const limit = Math.min(MAX_LIMIT, Math.max(1, query.limit ?? DEFAULT_LIMIT));
+  return matched.slice(0, limit).map((row) => toHit(row, nowUnix));
+}
+function toHit(row, nowUnix) {
+  const meta4 = paymentMeta(row.paymentToken);
+  const perCtm = row.locked > 0n ? row.price * 10n ** 18n / row.locked : 0n;
+  const months = row.unlockUnix > nowUnix ? ((row.unlockUnix - nowUnix) / MONTH_SECONDS).toFixed(1) : row.unlockUnix > 0 ? "0" : "";
+  return {
+    kind: row.kind,
+    tokenId: row.tokenId,
+    onchainIndex: row.onchainIndex,
+    seller: row.seller,
+    paymentToken: row.paymentToken,
+    paymentSymbol: meta4.symbol,
+    price: row.price.toString(),
+    priceHuman: humanAmount(row.price, meta4.decimals),
+    priceBasis: row.priceBasis,
+    lockedCtm: row.locked.toString(),
+    lockedCtmHuman: humanAmount(row.locked, 18),
+    unlockAt: row.unlockUnix > 0 ? new Date(row.unlockUnix * 1e3).toISOString() : "",
+    monthsToUnlock: months,
+    pricePerLockedCtm: row.locked > 0n ? humanAmount(perCtm, meta4.decimals) : "",
+    deadlineAt: row.deadlineUnix > 0 ? new Date(row.deadlineUnix * 1e3).toISOString() : "",
+    attached: row.attached,
+    fillable: row.fillable
+  };
+}
+async function fillMissingLocks(rows, rpcUrl, chainId) {
+  const missing = [...new Set(rows.filter((row) => row.locked <= 0n || row.unlockUnix <= 0).map((row) => row.tokenId))];
+  if (missing.length === 0 || !rpcUrl?.trim()) return rows;
+  const client = marketplacePublicClient(chainId, rpcUrl.trim());
+  const locks = /* @__PURE__ */ new Map();
+  for (let i = 0; i < missing.length; i += 40) {
+    const chunk = missing.slice(i, i + 40);
+    const results = await client.multicall({
+      contracts: chunk.map((id) => ({
+        address: VOTING_ESCROW_LINEA_ADDRESS,
+        abi: LOCKED_ABI,
+        functionName: "locked",
+        args: [BigInt(id)]
+      })),
+      allowFailure: true
+    });
+    results.forEach((result, index) => {
+      if (result.status !== "success" || !result.result) return;
+      const [amount, end] = result.result;
+      const id = chunk[index];
+      if (!id) return;
+      locks.set(id, { amount: amount < 0n ? 0n : amount, end: Number(end) });
+    });
+  }
+  return rows.map((row) => applyLock(row, locks.get(row.tokenId)));
+}
+async function collectKind(kind, args) {
+  const rows = [];
+  let cursor;
+  let scanned = 0;
+  let source = "api";
+  let truncated = false;
+  for (let page = 0; page < MAX_PAGES; page += 1) {
+    const query = { ...args, includeInactive: false, limit: PAGE_SIZE, cursor };
+    const res = kind === "listing" ? await fetchContinuumDaoMarketplaceListings(query) : await fetchContinuumDaoMarketplaceAuctions(query);
+    source = res.source;
+    scanned += res.items.length;
+    for (const item of res.items) {
+      rows.push(kind === "listing" ? listingCandidate(item) : auctionCandidate(item));
+    }
+    if (res.source === "logs" || !res.nextCursor) return { rows, scanned, truncated, source };
+    cursor = res.nextCursor;
+  }
+  truncated = true;
+  return { rows, scanned, truncated, source };
+}
+async function searchContinuumDaoMarketplace(args = {}) {
+  const kind = args.kind ?? "listing";
+  const chainId = args.chainId ?? CONTINUUM_DAO_LINEA_CHAIN_ID;
+  const parts = await Promise.all([
+    kind !== "auction" ? collectKind("listing", args) : Promise.resolve(null),
+    kind !== "listing" ? collectKind("auction", args) : Promise.resolve(null)
+  ]);
+  const collected = parts.flatMap((part) => part?.rows ?? []);
+  const withLocks = await fillMissingLocks(collected, args.rpcUrl, chainId);
+  const sort = args.sort ?? "pricePerLockedCtm";
+  const items = rankMarketplaceSearchHits(withLocks, args);
+  return {
+    sort,
+    sortDirection: args.sortDirection ?? DEFAULT_DIRECTION[sort],
+    paymentToken: args.paymentToken ?? null,
+    scanned: parts.reduce((sum, part) => sum + (part?.scanned ?? 0), 0),
+    truncated: parts.some((part) => part?.truncated),
+    items,
+    source: parts.some((part) => part?.source === "logs") ? "logs" : "api"
+  };
+}
+
+// src/protocols/evm/continuum-dao/marketplaceFeeAlternative.ts
+init_constants();
+var PAGE_SIZE2 = 100;
+var MAX_PAGES2 = 20;
+var feeAbi = parseAbi([
+  "function veCtmThresholdPower() view returns (uint256)",
+  "function getActiveRates() view returns (uint256 monthlyFee, uint256 freeSignaturesPerMonth, uint256 overageFeePerSignature)",
+  "function FEE_TOKEN() view returns (address)",
+  "function ctmPerFeeToken() view returns (uint256)",
+  "function locked(uint256 tokenId) view returns (int128 amount, uint256 end)",
+  "function balanceOfNFT(uint256 tokenId) view returns (uint256)"
+]);
+function trimDecimal2(value) {
+  return value.replace(/(\.\d*?[1-9])0+$/, "$1").replace(/\.0+$/, "");
+}
+function human(wei, decimals) {
+  return trimDecimal2(formatUnits(wei, decimals));
+}
+function paymentMeta2(address) {
+  const lower = address.toLowerCase();
+  if (lower === MARKETPLACE_USDC_LINEA_ADDRESS.toLowerCase()) return { symbol: "USDC", decimals: 6 };
+  if (lower === MARKETPLACE_WETH_LINEA_ADDRESS.toLowerCase()) return { symbol: "WETH", decimals: 18 };
+  if (lower === CTM_TOKEN_ADDRESS.toLowerCase()) return { symbol: "CTM", decimals: 18 };
+  return { symbol: "token", decimals: 18 };
+}
+function monthsOfFees(price, monthly) {
+  if (monthly <= 0n || price < 0n) return null;
+  const tenths = price * 10n / monthly;
+  const whole = tenths / 10n;
+  const frac = tenths % 10n;
+  return frac === 0n ? whole.toString() : `${whole}.${frac}`;
+}
+function votingPowerAboveUntil(args) {
+  if (args.votingPower <= args.threshold) return null;
+  if (args.unlockUnix <= args.nowUnix) return null;
+  if (args.threshold <= 0n) return args.unlockUnix;
+  const remaining = BigInt(args.unlockUnix - args.nowUnix);
+  const drop = remaining * args.threshold / args.votingPower;
+  return args.unlockUnix - Number(drop);
+}
+function pickFeeAlternativeExample(rows, preferredToken) {
+  const fillable = rows.filter((row) => row.fillable && row.locked > 0n && row.votingPower > 0n);
+  const preferred = preferredToken ? fillable.filter((row) => row.paymentToken.toLowerCase() === preferredToken.toLowerCase()) : [];
+  const pool = preferred.length > 0 ? preferred : fillable;
+  const perCtm = (row) => row.price * 10n ** 18n / row.locked;
+  return [...pool].sort((a, b) => {
+    const left = perCtm(a);
+    const right = perCtm(b);
+    if (left === right) return a.tokenId.localeCompare(b.tokenId);
+    return left < right ? -1 : 1;
+  })[0] ?? null;
+}
+function iso(unix) {
+  return unix > 0 ? new Date(unix * 1e3).toISOString() : "";
+}
+function buildFeeAlternativeSummary(args) {
+  const fee = `${args.monthlyFeeHuman} ${args.monthlyFeeSymbol}`;
+  const year = `${args.annualFeeHuman} ${args.monthlyFeeSymbol} (${args.annualFeeCtmHuman} CTM)`;
+  const lead = `Paying this month is ${fee}. A year for one KeyGen is ${year}. As an alternative, buy a veCTM and attach it. Locked CTM and voting power both have to be above ${args.thresholdHuman}. One attached veCTM waives the monthly fee for KeyGens in that group, and VPN follows a qualifying group on the node. Voting power decays, so a lock sitting on the line can miss a later month.`;
+  if (!args.example) {
+    return `${lead} No live direct listing is above that threshold right now.`;
+  }
+  const row = args.example;
+  const compare = row.monthsOfFees ? ` That ask is about ${row.monthsOfFees} months of fees. The ask buys a lock you still hold; the monthly fee is spent.` : ` The listing is priced in ${row.paymentSymbol}, which is a different token from the fee.`;
+  return `${lead} Example direct listing #${row.tokenId}: ${row.priceHuman} ${row.paymentSymbol} for ${row.lockedCtmHuman} CTM, unlocks ${row.unlockAt}. Voting power stays above the threshold until ${row.staysAboveThresholdUntil}.${compare}`;
+}
+async function readFeeSide(rpcUrl, chainId) {
+  const client = marketplacePublicClient(chainId, rpcUrl);
+  const wallet = MULTISIGN_AGENT_WALLET_LINEA_ADDRESS;
+  const [threshold, rates, feeToken, ctmPerFeeToken] = await Promise.all([
+    client.readContract({ address: wallet, abi: feeAbi, functionName: "veCtmThresholdPower" }),
+    client.readContract({ address: wallet, abi: feeAbi, functionName: "getActiveRates" }),
+    client.readContract({ address: wallet, abi: feeAbi, functionName: "FEE_TOKEN" }),
+    client.readContract({ address: wallet, abi: feeAbi, functionName: "ctmPerFeeToken" })
+  ]);
+  const monthlyFee = rates[0];
+  const monthlyFeeCtm = ctmPerFeeToken > 0n ? monthlyFee * ctmPerFeeToken / CTM_FEE_RATE_SCALE : 0n;
+  return { threshold, monthlyFee, monthlyFeeCtm, feeToken: getAddress(feeToken) };
+}
+async function collectListings(args) {
+  const rows = [];
+  let cursor;
+  let scanned = 0;
+  let source = "api";
+  let truncated = false;
+  for (let page = 0; page < MAX_PAGES2; page += 1) {
+    const res = await fetchContinuumDaoMarketplaceListings({ ...args, includeInactive: false, limit: PAGE_SIZE2, cursor });
+    source = res.source;
+    scanned += res.items.length;
+    rows.push(...res.items.map(listingCandidate));
+    if (res.source === "logs" || !res.nextCursor) return { rows, scanned, truncated, source };
+    cursor = res.nextCursor;
+  }
+  return { rows, scanned, truncated: true, source };
+}
+async function fillLocks(rows, rpcUrl, chainId) {
+  const missing = [...new Set(rows.filter((row) => row.locked <= 0n || row.unlockUnix <= 0).map((row) => row.tokenId))];
+  if (missing.length === 0) return rows;
+  const client = marketplacePublicClient(chainId, rpcUrl);
+  const locks = /* @__PURE__ */ new Map();
+  for (let i = 0; i < missing.length; i += 40) {
+    const chunk = missing.slice(i, i + 40);
+    const results = await client.multicall({
+      contracts: chunk.map((id) => ({
+        address: VOTING_ESCROW_LINEA_ADDRESS,
+        abi: feeAbi,
+        functionName: "locked",
+        args: [BigInt(id)]
+      })),
+      allowFailure: true
+    });
+    results.forEach((result, index) => {
+      if (result.status !== "success" || !result.result) return;
+      const id = chunk[index];
+      if (!id) return;
+      const [amount, end] = result.result;
+      locks.set(id, { amount: amount < 0n ? 0n : amount, end: Number(end) });
+    });
+  }
+  return rows.map((row) => {
+    const lock = locks.get(row.tokenId);
+    if (!lock) return row;
+    return { ...row, locked: row.locked > 0n ? row.locked : lock.amount, unlockUnix: row.unlockUnix > 0 ? row.unlockUnix : lock.end };
+  });
+}
+async function readVotingPower(tokenIds, rpcUrl, chainId) {
+  const client = marketplacePublicClient(chainId, rpcUrl);
+  const power = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tokenIds.length; i += 40) {
+    const chunk = tokenIds.slice(i, i + 40);
+    const results = await client.multicall({
+      contracts: chunk.map((id) => ({
+        address: VOTING_ESCROW_LINEA_ADDRESS,
+        abi: feeAbi,
+        functionName: "balanceOfNFT",
+        args: [BigInt(id)]
+      })),
+      allowFailure: true
+    });
+    results.forEach((result, index) => {
+      const id = chunk[index];
+      if (!id || result.status !== "success") return;
+      power.set(id, result.result);
+    });
+  }
+  return power;
+}
+async function quoteContinuumDaoMarketplaceFeeAlternative(args) {
+  const rpcUrl = args.rpcUrl?.trim();
+  if (!rpcUrl) throw new Error("Linea RPC is required to read the monthly fee and veCTM threshold.");
+  const chainId = args.chainId ?? CONTINUUM_DAO_LINEA_CHAIN_ID;
+  const payment = args.payment ?? "fee";
+  const nowUnix = Math.floor(Date.now() / 1e3);
+  const fee = await readFeeSide(rpcUrl, chainId);
+  const collected = await collectListings(args);
+  const withLocks = await fillLocks(collected.rows, rpcUrl, chainId);
+  const executor = args.executor?.trim();
+  const visible = executor ? withLocks.filter((row) => {
+    try {
+      return getAddress(row.seller) !== getAddress(executor);
+    } catch {
+      return row.seller.toLowerCase() !== executor.toLowerCase();
+    }
+  }) : withLocks;
+  const aboveLock = visible.filter((row) => row.fillable && row.locked > fee.threshold);
+  const power = await readVotingPower(aboveLock.map((row) => row.tokenId), rpcUrl, chainId);
+  const qualified = aboveLock.flatMap((row) => {
+    const votingPower = power.get(row.tokenId);
+    if (votingPower == null || votingPower <= fee.threshold) return [];
+    return [
+      {
+        tokenId: row.tokenId,
+        paymentToken: row.paymentToken,
+        price: row.price,
+        locked: row.locked,
+        unlockUnix: row.unlockUnix,
+        votingPower,
+        fillable: row.fillable
+      }
+    ];
+  });
+  const preferred = payment === "ctm" ? CTM_TOKEN_ADDRESS : fee.feeToken;
+  const picked = pickFeeAlternativeExample(qualified, preferred);
+  const feeMeta = paymentMeta2(fee.feeToken);
+  const example = picked ? toExample(picked, fee, payment, preferred, nowUnix) : null;
+  const quoteBase = {
+    payment,
+    threshold: fee.threshold.toString(),
+    thresholdHuman: human(fee.threshold, 18),
+    monthlyFee: fee.monthlyFee.toString(),
+    monthlyFeeHuman: human(fee.monthlyFee, feeMeta.decimals),
+    monthlyFeeSymbol: feeMeta.symbol,
+    annualFee: (fee.monthlyFee * 12n).toString(),
+    annualFeeHuman: human(fee.monthlyFee * 12n, feeMeta.decimals),
+    monthlyFeeCtm: fee.monthlyFeeCtm.toString(),
+    monthlyFeeCtmHuman: human(fee.monthlyFeeCtm, 18),
+    annualFeeCtm: (fee.monthlyFeeCtm * 12n).toString(),
+    annualFeeCtmHuman: human(fee.monthlyFeeCtm * 12n, 18),
+    feeToken: fee.feeToken,
+    example,
+    scanned: collected.scanned,
+    truncated: collected.truncated,
+    source: collected.source
+  };
+  return {
+    ...quoteBase,
+    summary: buildFeeAlternativeSummary({
+      thresholdHuman: quoteBase.thresholdHuman,
+      monthlyFeeHuman: quoteBase.monthlyFeeHuman,
+      monthlyFeeSymbol: quoteBase.monthlyFeeSymbol,
+      annualFeeHuman: quoteBase.annualFeeHuman,
+      annualFeeCtmHuman: quoteBase.annualFeeCtmHuman,
+      example
+    })
+  };
+}
+function toExample(row, fee, payment, preferred, nowUnix) {
+  const meta4 = paymentMeta2(row.paymentToken);
+  const same5 = row.paymentToken.toLowerCase() === preferred.toLowerCase();
+  const monthly = payment === "ctm" ? fee.monthlyFeeCtm : fee.monthlyFee;
+  const until = votingPowerAboveUntil({
+    votingPower: row.votingPower,
+    threshold: fee.threshold,
+    nowUnix,
+    unlockUnix: row.unlockUnix
+  });
+  const perCtm = row.price * 10n ** 18n / row.locked;
+  return {
+    tokenId: row.tokenId,
+    price: row.price.toString(),
+    priceHuman: human(row.price, meta4.decimals),
+    paymentToken: row.paymentToken,
+    paymentSymbol: meta4.symbol,
+    lockedCtm: row.locked.toString(),
+    lockedCtmHuman: human(row.locked, 18),
+    unlockAt: iso(row.unlockUnix),
+    votingPower: row.votingPower.toString(),
+    votingPowerHuman: human(row.votingPower, 18),
+    staysAboveThresholdUntil: iso(until ?? 0),
+    pricePerLockedCtm: human(perCtm, meta4.decimals),
+    monthsOfFees: same5 ? monthsOfFees(row.price, monthly) : null,
+    comparedTo: same5 ? payment : null,
+    fillable: row.fillable
+  };
+}
+
+// src/protocols/evm/continuum-dao/marketplaceMultisign.ts
+init_buildBatch();
+init_constants();
+function parseWei(raw, label) {
+  const value = typeof raw === "bigint" ? raw : BigInt(String(raw).trim());
+  if (value < 0n) throw new Error(`${label} must be zero or greater.`);
+  return value;
+}
+function parseTokenId2(raw) {
+  const id = typeof raw === "bigint" ? raw : BigInt(String(raw).trim());
+  if (id <= 0n) throw new Error("veCTM token id must be greater than zero.");
+  return id;
+}
+function requireLinea(chainId) {
+  if (chainId !== CONTINUUM_DAO_LINEA_CHAIN_ID) {
+    throw new Error("veCTM marketplace actions are Linea mainnet only.");
+  }
+}
+function meta3(step, chainId, gasLimit) {
+  return {
+    destinationAddress: step.to,
+    signatureText: continuumDaoSignatureText({ name: step.name, ...step.extra }, chainId),
+    evm: {
+      type: step.evmType,
+      version: 1,
+      chainId: String(chainId),
+      protocolId: CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID
+    },
+    continuumDaoMarketplace: { ...step.extra, name: step.name, gas: { baseGasUnits: gasLimit.toString() } }
+  };
+}
+async function finalize2(steps, args, purposeSuffix) {
+  const evmSteps = steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: s.fallbackGas
+  }));
+  const firstDataNo0x = evmSteps[0].data.startsWith("0x") ? evmSteps[0].data.slice(2) : evmSteps[0].data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl.trim(),
+      executorAddress: args.executorAddress,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: steps[0].to,
+    buildBatchMeta: ({ index, gasLimit }) => meta3(steps[index], args.chainId, gasLimit)
+  });
+}
+async function build(args, input, purposeSuffix, snapshotArgs) {
+  requireLinea(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const tokenId = "tokenId" in input ? input.tokenId : 0n;
+  const snap = await loadMarketplacePlanSnapshot({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    executor,
+    tokenId,
+    ...snapshotArgs
+  });
+  const steps = planMarketplaceSteps(input, snap);
+  return finalize2(steps, args, purposeSuffix);
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceCreateListing(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const paymentToken = getAddress(args.paymentToken);
+  const askWei = parseWei(args.askWei, "Ask");
+  const deadline = parseWei(args.deadline, "Deadline");
+  return build(
+    args,
+    { action: "createListing", tokenId, paymentToken, askWei, deadline },
+    `ContinuumDAO marketplace: list veCTM #${tokenId.toString()}.`,
+    { paymentToken }
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceDelist(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  return build(args, { action: "delist", tokenId }, `ContinuumDAO marketplace: delist veCTM #${tokenId.toString()}.`, {});
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceFulfillListing(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const seller = getAddress(args.seller);
+  const paymentToken = getAddress(args.paymentToken);
+  const priceWei = parseWei(args.priceWei, "Price");
+  return build(
+    args,
+    { action: "fulfillListing", tokenId, seller, paymentToken, priceWei },
+    `ContinuumDAO marketplace: buy veCTM #${tokenId.toString()}.`,
+    { seller, paymentToken }
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceCreateOffering(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const paymentToken = getAddress(args.paymentToken);
+  const bidWei = parseWei(args.bidWei, "Bid");
+  const deadline = parseWei(args.deadline, "Deadline");
+  return build(
+    args,
+    { action: "createOffering", tokenId, paymentToken, bidWei, deadline },
+    `ContinuumDAO marketplace: offer on veCTM #${tokenId.toString()}.`,
+    { paymentToken }
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceRescind(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  return build(
+    args,
+    { action: "rescind", tokenId },
+    `ContinuumDAO marketplace: rescind offer on veCTM #${tokenId.toString()}.`,
+    {}
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceFulfillOffering(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const buyer = getAddress(args.buyer);
+  const paymentToken = getAddress(args.paymentToken);
+  const priceWei = parseWei(args.priceWei, "Price");
+  return build(
+    args,
+    { action: "fulfillOffering", tokenId, buyer, paymentToken, priceWei },
+    `ContinuumDAO marketplace: accept offer on veCTM #${tokenId.toString()}.`,
+    { buyer, paymentToken }
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceCreateAuction(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const paymentToken = getAddress(args.paymentToken);
+  const deadline = parseWei(args.deadline, "Deadline");
+  const reserveWei = parseWei(args.reserveWei, "Reserve");
+  const minIncrementWei = parseWei(args.minIncrementWei, "Minimum increment");
+  return build(
+    args,
+    { action: "createAuction", tokenId, paymentToken, deadline, reserveWei, minIncrementWei },
+    `ContinuumDAO marketplace: auction veCTM #${tokenId.toString()}.`,
+    { paymentToken }
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceCancelAuction(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  return build(
+    args,
+    { action: "cancelAuction", tokenId },
+    `ContinuumDAO marketplace: cancel auction for veCTM #${tokenId.toString()}.`,
+    {}
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceAuctionBid(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const seller = getAddress(args.seller);
+  const priceWei = parseWei(args.priceWei, "Bid");
+  return build(
+    args,
+    { action: "auctionBid", tokenId, seller, priceWei },
+    `ContinuumDAO marketplace: bid on veCTM #${tokenId.toString()}.`,
+    { seller }
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoMarketplaceSettleAuction(args) {
+  const tokenId = parseTokenId2(args.tokenId);
+  const seller = getAddress(args.seller);
+  return build(
+    args,
+    { action: "settleAuction", tokenId, seller },
+    `ContinuumDAO marketplace: settle auction for veCTM #${tokenId.toString()}.`,
+    { seller }
+  );
+}
+function parseExtra(detail) {
+  const raw = detail?.ExtraJSON ?? detail?.extraJSON;
+  if (raw == null) return null;
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function same4(a, b) {
+  try {
+    return getAddress(a) === getAddress(b);
+  } catch {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+}
+function marketplaceVeCtmReceivedBy(detail, executor) {
+  const extra = parseExtra(detail);
+  const batch = extra?.batchMeta;
+  if (!Array.isArray(batch) || !executor.trim()) return null;
+  for (const entry of batch) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const row = entry;
+    const evm = row.evm;
+    const type = evm && typeof evm === "object" ? String(evm.type ?? "") : "";
+    const meta4 = row.continuumDaoMarketplace;
+    if (!meta4 || typeof meta4 !== "object" || Array.isArray(meta4)) continue;
+    const info = meta4;
+    const tokenId = String(info.tokenId ?? "").trim();
+    if (!tokenId) continue;
+    if (type === "continuum_dao_marketplace_fulfill_listing") {
+      const recipient = String(info.recipient ?? "");
+      if (!recipient || same4(recipient, executor)) return { tokenId };
+    }
+    if (type === "continuum_dao_marketplace_settle_auction") {
+      const highest = String(info.highestBidder ?? "");
+      const recipient = String(info.recipient ?? "");
+      if (highest && same4(highest, executor) && same4(recipient, executor)) return { tokenId };
+    }
+  }
+  return null;
+}
+
+// src/protocols/evm/continuum-dao/index.ts
+registerProtocolModule(continuumDaoMarketplaceProtocolModule);
 var continuumDaoProtocolModule = {
   id: CONTINUUM_DAO_PROTOCOL_ID,
   chainCategory: "evm",
@@ -4762,6 +6919,6 @@ var continuumDaoProtocolModule = {
 };
 registerProtocolModule(continuumDaoProtocolModule);
 
-export { ATTACH_VECTM_SIGNATURE, BRAVO_SUPPORT_LABELS, CONTINUUM_DAO_APPROVE_FALLBACK, CONTINUUM_DAO_ATTACH_FALLBACK, CONTINUUM_DAO_CANCEL_FALLBACK, CONTINUUM_DAO_COMMITTEE_PROPOSERS, CONTINUUM_DAO_CREATE_LOCK_FALLBACK, CONTINUUM_DAO_DELEGATE_FALLBACK, CONTINUUM_DAO_DEPLOYMENTS, CONTINUUM_DAO_DETACH_FALLBACK, CONTINUUM_DAO_ETHEREUM_CHAIN_ID, CONTINUUM_DAO_EVM_TYPES, CONTINUUM_DAO_EXECUTE_FALLBACK, CONTINUUM_DAO_GOVERNANCE_API, CONTINUUM_DAO_GOV_EVM_TYPES, CONTINUUM_DAO_INCREASE_AMOUNT_FALLBACK, CONTINUUM_DAO_INCREASE_UNLOCK_FALLBACK, CONTINUUM_DAO_LINEA_CHAIN_ID, CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS, CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS, CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID, CONTINUUM_DAO_LIQUIDATE_FALLBACK, CONTINUUM_DAO_MERGE_FALLBACK, CONTINUUM_DAO_PROPOSE_FALLBACK, CONTINUUM_DAO_PROTOCOL_ID, CONTINUUM_DAO_SPLIT_FALLBACK, CONTINUUM_DAO_TRANSFER_FALLBACK, CONTINUUM_DAO_VOTE_FALLBACK, CONTINUUM_DAO_WITHDRAW_FALLBACK, CTM_TOKEN_ADDRESS, CTM_TOKEN_DECIMALS, CTM_TOKEN_NAME, CTM_TOKEN_SYMBOL, FORUM_GOVERNANCE_SECTIONS, FORUM_IDEA_SECTION, FORUM_LOGIN_DELIVERY_KIND, FOUNDRY_PROPOSAL_REQUIRED_SERVERS, GOVERNOR_STATE, GOVERNOR_STATE_LABELS, INCREASE_UNLOCK_TIME_SIGNATURE, MAXTIME_SECONDS, PROPOSAL_TYPE_LABELS, PROPOSAL_TYPE_TO_FORUM_SECTION, VECTM_DEFAULT_MINIMUM_LOCK_WEI, VECTM_LIQ_MIN_LOCKED_WEI, VECTM_LIQ_PENALTY_DEN, VECTM_LIQ_PENALTY_NUM, VECTM_MAX_LOCK_WEEKS, VECTM_NODE_INFO_TUPLE, VECTM_TOKEN_NAME, VECTM_TOKEN_SYMBOL, VOTE_CAST_EVENT, VOTE_CAST_WITH_PARAMS_EVENT, VOTING_ESCROW_LINEA_ADDRESS, WEEK_SECONDS, applyForumSectionCheck, applyNodeAttachments, assertContinuumDaoForumDeleteInput, assertContinuumDaoForumMarkReadInput, assertContinuumDaoForumRecentInput, assertContinuumDaoForumSearchInput, assertContinuumDaoForumTopicKey, assertContinuumDaoProposalSimulation, assertCreateLockAmount, assertCtmAmountAtLeastMinimum, assertDelegatee, assertExecutorOwnsLock, assertIncreaseAmount, assertIncreaseUnlockTime, assertLiquidate, assertLockDurationSeconds, assertMerge, assertSplitExtracted, assertTransfer, assertUndelegateNotAlreadySelf, assertWithdraw, bravoSupportLabel, bucketGovernorState, buildBravoProposalArgs, buildDeltaProposalArgs, buildEvmMultisignBodyContinuumDaoAttachVeCtm, buildEvmMultisignBodyContinuumDaoAttachVeCtmFromMcp, buildEvmMultisignBodyContinuumDaoCancel, buildEvmMultisignBodyContinuumDaoCastVoteBravo, buildEvmMultisignBodyContinuumDaoCastVoteBravoFromMcp, buildEvmMultisignBodyContinuumDaoCastVoteDelta, buildEvmMultisignBodyContinuumDaoCreateLock, buildEvmMultisignBodyContinuumDaoDelegate, buildEvmMultisignBodyContinuumDaoExecute, buildEvmMultisignBodyContinuumDaoForumSignIn, buildEvmMultisignBodyContinuumDaoIncreaseAmount, buildEvmMultisignBodyContinuumDaoIncreaseUnlockTime, buildEvmMultisignBodyContinuumDaoLiquidate, buildEvmMultisignBodyContinuumDaoMerge, buildEvmMultisignBodyContinuumDaoProposeBravo, buildEvmMultisignBodyContinuumDaoProposeDelta, buildEvmMultisignBodyContinuumDaoProposeDeltaFromMcp, buildEvmMultisignBodyContinuumDaoRequestDetach, buildEvmMultisignBodyContinuumDaoSplit, buildEvmMultisignBodyContinuumDaoTransfer, buildEvmMultisignBodyContinuumDaoUndelegate, buildEvmMultisignBodyContinuumDaoWithdraw, buildFoundryProposalSimulatePlan, collectVotesFromLogs, computeLiquidationAmounts, continuumDaoComposeProposalAction, continuumDaoDeployment, continuumDaoExplainProposal, continuumDaoFetchDelegates, continuumDaoFetchLiveProposals, continuumDaoFetchProposal, continuumDaoFetchProposalCount, continuumDaoFetchProposalState, continuumDaoFetchProposalVoteEligibility, continuumDaoFetchProposalVotes, continuumDaoFetchProposals, continuumDaoFetchVotingPower, continuumDaoForumCreateIdea, continuumDaoForumCreateTopic, continuumDaoForumDelete, continuumDaoForumFetchPost, continuumDaoForumFetchThread, continuumDaoForumMarkRead, continuumDaoForumMarkUnread, continuumDaoForumMe, continuumDaoForumReact, continuumDaoForumRecent, continuumDaoForumReply, continuumDaoForumReplyCount, continuumDaoForumResolve, continuumDaoForumSearch, continuumDaoForumSections, continuumDaoForumSignInEligible, continuumDaoForumSignInNonce, continuumDaoForumSignOut, continuumDaoForumUnread, continuumDaoForumUrl, continuumDaoForumUserPostIds, continuumDaoHashProposal, continuumDaoMpaFlag, continuumDaoMpaListing, continuumDaoMpaMailboxList, continuumDaoMpaMailboxOpen, continuumDaoMpaMailboxSend, continuumDaoMpaRetract, continuumDaoProtocolModule, continuumDaoRegisterProposal, continuumDaoSignatureText, continuumDaoSimulateProposal, continuumDaoTechnocoreBind, ctmTokenAddressOnEvmChain, decodeDeltaVoteParams, encodeContinuumDaoNodeInfo, encodeDeltaMetadata, encodeDeltaVoteParams, encodeGovActionCalldata, estimateBlockAtTimestamp, executableGovBatches, expectedForumSectionForProposalType, explainGovAction, explainProposalRecord, explorerBase, floorUnlockTimeSeconds, formatProposalSimulationFailure, foundryPlanHasSequentialExecute, foundryScriptContainsCall, governorAddressOnEvmChain, governorWriteAbi, howVoted, isConfiguredAddress, isContinuumDaoCommitteeProposer, isContinuumDaoCtmOnAssetsChain, isContinuumDaoLockChain, isContinuumDaoSupportedChainId, isContinuumDaoVeCtmOnAssetsChain, isCtmTokenSymbol, isForumIdeaSection, isGovNoOpAction, isLegacyContinuumDaoGovernor, isLineaHomeNetwork, isRemoteC3Action, isVotingEscrowContinuumName, listContinuumDaoDefaultAssets, looksLikeProposalCatalogId, looksLikeUnixSeconds, maxLockDurationSeconds, normalizeGovConfiguration, normalizeNodeInfo, preflightAttachVeCtm, preflightCreateLock, preflightDelegate, preflightIncreaseAmount, preflightIncreaseUnlockTime, preflightLiquidate, preflightMerge, preflightRequestDetach, preflightSplit, preflightTransfer, preflightUndelegate, preflightWithdraw, proposalDescriptionHash, publicClient2 as publicClient, readCtmBalanceWei, readMinimumLockWei, readVeCtmLockState, requireGovernor, resolveAttachGroupId, resolveGovernorProposalRef, resolveProposalCatalogRange, summarizeLiveProposals, summarizeProposalVotes, throwIfProposalSimulationFailed, validateAbiParameter, votingEscrowAddressOnEvmChain, votingPowerRefuse, votingPowerWarning };
+export { ATTACH_VECTM_SIGNATURE, AUCTION_STATUS, BRAVO_SUPPORT_LABELS, CONTINUUM_DAO_APPROVE_FALLBACK, CONTINUUM_DAO_ATTACH_FALLBACK, CONTINUUM_DAO_CANCEL_FALLBACK, CONTINUUM_DAO_COMMITTEE_PROPOSERS, CONTINUUM_DAO_CREATE_LOCK_FALLBACK, CONTINUUM_DAO_DELEGATE_FALLBACK, CONTINUUM_DAO_DEPLOYMENTS, CONTINUUM_DAO_DETACH_FALLBACK, CONTINUUM_DAO_ETHEREUM_CHAIN_ID, CONTINUUM_DAO_EVM_TYPES, CONTINUUM_DAO_EXECUTE_FALLBACK, CONTINUUM_DAO_GOVERNANCE_API, CONTINUUM_DAO_GOV_EVM_TYPES, CONTINUUM_DAO_INCREASE_AMOUNT_FALLBACK, CONTINUUM_DAO_INCREASE_UNLOCK_FALLBACK, CONTINUUM_DAO_LINEA_CHAIN_ID, CONTINUUM_DAO_LINEA_GOVERNOR_ADDRESS, CONTINUUM_DAO_LINEA_GOVERNOR_LEGACY_ADDRESS, CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID, CONTINUUM_DAO_LIQUIDATE_FALLBACK, CONTINUUM_DAO_MARKETPLACE_API, CONTINUUM_DAO_MARKETPLACE_PROTOCOL_ID, CONTINUUM_DAO_MERGE_FALLBACK, CONTINUUM_DAO_PROPOSE_FALLBACK, CONTINUUM_DAO_PROTOCOL_ID, CONTINUUM_DAO_SPLIT_FALLBACK, CONTINUUM_DAO_TRANSFER_FALLBACK, CONTINUUM_DAO_VOTE_FALLBACK, CONTINUUM_DAO_WITHDRAW_FALLBACK, CTM_FEE_RATE_SCALE, CTM_TOKEN_ADDRESS, CTM_TOKEN_DECIMALS, CTM_TOKEN_NAME, CTM_TOKEN_SYMBOL, FEE_TIER_NAMES, FORUM_GOVERNANCE_SECTIONS, FORUM_IDEA_SECTION, FORUM_LOGIN_DELIVERY_KIND, FOUNDRY_PROPOSAL_REQUIRED_SERVERS, GOVERNOR_STATE, GOVERNOR_STATE_LABELS, INCREASE_UNLOCK_TIME_SIGNATURE, MARKETPLACE_APPROVE_FALLBACK, MARKETPLACE_AUCTION_CREATE_FALLBACK, MARKETPLACE_BID_FALLBACK, MARKETPLACE_FULFILL_FALLBACK, MARKETPLACE_LISTING_FALLBACK, MARKETPLACE_OFFERING_FALLBACK, MARKETPLACE_SETTLE_FALLBACK, MARKETPLACE_USDC_LINEA_ADDRESS, MARKETPLACE_WETH_LINEA_ADDRESS, MARKET_ORDER_STATUS, MAXTIME_SECONDS, MULTISIGN_AGENT_WALLET_LINEA_ADDRESS, PROPOSAL_TYPE_LABELS, PROPOSAL_TYPE_TO_FORUM_SECTION, VECTM_DEFAULT_MINIMUM_LOCK_WEI, VECTM_LIQ_MIN_LOCKED_WEI, VECTM_LIQ_PENALTY_DEN, VECTM_LIQ_PENALTY_NUM, VECTM_MAX_LOCK_WEEKS, VECTM_NODE_INFO_TUPLE, VECTM_TOKEN_NAME, VECTM_TOKEN_SYMBOL, VOTE_CAST_EVENT, VOTE_CAST_WITH_PARAMS_EVENT, VOTING_ESCROW_LINEA_ADDRESS, VOTING_ESCROW_MARKETPLACE_LINEA_ADDRESS, VOTING_ESCROW_MARKETPLACE_START_BLOCK, WEEK_SECONDS, applyDerivedStatuses, applyForumSectionCheck, applyMarketplaceEvent, applyNodeAttachments, assertContinuumDaoForumDeleteInput, assertContinuumDaoForumMarkReadInput, assertContinuumDaoForumRecentInput, assertContinuumDaoForumSearchInput, assertContinuumDaoForumTopicKey, assertContinuumDaoProposalSimulation, assertCreateLockAmount, assertCtmAmountAtLeastMinimum, assertDelegatee, assertExecutorOwnsLock, assertIncreaseAmount, assertIncreaseUnlockTime, assertLiquidate, assertLockDurationSeconds, assertMerge, assertSplitExtracted, assertTransfer, assertUndelegateNotAlreadySelf, assertWithdraw, auctionCandidate, auctionStatusName, bravoSupportLabel, bucketGovernorState, buildBravoProposalArgs, buildDeltaProposalArgs, buildEvmMultisignBodyContinuumDaoAttachVeCtm, buildEvmMultisignBodyContinuumDaoAttachVeCtmFromMcp, buildEvmMultisignBodyContinuumDaoCancel, buildEvmMultisignBodyContinuumDaoCastVoteBravo, buildEvmMultisignBodyContinuumDaoCastVoteBravoFromMcp, buildEvmMultisignBodyContinuumDaoCastVoteDelta, buildEvmMultisignBodyContinuumDaoCreateLock, buildEvmMultisignBodyContinuumDaoDelegate, buildEvmMultisignBodyContinuumDaoExecute, buildEvmMultisignBodyContinuumDaoForumSignIn, buildEvmMultisignBodyContinuumDaoIncreaseAmount, buildEvmMultisignBodyContinuumDaoIncreaseUnlockTime, buildEvmMultisignBodyContinuumDaoLiquidate, buildEvmMultisignBodyContinuumDaoMarketplaceAuctionBid, buildEvmMultisignBodyContinuumDaoMarketplaceCancelAuction, buildEvmMultisignBodyContinuumDaoMarketplaceCreateAuction, buildEvmMultisignBodyContinuumDaoMarketplaceCreateListing, buildEvmMultisignBodyContinuumDaoMarketplaceCreateOffering, buildEvmMultisignBodyContinuumDaoMarketplaceDelist, buildEvmMultisignBodyContinuumDaoMarketplaceFulfillListing, buildEvmMultisignBodyContinuumDaoMarketplaceFulfillOffering, buildEvmMultisignBodyContinuumDaoMarketplaceRescind, buildEvmMultisignBodyContinuumDaoMarketplaceSettleAuction, buildEvmMultisignBodyContinuumDaoMerge, buildEvmMultisignBodyContinuumDaoProposeBravo, buildEvmMultisignBodyContinuumDaoProposeDelta, buildEvmMultisignBodyContinuumDaoProposeDeltaFromMcp, buildEvmMultisignBodyContinuumDaoRequestDetach, buildEvmMultisignBodyContinuumDaoSplit, buildEvmMultisignBodyContinuumDaoTransfer, buildEvmMultisignBodyContinuumDaoUndelegate, buildEvmMultisignBodyContinuumDaoWithdraw, buildFeeAlternativeSummary, buildFoundryProposalSimulatePlan, calculateMarketplaceFee, collectVotesFromLogs, computeLiquidationAmounts, continuumDaoComposeProposalAction, continuumDaoDeployment, continuumDaoExplainProposal, continuumDaoFetchDelegates, continuumDaoFetchLiveProposals, continuumDaoFetchProposal, continuumDaoFetchProposalCount, continuumDaoFetchProposalState, continuumDaoFetchProposalVoteEligibility, continuumDaoFetchProposalVotes, continuumDaoFetchProposals, continuumDaoFetchVotingPower, continuumDaoForumCreateIdea, continuumDaoForumCreateTopic, continuumDaoForumDelete, continuumDaoForumFetchPost, continuumDaoForumFetchThread, continuumDaoForumMarkRead, continuumDaoForumMarkUnread, continuumDaoForumMe, continuumDaoForumReact, continuumDaoForumRecent, continuumDaoForumReply, continuumDaoForumReplyCount, continuumDaoForumResolve, continuumDaoForumSearch, continuumDaoForumSections, continuumDaoForumSignInEligible, continuumDaoForumSignInNonce, continuumDaoForumSignOut, continuumDaoForumUnread, continuumDaoForumUrl, continuumDaoForumUserPostIds, continuumDaoHashProposal, continuumDaoMarketplaceProtocolModule, continuumDaoMpaFlag, continuumDaoMpaListing, continuumDaoMpaMailboxList, continuumDaoMpaMailboxOpen, continuumDaoMpaMailboxSend, continuumDaoMpaRetract, continuumDaoProtocolModule, continuumDaoRegisterProposal, continuumDaoSignatureText, continuumDaoSimulateProposal, continuumDaoTechnocoreBind, ctmTokenAddressOnEvmChain, decodeDeltaVoteParams, deriveAuctionStatus, emptyMarketplaceIndexCache, encodeContinuumDaoNodeInfo, encodeDeltaMetadata, encodeDeltaVoteParams, encodeGovActionCalldata, estimateBlockAtTimestamp, executableGovBatches, expectedForumSectionForProposalType, explainGovAction, explainProposalRecord, explorerBase, fetchContinuumDaoMarketplaceActivity, fetchContinuumDaoMarketplaceAuctions, fetchContinuumDaoMarketplaceConfig, fetchContinuumDaoMarketplaceFeePreview, fetchContinuumDaoMarketplaceListings, fetchContinuumDaoMarketplaceOfferings, fetchContinuumDaoMarketplaceToken, floorUnlockTimeSeconds, foldMarketplaceEvents, formatProposalSimulationFailure, foundryPlanHasSequentialExecute, foundryScriptContainsCall, getMarketplaceIndexMemoryCache, governorAddressOnEvmChain, governorWriteAbi, howVoted, isConfiguredAddress, isContinuumDaoCommitteeProposer, isContinuumDaoCtmOnAssetsChain, isContinuumDaoLockChain, isContinuumDaoSupportedChainId, isContinuumDaoVeCtmOnAssetsChain, isCtmTokenSymbol, isForumIdeaSection, isGovNoOpAction, isLegacyContinuumDaoGovernor, isLineaHomeNetwork, isLiveAuctionStatus, isOpenOrder, isRemoteC3Action, isVotingEscrowContinuumName, keyGenOwnsVeCtm, listContinuumDaoDefaultAssets, listingCandidate, loadMarketplacePlanSnapshot, looksLikeProposalCatalogId, looksLikeUnixSeconds, marketplacePublicClient, marketplaceVeCtmReceivedBy, maxLockDurationSeconds, monthsOfFees, normalizeGovConfiguration, normalizeNodeInfo, orderStatusName, pickFeeAlternativeExample, planMarketplaceSteps, preflightAttachVeCtm, preflightCreateLock, preflightDelegate, preflightIncreaseAmount, preflightIncreaseUnlockTime, preflightLiquidate, preflightMerge, preflightRequestDetach, preflightSplit, preflightTransfer, preflightUndelegate, preflightWithdraw, proposalDescriptionHash, publicClient2 as publicClient, quoteContinuumDaoMarketplaceFeeAlternative, rankMarketplaceSearchHits, readCtmBalanceWei, readMarketplaceConfigFromChain, readMarketplaceFeePreviewFromChain, readMinimumLockWei, readVeCtmLockState, requireGovernor, resolveAttachGroupId, resolveGovernorProposalRef, resolveProposalCatalogRange, scanMarketplaceLogs, searchContinuumDaoMarketplace, setMarketplaceIndexMemoryCache, summarizeLiveProposals, summarizeProposalVotes, throwIfProposalSimulationFailed, validateAbiParameter, votingEscrowAddressOnEvmChain, votingEscrowMarketplaceAddressOnEvmChain, votingPowerAboveUntil, votingPowerRefuse, votingPowerWarning };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map