@continuumdao/ctm-mpc-defi 0.2.28 → 0.2.30

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

@@ -0,0 +1,2110 @@
+import { parseAbi, zeroAddress, getAddress, parseUnits, encodeFunctionData, createPublicClient, http, defineChain, keccak256, encodePacked, padHex, toHex, hashTypedData, parseGwei, serializeTransaction, stringToHex } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/chains/evm/chainIdParse.ts
+function parseEvmChainIdToNumber(chainId) {
+  if (chainId == null) return Number.NaN;
+  if (typeof chainId === "bigint") {
+    const n = Number(chainId);
+    return Number.isSafeInteger(n) && n >= 0 ? n : Number.NaN;
+  }
+  if (typeof chainId === "number") {
+    return Number.isInteger(chainId) && chainId >= 0 ? chainId : Number.NaN;
+  }
+  const t = String(chainId).trim();
+  if (!t) return Number.NaN;
+  const low = t.toLowerCase();
+  if (low.startsWith("eip155:")) {
+    const rest = t.slice("eip155:".length).trim();
+    const n = Number.parseInt(rest, 10);
+    return Number.isNaN(n) || n < 0 ? Number.NaN : n;
+  }
+  if (low.startsWith("0x")) {
+    return Number.parseInt(t, 16);
+  }
+  return Number.parseInt(t, 10);
+}
+
+// src/protocols/evm/continuum-dao/constants.ts
+var CONTINUUM_DAO_PROTOCOL_ID = "continuum-dao";
+var CONTINUUM_DAO_ETHEREUM_CHAIN_ID = 1;
+var CONTINUUM_DAO_LINEA_CHAIN_ID = 59144;
+var CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID = 59141;
+var CTM_TOKEN_NAME = "Continuum";
+var CTM_TOKEN_SYMBOL = "CTM";
+var VECTM_TOKEN_NAME = "Voting Escrow Continuum";
+var VECTM_TOKEN_SYMBOL = "veCTM";
+var CTM_TOKEN_DECIMALS = 18;
+var WEEK_SECONDS = 7 * 86400;
+var MAXTIME_SECONDS = 4 * 365 * 86400;
+var UNSET = {
+  ctm: zeroAddress,
+  votingEscrow: zeroAddress,
+  nodeProperties: zeroAddress,
+  rewards: zeroAddress,
+  governor: zeroAddress
+};
+var CONTINUUM_DAO_DEPLOYMENTS = {
+  [CONTINUUM_DAO_LINEA_CHAIN_ID]: { ...UNSET },
+  [CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID]: { ...UNSET },
+  [CONTINUUM_DAO_ETHEREUM_CHAIN_ID]: {
+    ctm: zeroAddress,
+    votingEscrow: zeroAddress,
+    nodeProperties: zeroAddress,
+    rewards: zeroAddress,
+    governor: zeroAddress
+  }
+};
+var CONTINUUM_DAO_GOVERNANCE_API = "https://app-api.continuumdao.org";
+function isConfiguredAddress(addr) {
+  if (!addr?.trim()) return false;
+  try {
+    return getAddress(addr) !== zeroAddress;
+  } catch {
+    return false;
+  }
+}
+function continuumDaoDeployment(chainId) {
+  return CONTINUUM_DAO_DEPLOYMENTS[chainId] ?? null;
+}
+function isContinuumDaoLockChain(chainId) {
+  return chainId === CONTINUUM_DAO_LINEA_CHAIN_ID || chainId === CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID;
+}
+function isContinuumDaoSupportedChainId(chainId) {
+  return continuumDaoDeployment(chainId) != null;
+}
+function ctmTokenAddressOnEvmChain(chainId) {
+  const ctm = continuumDaoDeployment(chainId)?.ctm;
+  return ctm && isConfiguredAddress(ctm) ? getAddress(ctm) : null;
+}
+function votingEscrowAddressOnEvmChain(chainId) {
+  const ve = continuumDaoDeployment(chainId)?.votingEscrow;
+  return ve && isConfiguredAddress(ve) ? getAddress(ve) : null;
+}
+function governorAddressOnEvmChain(chainId) {
+  const gov = continuumDaoDeployment(chainId)?.governor;
+  return gov && isConfiguredAddress(gov) ? getAddress(gov) : null;
+}
+function sameAddr(a, b) {
+  try {
+    return getAddress(a) === getAddress(b);
+  } catch {
+    return false;
+  }
+}
+function isContinuumDaoCtmOnAssetsChain(assetsChainId, contractAddress) {
+  const n = parseEvmChainIdToNumber(assetsChainId);
+  if (Number.isNaN(n) || n < 0) return false;
+  const expected = ctmTokenAddressOnEvmChain(n);
+  if (!expected) return false;
+  return sameAddr(contractAddress, expected);
+}
+function isContinuumDaoVeCtmOnAssetsChain(assetsChainId, contractAddress) {
+  const n = parseEvmChainIdToNumber(assetsChainId);
+  if (Number.isNaN(n) || n < 0) return false;
+  const expected = votingEscrowAddressOnEvmChain(n);
+  if (!expected) return false;
+  return sameAddr(contractAddress, expected);
+}
+function isVotingEscrowContinuumName(name) {
+  return (name ?? "").trim() === VECTM_TOKEN_NAME;
+}
+function isCtmTokenSymbol(symbol) {
+  return (symbol ?? "").trim().toUpperCase() === CTM_TOKEN_SYMBOL;
+}
+function listContinuumDaoDefaultAssets() {
+  const out = [];
+  for (const chainId of [
+    CONTINUUM_DAO_LINEA_CHAIN_ID,
+    CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID,
+    CONTINUUM_DAO_ETHEREUM_CHAIN_ID
+  ]) {
+    const dep = continuumDaoDeployment(chainId);
+    if (!dep) continue;
+    if (isConfiguredAddress(dep.ctm)) {
+      out.push({
+        chainId,
+        tokenType: "CTMERC20",
+        contractAddress: getAddress(dep.ctm),
+        name: CTM_TOKEN_NAME,
+        symbol: CTM_TOKEN_SYMBOL,
+        decimals: CTM_TOKEN_DECIMALS
+      });
+    }
+    if (isContinuumDaoLockChain(chainId) && isConfiguredAddress(dep.votingEscrow)) {
+      out.push({
+        chainId,
+        tokenType: "ERC721",
+        contractAddress: getAddress(dep.votingEscrow),
+        name: VECTM_TOKEN_NAME,
+        symbol: VECTM_TOKEN_SYMBOL
+      });
+    }
+  }
+  return out;
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient2 = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient2.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const gasLimitConfig = useCustomGas && chainDetail?.gasLimit != null ? Number(chainDetail.gasLimit) : void 0;
+  const chainGasLimitRouter = chainDetail?.gasLimit != null && Number.isFinite(Number(chainDetail.gasLimit)) && Number(chainDetail.gasLimit) > 0 ? Number(chainDetail.gasLimit) : void 0;
+  const gasFeeMultiplier = useCustomGas && chainDetail?.gasMultiplier != null ? Number(chainDetail.gasMultiplier) : void 0;
+  const executor = getAddress(executorAddress);
+  const baseNonce = await publicClient2.getTransactionCount({ address: executor, blockTag: "pending" });
+  const legs = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    if (args.estimateGasForStep) {
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient: publicClient2, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient2.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient: publicClient2 });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient2.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/continuum-dao/multisign.ts
+var CONTINUUM_DAO_APPROVE_FALLBACK = 100000n;
+var CONTINUUM_DAO_CREATE_LOCK_FALLBACK = 550000n;
+var CONTINUUM_DAO_INCREASE_AMOUNT_FALLBACK = 400000n;
+var CONTINUUM_DAO_INCREASE_UNLOCK_FALLBACK = 400000n;
+var CONTINUUM_DAO_SPLIT_FALLBACK = 650000n;
+var CONTINUUM_DAO_MERGE_FALLBACK = 550000n;
+var CONTINUUM_DAO_WITHDRAW_FALLBACK = 350000n;
+var CONTINUUM_DAO_LIQUIDATE_FALLBACK = 450000n;
+var CONTINUUM_DAO_DELEGATE_FALLBACK = 160000n;
+var CONTINUUM_DAO_TRANSFER_FALLBACK = 160000n;
+var CONTINUUM_DAO_ATTACH_FALLBACK = 450000n;
+var CONTINUUM_DAO_DETACH_FALLBACK = 220000n;
+var VECTM_NODE_INFO_TUPLE = "(string,string,uint8[4],uint16[8],string,uint256,uint256,string,string,bytes)";
+var ATTACH_VECTM_SIGNATURE = `attachVeCtm(string,uint256,${VECTM_NODE_INFO_TUPLE})`;
+var erc20Abi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+var veWriteAbi = parseAbi([
+  "function create_lock(uint256 _value, uint256 _lock_duration) returns (uint256)",
+  "function increase_amount(uint256 _tokenId, uint256 _value)",
+  "function increase_unlock_time(uint256 _tokenId, uint256 _lock_duration)",
+  "function withdraw(uint256 _tokenId)",
+  "function split(uint256 _tokenId, uint256 _extracted) returns (uint256)",
+  "function merge(uint256 _from, uint256 _to)",
+  "function liquidate(uint256 _tokenId)",
+  "function delegate(address delegatee)",
+  "function transferFrom(address _from, address _to, uint256 _tokenId)"
+]);
+var attachAbi = parseAbi([
+  `function attachVeCtm(string nodeKey, uint256 tokenId, ${VECTM_NODE_INFO_TUPLE} nodeInfo)`
+]);
+var detachAbi = parseAbi(["function setNodeRemovalStatus(uint256 tokenId, bool status)"]);
+var CONTINUUM_DAO_EVM_TYPES = /* @__PURE__ */ new Set([
+  "continuum_dao_approve",
+  "continuum_dao_create_lock",
+  "continuum_dao_increase_amount",
+  "continuum_dao_increase_unlock_time",
+  "continuum_dao_split",
+  "continuum_dao_merge",
+  "continuum_dao_withdraw",
+  "continuum_dao_liquidate",
+  "continuum_dao_delegate",
+  "continuum_dao_undelegate",
+  "continuum_dao_transfer",
+  "continuum_dao_attach",
+  "continuum_dao_request_detach"
+]);
+function requireLockChain(chainId) {
+  if (!isContinuumDaoLockChain(chainId)) {
+    throw new Error("ContinuumDAO lock and attach actions are Linea-only.");
+  }
+}
+function requireVe(chainId) {
+  requireLockChain(chainId);
+  const ve = votingEscrowAddressOnEvmChain(chainId);
+  if (!ve) throw new Error("Voting Escrow address is not configured for this chain yet.");
+  return ve;
+}
+function requireCtm(chainId) {
+  const ctm = ctmTokenAddressOnEvmChain(chainId);
+  if (!ctm) throw new Error("CTM address is not configured for this chain yet.");
+  return ctm;
+}
+function parseTokenId(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 meta(evmType, chainId, to, extra, gasLimit) {
+  return {
+    destinationAddress: to,
+    signatureText: JSON.stringify({
+      kind: "ContinuumDAO",
+      ...extra,
+      chainId
+    }),
+    evm: { type: evmType, version: 1, chainId: String(chainId), protocolId: CONTINUUM_DAO_PROTOCOL_ID },
+    continuumDao: { ...extra, gas: { baseGasUnits: gasLimit.toString() } }
+  };
+}
+async function finalize(steps, args, purposeSuffix) {
+  if (steps.length === 0) throw new Error("ContinuumDAO batch requires at least one step.");
+  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 }) => steps[index].buildBatchMeta({ gasLimit })
+  });
+}
+async function maybeApproveCtmStep(args) {
+  const ch = defineChain({
+    id: args.chainId,
+    name: "ContinuumDAO",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl.trim()] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(args.rpcUrl.trim()) });
+  let allowance = 0n;
+  try {
+    allowance = await client.readContract({
+      address: args.ctm,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [args.owner, args.spender]
+    });
+  } catch {
+    allowance = 0n;
+  }
+  if (allowance >= args.amountWei) return null;
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "approve",
+    args: [args.spender, args.amountWei]
+  });
+  return {
+    to: args.ctm,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_APPROVE_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_approve", args.chainId, args.ctm, {
+      name: "CTM.approve",
+      spender: args.spender,
+      amountWei: args.amountWei.toString()
+    }, gasLimit)
+  };
+}
+async function buildEvmMultisignBodyContinuumDaoCreateLock(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const ctm = args.ctm && isConfiguredAddress(args.ctm) ? getAddress(args.ctm) : requireCtm(args.chainId);
+  const amountWei = parseUnits(String(args.amountHuman).trim().replace(/,/g, ""), CTM_TOKEN_DECIMALS);
+  if (amountWei <= 0n) throw new Error("CTM amount must be greater than zero.");
+  const duration = BigInt(String(args.lockDurationSeconds).trim());
+  if (duration <= 0n) throw new Error("Lock duration must be greater than zero.");
+  const owner = getAddress(args.executorAddress);
+  const approve = await maybeApproveCtmStep({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    owner,
+    ctm,
+    spender: ve,
+    amountWei
+  });
+  const data = encodeFunctionData({
+    abi: veWriteAbi,
+    functionName: "create_lock",
+    args: [amountWei, duration]
+  });
+  const lockStep = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_CREATE_LOCK_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_create_lock", args.chainId, ve, {
+      name: "VotingEscrow.create_lock",
+      amountWei: amountWei.toString(),
+      lockDurationSeconds: duration.toString()
+    }, gasLimit)
+  };
+  const steps = approve ? [approve, lockStep] : [lockStep];
+  return finalize(steps, args, `ContinuumDAO: create lock ${args.amountHuman} CTM.`);
+}
+async function buildEvmMultisignBodyContinuumDaoIncreaseAmount(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const ctm = args.ctm && isConfiguredAddress(args.ctm) ? getAddress(args.ctm) : requireCtm(args.chainId);
+  const tokenId = parseTokenId(args.tokenId);
+  const amountWei = parseUnits(String(args.amountHuman).trim().replace(/,/g, ""), CTM_TOKEN_DECIMALS);
+  if (amountWei <= 0n) throw new Error("CTM amount must be greater than zero.");
+  const owner = getAddress(args.executorAddress);
+  const approve = await maybeApproveCtmStep({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    owner,
+    ctm,
+    spender: ve,
+    amountWei
+  });
+  const data = encodeFunctionData({
+    abi: veWriteAbi,
+    functionName: "increase_amount",
+    args: [tokenId, amountWei]
+  });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_INCREASE_AMOUNT_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_increase_amount", args.chainId, ve, {
+      name: "VotingEscrow.increase_amount",
+      tokenId: tokenId.toString(),
+      amountWei: amountWei.toString()
+    }, gasLimit)
+  };
+  const steps = approve ? [approve, step] : [step];
+  return finalize(steps, args, `ContinuumDAO: increase amount on veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoIncreaseUnlockTime(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const tokenId = parseTokenId(args.tokenId);
+  const duration = BigInt(String(args.lockDurationSeconds).trim());
+  if (duration <= 0n) throw new Error("Unlock duration must be greater than zero.");
+  const data = encodeFunctionData({
+    abi: veWriteAbi,
+    functionName: "increase_unlock_time",
+    args: [tokenId, duration]
+  });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_INCREASE_UNLOCK_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_increase_unlock_time", args.chainId, ve, {
+      name: "VotingEscrow.increase_unlock_time",
+      tokenId: tokenId.toString(),
+      lockDurationSeconds: duration.toString()
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: increase unlock time on veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoSplit(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const tokenId = parseTokenId(args.tokenId);
+  const extracted = parseUnits(String(args.extractedHuman).trim().replace(/,/g, ""), CTM_TOKEN_DECIMALS);
+  if (extracted <= 0n) throw new Error("Split amount must be greater than zero.");
+  const data = encodeFunctionData({
+    abi: veWriteAbi,
+    functionName: "split",
+    args: [tokenId, extracted]
+  });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_SPLIT_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_split", args.chainId, ve, {
+      name: "VotingEscrow.split",
+      tokenId: tokenId.toString(),
+      extractedWei: extracted.toString()
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: split veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoMerge(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const fromId = parseTokenId(args.fromTokenId);
+  const toId = parseTokenId(args.toTokenId);
+  if (fromId === toId) throw new Error("Merge requires two different token ids.");
+  const data = encodeFunctionData({
+    abi: veWriteAbi,
+    functionName: "merge",
+    args: [fromId, toId]
+  });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_MERGE_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_merge", args.chainId, ve, {
+      name: "VotingEscrow.merge",
+      fromTokenId: fromId.toString(),
+      toTokenId: toId.toString()
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: merge veCTM #${fromId} into #${toId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoWithdraw(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const tokenId = parseTokenId(args.tokenId);
+  const data = encodeFunctionData({ abi: veWriteAbi, functionName: "withdraw", args: [tokenId] });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_WITHDRAW_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_withdraw", args.chainId, ve, {
+      name: "VotingEscrow.withdraw",
+      tokenId: tokenId.toString()
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: withdraw veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoLiquidate(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const tokenId = parseTokenId(args.tokenId);
+  const data = encodeFunctionData({ abi: veWriteAbi, functionName: "liquidate", args: [tokenId] });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_LIQUIDATE_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_liquidate", args.chainId, ve, {
+      name: "VotingEscrow.liquidate",
+      tokenId: tokenId.toString()
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: liquidate veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoDelegate(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const delegatee = getAddress(args.delegatee);
+  const data = encodeFunctionData({ abi: veWriteAbi, functionName: "delegate", args: [delegatee] });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_DELEGATE_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_delegate", args.chainId, ve, {
+      name: "VotingEscrow.delegate",
+      delegatee
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: delegate voting power to ${delegatee}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoUndelegate(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const self = getAddress(args.executorAddress);
+  const data = encodeFunctionData({ abi: veWriteAbi, functionName: "delegate", args: [self] });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_DELEGATE_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_undelegate", args.chainId, ve, {
+      name: "VotingEscrow.delegate",
+      delegatee: self,
+      undelegate: true
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: undelegate voting power (delegate back to ${self}).`);
+}
+var veReadAbi = parseAbi(["function delegates(address account) view returns (address)"]);
+async function continuumDaoFetchDelegates(args) {
+  const chainId = Number(args.chainId);
+  requireLockChain(chainId);
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(chainId);
+  const account = getAddress(args.account);
+  const client = createPublicClient({
+    chain: defineChain({
+      id: chainId,
+      name: "ContinuumDAO",
+      nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+      rpcUrls: { default: { http: [args.rpcUrl.trim()] } }
+    }),
+    transport: http(args.rpcUrl.trim())
+  });
+  const delegatee = getAddress(
+    await client.readContract({ address: ve, abi: veReadAbi, functionName: "delegates", args: [account] })
+  );
+  return { account, delegatee, self: delegatee === account };
+}
+async function buildEvmMultisignBodyContinuumDaoTransfer(args) {
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
+  const tokenId = parseTokenId(args.tokenId);
+  const to = getAddress(args.to);
+  const from = getAddress(args.executorAddress);
+  const data = encodeFunctionData({
+    abi: veWriteAbi,
+    functionName: "transferFrom",
+    args: [from, to, tokenId]
+  });
+  const step = {
+    to: ve,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_TRANSFER_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_transfer", args.chainId, ve, {
+      name: "VotingEscrow.transferFrom",
+      tokenId: tokenId.toString(),
+      from,
+      to
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: transfer veCTM #${tokenId} to ${to}.`);
+}
+function encodeContinuumDaoNodeInfo(info) {
+  const ipv4Src = info?.ipv4 ?? [0, 0, 0, 0];
+  const ipv6Src = info?.ipv6 ?? [0, 0, 0, 0, 0, 0, 0, 0];
+  const ipv4 = [
+    ipv4Src[0] ?? 0,
+    ipv4Src[1] ?? 0,
+    ipv4Src[2] ?? 0,
+    ipv4Src[3] ?? 0
+  ];
+  const ipv6 = [
+    ipv6Src[0] ?? 0,
+    ipv6Src[1] ?? 0,
+    ipv6Src[2] ?? 0,
+    ipv6Src[3] ?? 0,
+    ipv6Src[4] ?? 0,
+    ipv6Src[5] ?? 0,
+    ipv6Src[6] ?? 0,
+    ipv6Src[7] ?? 0
+  ];
+  const extraRaw = (info?.extra ?? "0x").trim() || "0x";
+  const extra = extraRaw.startsWith("0x") ? extraRaw : `0x${extraRaw}`;
+  return [
+    info?.forumHandle ?? "",
+    info?.email ?? "",
+    ipv4,
+    ipv6,
+    info?.vps ?? "",
+    BigInt(String(info?.ram ?? 0)),
+    BigInt(String(info?.cpu ?? 0)),
+    info?.dIDType ?? "",
+    info?.dID ?? "",
+    extra
+  ];
+}
+async function buildEvmMultisignBodyContinuumDaoAttachVeCtm(args) {
+  requireLockChain(args.chainId);
+  const wallet = getAddress(args.mpaWallet);
+  if (wallet === zeroAddress) throw new Error("MPA wallet address is required to attach veCTM.");
+  const tokenId = parseTokenId(args.tokenId);
+  const nodeKey = args.nodeKey.trim();
+  if (!nodeKey) throw new Error("nodeKey is required to attach veCTM.");
+  const tuple = args.nodeInfoTuple ?? encodeContinuumDaoNodeInfo(args.nodeInfo);
+  const data = encodeFunctionData({
+    abi: attachAbi,
+    functionName: "attachVeCtm",
+    args: [nodeKey, tokenId, tuple]
+  });
+  const step = {
+    to: wallet,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_ATTACH_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_attach", args.chainId, wallet, {
+      name: "MultiSignAgentWallet.attachVeCtm",
+      nodeKey,
+      tokenId: tokenId.toString()
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: attach veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoRequestDetach(args) {
+  requireLockChain(args.chainId);
+  const np = getAddress(args.nodeProperties);
+  if (np === zeroAddress) throw new Error("NodeProperties address is required to request detach.");
+  const tokenId = parseTokenId(args.tokenId);
+  const data = encodeFunctionData({
+    abi: detachAbi,
+    functionName: "setNodeRemovalStatus",
+    args: [tokenId, true]
+  });
+  const step = {
+    to: np,
+    data,
+    value: 0n,
+    fallbackGas: CONTINUUM_DAO_DETACH_FALLBACK,
+    buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_request_detach", args.chainId, np, {
+      name: "NodeProperties.setNodeRemovalStatus",
+      tokenId: tokenId.toString(),
+      status: true
+    }, gasLimit)
+  };
+  return finalize([step], args, `ContinuumDAO: request detach of veCTM #${tokenId}.`);
+}
+async function buildEvmMultisignBodyContinuumDaoAttachVeCtmFromMcp(args) {
+  return buildEvmMultisignBodyContinuumDaoAttachVeCtm({
+    ...args,
+    nodeInfo: {
+      forumHandle: args.forumHandle,
+      email: args.email,
+      vps: args.vps,
+      ram: args.ram,
+      cpu: args.cpu,
+      dIDType: args.dIDType,
+      dID: args.dID
+    }
+  });
+}
+var EIP712_SIGN_REQUEST_KIND = "eip712";
+function msgHashNo0x(digest) {
+  return digest.startsWith("0x") ? digest.slice(2) : digest;
+}
+function eip712SignatureText(domain, primaryType) {
+  return JSON.stringify({
+    kind: "EIP-712",
+    ...typeof domain.name === "string" ? { name: domain.name } : {},
+    primaryType
+  });
+}
+function jsonStringifyForAudit(value) {
+  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+function eip712LegEnvelope(typedData, delivery, digest) {
+  return {
+    version: 1,
+    digest,
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message,
+    delivery
+  };
+}
+function eip712MsgRawHex(envelope) {
+  return stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712Multisign(args) {
+  if (args.legs.length < 1) {
+    throw new Error("buildEip712Multisign requires at least one leg");
+  }
+  const eip712 = [];
+  const legs = args.legs.map((leg) => {
+    const digest = hashTypedData({
+      domain: leg.typedData.domain,
+      types: leg.typedData.types,
+      primaryType: leg.typedData.primaryType,
+      message: leg.typedData.message
+    });
+    const envelope = eip712LegEnvelope(leg.typedData, leg.delivery, digest);
+    eip712.push(envelope);
+    return {
+      msgHash: msgHashNo0x(digest),
+      msgRaw: eip712MsgRawHex(envelope),
+      destinationAddress: args.destinationAddress,
+      signatureText: eip712SignatureText(leg.typedData.domain, leg.typedData.primaryType),
+      audit: {
+        kind: "EIP712",
+        primaryType: leg.typedData.primaryType,
+        deliveryKind: leg.delivery.kind,
+        ...leg.audit ?? {}
+      },
+      feeSnapshot: {}
+    };
+  });
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON: {
+      signRequestKind: EIP712_SIGN_REQUEST_KIND,
+      eip712
+    },
+    expiryDate: args.expiryDate,
+    legs
+  });
+}
+
+// src/protocols/evm/continuum-dao/forum.ts
+var DEFAULT_FORUM_URL = "https://forum.continuumdao.org";
+var FORUM_GOVERNANCE_SECTIONS = [
+  "decision",
+  "election",
+  "treasury",
+  "constitution",
+  "admin"
+];
+var FORUM_IDEA_SECTION = "ideas";
+var PROPOSAL_TYPE_TO_FORUM_SECTION = {
+  Admin: "admin",
+  Constitution: "constitution",
+  Decision: "decision",
+  Election: "election",
+  Treasury: "treasury"
+};
+var IDEA_SECTION_ALIASES = /* @__PURE__ */ new Set(["ideas", "ideas-suggestions", "suggestions"]);
+function expectedForumSectionForProposalType(typeLabel2) {
+  return PROPOSAL_TYPE_TO_FORUM_SECTION[typeLabel2] ?? null;
+}
+function isForumIdeaSection(section) {
+  return IDEA_SECTION_ALIASES.has(String(section || "").toLowerCase());
+}
+function applyForumSectionCheck(out, section, cid) {
+  const forumSection = section?.trim() || null;
+  const forumCid = cid != null && Number(cid) > 0 ? Number(cid) : null;
+  const expected = expectedForumSectionForProposalType(out.typeLabel);
+  const added = [];
+  if (forumSection === FORUM_IDEA_SECTION || isForumIdeaSection(forumSection ?? void 0)) {
+    added.push(
+      "Forum thread is in Ideas & Suggestions, not a Governance proposal category. Ideas are discussion only and must not be used as forumKey."
+    );
+  } else if (expected && forumSection && forumSection !== expected) {
+    added.push(`Forum section is ${forumSection} but proposal type is ${out.typeLabel} (expected ${expected}).`);
+  }
+  const extraLine = forumSection === FORUM_IDEA_SECTION || isForumIdeaSection(forumSection ?? void 0) ? `Forum section: ideas (mismatch \u2014 expected ${expected ?? "a Governance category"}).` : expected && forumSection && forumSection !== expected ? `Forum section: ${forumSection} (mismatch \u2014 expected ${expected}).` : forumSection ? `Forum section: ${forumSection}` : null;
+  const lines = out.briefing.split("\n");
+  if (extraLine) {
+    const forumLine = lines.findIndex((l) => l.startsWith("Forum:"));
+    if (forumLine >= 0) lines.splice(forumLine + 1, 0, extraLine);
+    else lines.splice(1, 0, extraLine);
+  }
+  if (added.length) {
+    if (!lines.includes("Risks:")) lines.push("Risks:");
+    for (const r of added) lines.push(`- ${r}`);
+  }
+  return { ...out, briefing: lines.join("\n"), risks: [...out.risks, ...added], forumSection, forumCid };
+}
+var FORUM_LOGIN_DELIVERY_KIND = "forumLogin";
+function continuumDaoForumUrl(explicit) {
+  const raw = explicit?.trim() || (typeof process !== "undefined" ? process.env.FORUM_URL || process.env.NEXT_PUBLIC_FORUM_URL : "") || DEFAULT_FORUM_URL;
+  return raw.replace(/\/+$/, "");
+}
+function assertContinuumDaoForumTopicKey(forumKey, forumUrl) {
+  const raw = String(forumKey || "").trim();
+  if (!raw) {
+    throw new Error(
+      "A forum thread is required. Create one with ctm_continuum_dao_forum_create_topic in a Governance section (decision / election / treasury / constitution / admin) before propose or register_proposal. Ideas & Suggestions threads are not valid forumKey values."
+    );
+  }
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error("forumKey must be a full forum topic URL (https://forum.continuumdao.org/topic/123).");
+  }
+  const expected = new URL(`${continuumDaoForumUrl(forumUrl)}/`);
+  if (url.host !== expected.host) {
+    throw new Error(`forumKey must be on ${expected.host}.`);
+  }
+  if (!/\/(?:topic|t)\/\d+/.test(url.pathname)) {
+    throw new Error("forumKey must be a created thread (/topic/:tid or /t/:tid), not the forum homepage.");
+  }
+  return raw.replace(/\/+$/, "");
+}
+function forumError(body, status) {
+  const o = body && typeof body === "object" ? body : {};
+  const st = o.status && typeof o.status === "object" ? o.status : null;
+  const msg = st && typeof st.message === "string" && st.message || typeof o.message === "string" && o.message || `forum HTTP ${status}`;
+  return new Error(msg);
+}
+async function forumFetch(path, init = {}) {
+  const url = `${continuumDaoForumUrl(init.forumUrl)}${path}`;
+  const headers = {
+    Accept: "application/json",
+    ...init.body ? { "Content-Type": "application/json" } : {}
+  };
+  if (init.ticket) {
+    headers.Authorization = `Bearer ${init.ticket}`;
+  }
+  const res = await fetch(url, {
+    method: init.method || "GET",
+    headers,
+    body: init.body,
+    cache: "no-store"
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw forumError(body, res.status);
+  }
+  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 });
+}
+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 });
+}
+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 });
+}
+async function continuumDaoForumFetchPost(args) {
+  return forumFetch(`/api/continuum/forum/post?pid=${encodeURIComponent(String(args.pid))}`, {
+    forumUrl: args.forumUrl
+  });
+}
+function assertForumHours(hours) {
+  if (hours != null && (!Number.isFinite(hours) || hours <= 0)) {
+    throw new Error("hours must be a positive number");
+  }
+}
+function assertContinuumDaoForumSearchInput(args) {
+  assertForumHours(args.hours);
+  if (!args.query?.trim() && args.hours == null && !args.since?.trim()) {
+    throw new Error("Provide query and/or a time filter (hours or since)");
+  }
+}
+function assertContinuumDaoForumRecentInput(args) {
+  assertForumHours(args.hours);
+  if (args.hours == null && !args.since?.trim()) {
+    throw new Error("Provide a time filter (hours or since)");
+  }
+}
+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 });
+}
+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}`, {
+    forumUrl: args.forumUrl,
+    ticket: args.ticket
+  });
+}
+function assertContinuumDaoForumDeleteInput(args) {
+  if (!args.ticket?.trim()) {
+    throw new Error("ticket is required to delete forum posts");
+  }
+  assertForumHours(args.hours);
+  const hasPost = args.pid != null && String(args.pid).trim() !== "";
+  const hasThread = Boolean(args.url?.trim() || args.tid != null && String(args.tid).trim() !== "");
+  const hasUser = Boolean(args.username?.trim());
+  if (Number(hasPost) + Number(hasThread) + Number(hasUser) !== 1) {
+    throw new Error("Provide exactly one of pid, tid/url, or username");
+  }
+}
+async function continuumDaoForumDelete(args) {
+  assertContinuumDaoForumDeleteInput(args);
+  return forumFetch("/api/continuum/forum/delete", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({
+      pid: args.pid,
+      tid: args.tid,
+      url: args.url,
+      username: args.username,
+      hours: args.hours,
+      since: args.since
+    })
+  });
+}
+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 });
+}
+async function continuumDaoForumReply(args) {
+  return forumFetch("/api/continuum/forum/reply", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({
+      url: args.url,
+      tid: args.tid,
+      content: args.content,
+      toPid: args.toPid
+    })
+  });
+}
+async function continuumDaoForumReact(args) {
+  return forumFetch("/api/continuum/forum/react", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({ pid: args.pid, emoji: args.emoji })
+  });
+}
+async function continuumDaoForumCreateTopic(args) {
+  if (isForumIdeaSection(args.section)) {
+    throw new Error(
+      "Ideas & Suggestions is not a proposal category. Use ctm_continuum_dao_forum_create_idea for discussion. Formal proposals must use decision, election, treasury, constitution, or admin."
+    );
+  }
+  return forumFetch("/api/continuum/forum/topic", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({
+      section: args.section,
+      cid: args.cid,
+      title: args.title,
+      content: args.content
+    })
+  });
+}
+async function continuumDaoForumCreateIdea(args) {
+  return forumFetch("/api/continuum/forum/topic", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({
+      section: FORUM_IDEA_SECTION,
+      title: args.title,
+      content: args.content
+    })
+  });
+}
+async function continuumDaoForumMe(args = {}) {
+  return forumFetch("/api/continuum/forum/me", { forumUrl: args.forumUrl, ticket: args.ticket });
+}
+function assertContinuumDaoForumMarkReadInput(args) {
+  if (!args.ticket?.trim()) {
+    throw new Error("ticket is required to mark forum topics read");
+  }
+  const all = Boolean(args.all);
+  const one = Boolean(args.url?.trim() || args.tid != null && String(args.tid).trim() !== "");
+  const many = Array.isArray(args.tids) && args.tids.length > 0;
+  if (Number(all) + Number(one) + Number(many) !== 1) {
+    throw new Error("Provide exactly one of tid/url, tids, or all");
+  }
+}
+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}` : "";
+  return forumFetch(`/api/continuum/forum/unread${suffix}`, {
+    forumUrl: args.forumUrl,
+    ticket: args.ticket
+  });
+}
+async function continuumDaoForumMarkRead(args) {
+  assertContinuumDaoForumMarkReadInput(args);
+  return forumFetch("/api/continuum/forum/read", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({
+      tid: args.tid,
+      url: args.url,
+      tids: args.tids,
+      all: args.all
+    })
+  });
+}
+async function continuumDaoForumMarkUnread(args) {
+  if (!args.ticket?.trim()) {
+    throw new Error("ticket is required to mark a forum topic unread");
+  }
+  if (!args.url?.trim() && (args.tid == null || String(args.tid).trim() === "")) {
+    throw new Error("Provide tid or url");
+  }
+  return forumFetch("/api/continuum/forum/unread", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({ tid: args.tid, url: args.url })
+  });
+}
+async function continuumDaoForumSections(args = {}) {
+  return forumFetch("/api/continuum/forum/sections", { forumUrl: args.forumUrl });
+}
+async function continuumDaoForumSignOut(args = {}) {
+  if (!args.ticket?.trim()) {
+    throw new Error("ticket is required to sign out");
+  }
+  return forumFetch("/api/continuum/eip712/logout", {
+    method: "POST",
+    forumUrl: args.forumUrl,
+    ticket: args.ticket,
+    body: JSON.stringify({})
+  });
+}
+async function continuumDaoForumSignInEligible(args) {
+  const address = getAddress(args.address);
+  const url = `${continuumDaoForumUrl(args.forumUrl)}/api/continuum/eip712/eligible?address=${encodeURIComponent(address)}`;
+  const res = await fetch(url, { headers: { Accept: "application/json" }, cache: "no-store" });
+  const body = await res.json().catch(() => ({}));
+  const st = body.status && typeof body.status === "object" ? body.status : null;
+  const reason = typeof body.reason === "string" && body.reason || st && typeof st.message === "string" && st.message || void 0;
+  const ok = res.ok && Boolean(body.ok ?? body.eligible);
+  return {
+    ok,
+    eligible: ok,
+    address: typeof body.address === "string" ? body.address : address,
+    reason: ok ? void 0 : reason || "Address does not meet the veCTM threshold"
+  };
+}
+async function continuumDaoForumSignInNonce(args) {
+  const qs = new URLSearchParams({
+    address: args.address,
+    nodeKey: args.nodeKey || "",
+    username: args.username || ""
+  });
+  return forumFetch(`/api/continuum/eip712/nonce?${qs}`, { forumUrl: args.forumUrl });
+}
+async function buildEvmMultisignBodyContinuumDaoForumSignIn(args) {
+  const owner = getAddress(args.executorAddress);
+  const gate = await continuumDaoForumSignInEligible({ address: owner, forumUrl: args.forumUrl });
+  if (!gate.ok) {
+    throw new Error(
+      `${gate.reason || "Address does not meet the veCTM threshold"}. Do not start a multi-sign request.`
+    );
+  }
+  const typed = await continuumDaoForumSignInNonce({
+    address: owner,
+    nodeKey: args.nodeKey,
+    username: args.username,
+    forumUrl: args.forumUrl
+  });
+  const types = { ...typed.types };
+  delete types.EIP712Domain;
+  return buildEip712Multisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: owner,
+    legs: [
+      {
+        typedData: {
+          domain: typed.domain,
+          types,
+          primaryType: typed.primaryType,
+          message: typed.message
+        },
+        delivery: {
+          kind: FORUM_LOGIN_DELIVERY_KIND,
+          forum: continuumDaoForumUrl(args.forumUrl),
+          nodeKey: args.nodeKey || typed.nodeKey || ""
+        }
+      }
+    ],
+    expiryDate: args.expiryDate
+  });
+}
+
+// src/protocols/evm/continuum-dao/governance.ts
+var CONTINUUM_DAO_PROPOSE_FALLBACK = 550000n;
+var CONTINUUM_DAO_VOTE_FALLBACK = 220000n;
+var CONTINUUM_DAO_EXECUTE_FALLBACK = 800000n;
+var CONTINUUM_DAO_CANCEL_FALLBACK = 180000n;
+var CONTINUUM_DAO_GOV_EVM_TYPES = /* @__PURE__ */ new Set([
+  "continuum_dao_propose",
+  "continuum_dao_cast_vote",
+  "continuum_dao_execute",
+  "continuum_dao_cancel"
+]);
+var governorWriteAbi = parseAbi([
+  "function propose(address[] targets, uint256[] values, bytes[] calldatas, string description) returns (uint256)",
+  "function castVote(uint256 proposalId, uint8 support) returns (uint256)",
+  "function castVoteWithReasonAndParams(uint256 proposalId, uint8 support, string reason, bytes params) returns (uint256)",
+  "function execute(uint256 proposalId) payable",
+  "function cancel(uint256 proposalId)"
+]);
+var governorReadAbi = parseAbi([
+  "function hashProposal(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) view returns (uint256)",
+  "function state(uint256 proposalId) view returns (uint8)",
+  "function getVotes(address account, uint256 timepoint) view returns (uint256)",
+  "function proposalThreshold() view returns (uint256)",
+  "function proposalCount() view returns (uint256)",
+  "function clock() view returns (uint48)",
+  "function proposalVotes(uint256 proposalId) view returns (uint256 againstVotes, uint256 forVotes, uint256 abstainVotes)"
+]);
+function splitAbiParamList(inner) {
+  const out = [];
+  let buf = "";
+  let depth = 0;
+  for (const ch of inner) {
+    if (ch === "(") depth += 1;
+    if (ch === ")") depth -= 1;
+    if (ch === "," && depth === 0) {
+      if (buf.trim()) out.push(buf.trim());
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim()) out.push(buf.trim());
+  return out;
+}
+function signatureToAbiInputs(signature) {
+  const start = signature.indexOf("(");
+  if (start === -1) return [];
+  let depth = 0;
+  let end = -1;
+  for (let i = start; i < signature.length; i++) {
+    const ch = signature[i];
+    if (ch === "(") depth += 1;
+    if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  if (end === -1) return [];
+  const inner = signature.slice(start + 1, end);
+  if (!inner.trim()) return [];
+  return splitAbiParamList(inner).map((t) => ({ type: t }));
+}
+function coerceAbiValue(type, value) {
+  const trimmed = (value ?? "").trim();
+  if (type.startsWith("(") && type.endsWith(")")) {
+    const parsed = JSON.parse(trimmed || "[]");
+    if (!Array.isArray(parsed)) throw new Error("tuple value must be a JSON array");
+    const parts = splitAbiParamList(type.slice(1, -1));
+    return parts.map((part, i) => {
+      const child = parsed[i];
+      if (typeof child === "string") return coerceAbiValue(part, child);
+      return coerceAbiValue(part, JSON.stringify(child ?? ""));
+    });
+  }
+  const fixed = type.match(/^(.+)\[(\d+)\]$/);
+  if (fixed && !type.endsWith("[]")) {
+    const parsed = trimmed.startsWith("[") ? JSON.parse(trimmed) : trimmed.split(",");
+    if (!Array.isArray(parsed)) throw new Error("fixed array value must be a JSON array");
+    return parsed.map((x) => coerceAbiValue(fixed[1], String(x)));
+  }
+  if (type.endsWith("[]")) {
+    const arr = trimmed.startsWith("[") ? JSON.parse(trimmed).map((x) => String(x)) : trimmed ? trimmed.split(",").map((s) => s.trim()) : [];
+    const baseType = type.slice(0, -2);
+    return arr.map((v) => coerceAbiValue(baseType, v));
+  }
+  if (type === "address") return trimmed;
+  if (type.startsWith("uint") || type.startsWith("int")) return BigInt(trimmed || "0");
+  if (type === "bool") return trimmed === "true" || trimmed === "1";
+  return trimmed;
+}
+function encodeGovActionCalldata(signature, inputs = []) {
+  const sig = signature.trim();
+  if (!sig) return "0x";
+  const name = sig.slice(0, sig.indexOf("(") === -1 ? sig.length : sig.indexOf("("));
+  const types = signatureToAbiInputs(sig);
+  if (types.length !== inputs.length) throw new Error("encodeGovActionCalldata: inputs length mismatch");
+  const args = inputs.map((inp, i) => coerceAbiValue(types[i].type, inp.value));
+  return encodeFunctionData({
+    abi: [
+      {
+        type: "function",
+        name,
+        inputs: types.map((t, i) => ({ name: `arg${i}`, type: t.type })),
+        outputs: [],
+        stateMutability: "nonpayable"
+      }
+    ],
+    functionName: name,
+    args
+  });
+}
+function proposalDescriptionHash(description) {
+  return keccak256(encodePacked(["string"], [description]));
+}
+function encodeDeltaMetadata(nOptions, nWinners, optionStartIndices) {
+  if (optionStartIndices.length !== nOptions) {
+    throw new Error("encodeDeltaMetadata: optionStartIndices length must equal nOptions");
+  }
+  const parts = [
+    padHex(toHex(nOptions), { size: 32 }).slice(2),
+    padHex(toHex(nWinners), { size: 32 }).slice(2),
+    ...optionStartIndices.map((i) => padHex(toHex(i), { size: 32 }).slice(2))
+  ];
+  return `0x${parts.join("")}`;
+}
+function encodeDeltaVoteParams(weights) {
+  if (weights.length < 3) throw new Error("Delta vote params need nOptions + NOTA (at least 3 slots).");
+  return `0x${weights.map((w) => padHex(toHex(BigInt(w)), { size: 32 }).slice(2)).join("")}`;
+}
+function noOpAction(noOpTarget) {
+  return { target: getAddress(noOpTarget), value: 0n, calldata: "0x" };
+}
+function encodeUserAction(a) {
+  const target = getAddress(a.target);
+  if (target === zeroAddress) throw new Error("Action target cannot be the zero address (reserved for Delta metadata).");
+  const value = BigInt(String(a.value || "0"));
+  const calldata = encodeGovActionCalldata(a.signature ?? "", a.inputs ?? []);
+  return { target, value, calldata };
+}
+function buildBravoProposalArgs(actions, description, noOpTarget) {
+  const encoded = actions.length === 0 ? [noOpAction(getAddress(noOpTarget))] : actions.map(encodeUserAction);
+  if (encoded[0].target === zeroAddress) {
+    throw new Error("Bravo first target cannot be address(0); that encoding is Delta.");
+  }
+  return {
+    targets: encoded.map((e) => e.target),
+    values: encoded.map((e) => e.value),
+    calldatas: encoded.map((e) => e.calldata),
+    description
+  };
+}
+function buildDeltaProposalArgs(options, nWinners, description, noOpTarget) {
+  if (options.length < 2) throw new Error("Delta proposals need at least 2 options.");
+  if (nWinners < 1 || nWinners >= options.length) throw new Error("Delta nWinners must be >= 1 and < nOptions.");
+  const fallback = getAddress(noOpTarget);
+  const targets = [zeroAddress];
+  const values = [0n];
+  const calldatas = [];
+  const optionStartIndices = [];
+  let nextIndex = 1;
+  for (const opt of options) {
+    optionStartIndices.push(nextIndex);
+    const userActions = opt.actions ?? [];
+    const encoded = userActions.length === 0 ? [noOpAction(fallback)] : userActions.map(encodeUserAction);
+    for (const e of encoded) {
+      targets.push(e.target);
+      values.push(e.value);
+      calldatas.push(e.calldata);
+      nextIndex += 1;
+    }
+  }
+  calldatas.unshift(encodeDeltaMetadata(options.length, nWinners, optionStartIndices));
+  return { targets, values, calldatas, description };
+}
+function requireGovChain(chainId) {
+  if (!isContinuumDaoLockChain(chainId)) {
+    throw new Error("ContinuumDAO governance is Linea-only.");
+  }
+}
+function requireGovernor(chainId, override) {
+  requireGovChain(chainId);
+  if (override && isConfiguredAddress(override)) return getAddress(override);
+  const gov = governorAddressOnEvmChain(chainId);
+  if (!gov) throw new Error("Governor address is not configured for this chain yet.");
+  return gov;
+}
+function meta2(evmType, chainId, to, extra, gasLimit) {
+  return {
+    destinationAddress: to,
+    signatureText: JSON.stringify({ kind: "ContinuumDAO", ...extra, chainId }),
+    evm: { type: evmType, version: 1, chainId: String(chainId), protocolId: CONTINUUM_DAO_PROTOCOL_ID },
+    continuumDao: { ...extra, gas: { baseGasUnits: gasLimit.toString() } }
+  };
+}
+async function finalizeGov(args, to, data, fallbackGas, evmType, extra, purposeSuffix, value = 0n) {
+  const step = { to, data, value, fallbackGas };
+  const firstDataNo0x = data.startsWith("0x") ? data.slice(2) : 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: [step],
+    purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: to,
+    buildBatchMeta: ({ gasLimit }) => meta2(evmType, args.chainId, to, extra, gasLimit)
+  });
+}
+async function requireProposalThreshold(args) {
+  const power = await continuumDaoFetchVotingPower({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    account: args.executorAddress,
+    governor: args.governor
+  });
+  if (BigInt(power.votes) < BigInt(power.threshold)) {
+    throw new Error(
+      `Proposer voting power ${power.votes} is below ContinuumDAO.proposalThreshold() ${power.threshold}. On-chain rule: max(1000e18 ve power, 1% of total voting power). Delegation applies at the KeyGen ETH address.`
+    );
+  }
+  return power;
+}
+async function buildEvmMultisignBodyContinuumDaoProposeBravo(args) {
+  const forumKey = assertContinuumDaoForumTopicKey(args.forumKey, args.forumUrl);
+  const gov = requireGovernor(args.chainId, args.governor);
+  await requireProposalThreshold(args);
+  const noOp = args.noOpTarget?.trim() || args.executorAddress;
+  const proposalArgs = buildBravoProposalArgs(args.actions ?? [], args.title.trim(), noOp);
+  const data = encodeFunctionData({
+    abi: governorWriteAbi,
+    functionName: "propose",
+    args: [proposalArgs.targets, proposalArgs.values, proposalArgs.calldatas, proposalArgs.description]
+  });
+  const built = await finalizeGov(
+    args,
+    gov,
+    data,
+    CONTINUUM_DAO_PROPOSE_FALLBACK,
+    "continuum_dao_propose",
+    { name: "ContinuumDAO.propose", configuration: "bravo", title: proposalArgs.description, forumKey },
+    "continuum-dao propose bravo"
+  );
+  return { ...built, proposalArgs };
+}
+async function buildEvmMultisignBodyContinuumDaoProposeDelta(args) {
+  const forumKey = assertContinuumDaoForumTopicKey(args.forumKey, args.forumUrl);
+  const gov = requireGovernor(args.chainId, args.governor);
+  await requireProposalThreshold(args);
+  const noOp = args.noOpTarget?.trim() || args.executorAddress;
+  const proposalArgs = buildDeltaProposalArgs(args.options, Number(args.nWinners), args.title.trim(), noOp);
+  const data = encodeFunctionData({
+    abi: governorWriteAbi,
+    functionName: "propose",
+    args: [proposalArgs.targets, proposalArgs.values, proposalArgs.calldatas, proposalArgs.description]
+  });
+  const built = await finalizeGov(
+    args,
+    gov,
+    data,
+    CONTINUUM_DAO_PROPOSE_FALLBACK,
+    "continuum_dao_propose",
+    { name: "ContinuumDAO.propose", configuration: "delta", title: proposalArgs.description, nWinners: args.nWinners, forumKey },
+    "continuum-dao propose delta"
+  );
+  return { ...built, proposalArgs };
+}
+async function buildEvmMultisignBodyContinuumDaoCastVoteBravo(args) {
+  const gov = requireGovernor(args.chainId, args.governor);
+  const proposalId = BigInt(String(args.proposalId).trim());
+  const data = encodeFunctionData({
+    abi: governorWriteAbi,
+    functionName: "castVote",
+    args: [proposalId, args.support]
+  });
+  return finalizeGov(
+    args,
+    gov,
+    data,
+    CONTINUUM_DAO_VOTE_FALLBACK,
+    "continuum_dao_cast_vote",
+    { name: "ContinuumDAO.castVote", proposalId: proposalId.toString(), support: args.support },
+    "continuum-dao vote bravo"
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoCastVoteDelta(args) {
+  const gov = requireGovernor(args.chainId, args.governor);
+  const proposalId = BigInt(String(args.proposalId).trim());
+  const params = encodeDeltaVoteParams(args.weights);
+  const data = encodeFunctionData({
+    abi: governorWriteAbi,
+    functionName: "castVoteWithReasonAndParams",
+    args: [proposalId, 0, "", params]
+  });
+  return finalizeGov(
+    args,
+    gov,
+    data,
+    CONTINUUM_DAO_VOTE_FALLBACK,
+    "continuum_dao_cast_vote",
+    { name: "ContinuumDAO.castVoteWithReasonAndParams", proposalId: proposalId.toString() },
+    "continuum-dao vote delta"
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoExecute(args) {
+  const gov = requireGovernor(args.chainId, args.governor);
+  const proposalId = BigInt(String(args.proposalId).trim());
+  const data = encodeFunctionData({
+    abi: governorWriteAbi,
+    functionName: "execute",
+    args: [proposalId]
+  });
+  return finalizeGov(
+    args,
+    gov,
+    data,
+    CONTINUUM_DAO_EXECUTE_FALLBACK,
+    "continuum_dao_execute",
+    { name: "ContinuumDAO.execute", proposalId: proposalId.toString() },
+    "continuum-dao execute"
+  );
+}
+async function buildEvmMultisignBodyContinuumDaoCancel(args) {
+  const gov = requireGovernor(args.chainId, args.governor);
+  const proposalId = BigInt(String(args.proposalId).trim());
+  const data = encodeFunctionData({
+    abi: governorWriteAbi,
+    functionName: "cancel",
+    args: [proposalId]
+  });
+  return finalizeGov(
+    args,
+    gov,
+    data,
+    CONTINUUM_DAO_CANCEL_FALLBACK,
+    "continuum_dao_cancel",
+    { name: "ContinuumDAO.cancel", proposalId: proposalId.toString() },
+    "continuum-dao cancel"
+  );
+}
+function publicClient(rpcUrl, chainId) {
+  return createPublicClient({
+    chain: defineChain({
+      id: chainId,
+      name: "ContinuumDAO",
+      nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+      rpcUrls: { default: { http: [rpcUrl.trim()] } }
+    }),
+    transport: http(rpcUrl.trim())
+  });
+}
+async function continuumDaoHashProposal(args) {
+  const chainId = Number(args.chainId);
+  const gov = requireGovernor(chainId, args.governor);
+  const client = publicClient(args.rpcUrl, chainId);
+  const id = await client.readContract({
+    address: gov,
+    abi: governorReadAbi,
+    functionName: "hashProposal",
+    args: [args.targets, args.values, args.calldatas, proposalDescriptionHash(args.description)]
+  });
+  return { proposalId: id.toString() };
+}
+async function continuumDaoFetchVotingPower(args) {
+  const chainId = Number(args.chainId);
+  const gov = requireGovernor(chainId, args.governor);
+  const client = publicClient(args.rpcUrl, chainId);
+  const clock = await client.readContract({ address: gov, abi: governorReadAbi, functionName: "clock" });
+  const timepoint = clock > 0 ? clock - 1 : 0;
+  const [votes, threshold] = await Promise.all([
+    client.readContract({
+      address: gov,
+      abi: governorReadAbi,
+      functionName: "getVotes",
+      args: [getAddress(args.account), BigInt(timepoint)]
+    }),
+    client.readContract({ address: gov, abi: governorReadAbi, functionName: "proposalThreshold" })
+  ]);
+  return { votes: votes.toString(), threshold: threshold.toString(), clock: clock.toString() };
+}
+async function continuumDaoFetchProposalState(args) {
+  const chainId = Number(args.chainId);
+  const gov = requireGovernor(chainId, args.governor);
+  const client = publicClient(args.rpcUrl, chainId);
+  const proposalId = BigInt(String(args.proposalId).trim());
+  const [state, votes] = await Promise.all([
+    client.readContract({ address: gov, abi: governorReadAbi, functionName: "state", args: [proposalId] }),
+    client.readContract({ address: gov, abi: governorReadAbi, functionName: "proposalVotes", args: [proposalId] })
+  ]);
+  return {
+    state: Number(state),
+    againstVotes: votes[0].toString(),
+    forVotes: votes[1].toString(),
+    abstainVotes: votes[2].toString()
+  };
+}
+async function continuumDaoFetchProposalCount(args) {
+  const gov = requireGovernor(args.chainId, args.governor);
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const count = await client.readContract({ address: gov, abi: governorReadAbi, functionName: "proposalCount" });
+  return { count: count.toString() };
+}
+async function continuumDaoFetchProposals(args) {
+  const start = args.start ?? 0;
+  const end = args.end ?? start + 20;
+  const res = await fetch(`${CONTINUUM_DAO_GOVERNANCE_API}/proposals`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ start, end })
+  });
+  if (!res.ok) throw new Error(`proposals: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
+var GOVERNOR_STATE = {
+  Pending: 0,
+  Active: 1,
+  Canceled: 2,
+  Defeated: 3,
+  Succeeded: 4,
+  Queued: 5,
+  Expired: 6,
+  Executed: 7
+};
+var GOVERNOR_STATE_LABELS = [
+  "Pending",
+  "Active",
+  "Canceled",
+  "Defeated",
+  "Succeeded",
+  "Queued",
+  "Expired",
+  "Executed"
+];
+function bucketGovernorState(state) {
+  if (state == null || !Number.isFinite(state)) return "unknown";
+  if (state === GOVERNOR_STATE.Active) return "live";
+  if (state === GOVERNOR_STATE.Pending) return "pending";
+  if (state === GOVERNOR_STATE.Succeeded) return "readyToExecute";
+  if (state === GOVERNOR_STATE.Canceled || state === GOVERNOR_STATE.Defeated || state === GOVERNOR_STATE.Queued || state === GOVERNOR_STATE.Expired || state === GOVERNOR_STATE.Executed) {
+    return "recentlyCompleted";
+  }
+  return "unknown";
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseBackendProposal(raw) {
+  const row = asRecord(raw);
+  if (!row) return null;
+  const onchainId = String(row.onchainId ?? row.onchain_id ?? row.proposalId ?? "").trim();
+  if (!onchainId) return null;
+  const idRaw = row.id;
+  const id = typeof idRaw === "number" ? idRaw : Number(idRaw);
+  return {
+    id: Number.isFinite(id) ? id : void 0,
+    onchainId,
+    title: String(row.title ?? "Untitled"),
+    configuration: typeof row.configuration === "number" ? row.configuration : void 0
+  };
+}
+function summarizeLiveProposals(result) {
+  if (result.overlay === "backend-only") {
+    return `Scanned ${result.scanned} backend proposal(s) but could not overlay ContinuumDAO.state. Do not call them live. Pass Linea chainId + rpcUrl + a non-zero governor.`;
+  }
+  const liveTitles = result.live.map((p) => `#${p.id ?? "\u2014"} ${p.title}`).join("; ") || "none";
+  const execTitles = result.readyToExecute.map((p) => `#${p.id ?? "\u2014"} ${p.title}`).join("; ") || "none";
+  return `Live (Active, voting now): ${result.live.length} (${liveTitles}). Pending: ${result.pending.length}. Passed, ready to execute (Succeeded): ${result.readyToExecute.length} (${execTitles}). Recently completed in this scan: ${result.recentlyCompleted.length}. Queue is not implemented.`;
+}
+async function mapPool(items, concurrency, fn) {
+  const out = [];
+  let i = 0;
+  const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+    while (i < items.length) {
+      const idx = i;
+      i += 1;
+      out[idx] = await fn(items[idx]);
+    }
+  });
+  await Promise.all(workers);
+  return out;
+}
+async function continuumDaoFetchLiveProposals(args) {
+  const limit = Math.min(Math.max(Number(args.limit) || 40, 1), 100);
+  const completedLimit = Math.min(Math.max(Number(args.completedLimit) || 8, 0), 20);
+  const listed = await continuumDaoFetchProposals({ start: 0, end: limit });
+  const rawList = Array.isArray(listed.proposals) ? listed.proposals : [];
+  const parsed = rawList.map(parseBackendProposal).filter((p) => p != null);
+  const chainId = args.chainId != null && String(args.chainId).trim() !== "" ? Number(args.chainId) : NaN;
+  const rpcUrl = (args.rpcUrl ?? "").trim();
+  let overlay = "backend-only";
+  try {
+    if (rpcUrl && Number.isFinite(chainId)) {
+      requireGovernor(chainId, args.governor);
+      overlay = "on-chain";
+    }
+  } catch {
+    overlay = "backend-only";
+  }
+  const rows = overlay === "on-chain" ? await mapPool(parsed, 6, async (p) => {
+    try {
+      const st = await continuumDaoFetchProposalState({
+        chainId,
+        rpcUrl,
+        proposalId: p.onchainId,
+        governor: args.governor
+      });
+      return {
+        ...p,
+        state: st.state,
+        stateLabel: GOVERNOR_STATE_LABELS[st.state] ?? String(st.state),
+        bucket: bucketGovernorState(st.state),
+        againstVotes: st.againstVotes,
+        forVotes: st.forVotes,
+        abstainVotes: st.abstainVotes
+      };
+    } catch {
+      return { ...p, state: null, stateLabel: "Unknown", bucket: "unknown" };
+    }
+  }) : parsed.map((p) => ({ ...p, state: null, stateLabel: "Unknown", bucket: "unknown" }));
+  const live = rows.filter((r) => r.bucket === "live");
+  const pending = rows.filter((r) => r.bucket === "pending");
+  const readyToExecute = rows.filter((r) => r.bucket === "readyToExecute");
+  const recentlyCompleted = rows.filter((r) => r.bucket === "recentlyCompleted").slice(0, completedLimit);
+  const unknown = rows.filter((r) => r.bucket === "unknown");
+  const grouped = {
+    overlay,
+    scanned: rows.length,
+    live,
+    pending,
+    readyToExecute,
+    recentlyCompleted,
+    unknown
+  };
+  return { ...grouped, note: summarizeLiveProposals(grouped) };
+}
+async function continuumDaoFetchProposal(args) {
+  const res = await fetch(`${CONTINUUM_DAO_GOVERNANCE_API}/proposals/${args.id}`, { cache: "no-store" });
+  if (!res.ok) throw new Error(`proposal: ${res.status} ${await res.text()}`);
+  return { proposal: await res.json() };
+}
+async function buildEvmMultisignBodyContinuumDaoProposeDeltaFromMcp(args) {
+  return buildEvmMultisignBodyContinuumDaoProposeDelta({
+    ...args,
+    nWinners: Number(args.nWinners)
+  });
+}
+async function buildEvmMultisignBodyContinuumDaoCastVoteBravoFromMcp(args) {
+  const support = Number(args.support);
+  if (support !== 0 && support !== 1 && support !== 2) throw new Error("Bravo support must be 0, 1, or 2.");
+  return buildEvmMultisignBodyContinuumDaoCastVoteBravo({ ...args, support });
+}
+async function continuumDaoRegisterProposal(payload) {
+  assertContinuumDaoForumTopicKey(payload.forumKey);
+  const res = await fetch(`${CONTINUUM_DAO_GOVERNANCE_API}/proposals/create`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) throw new Error(`proposals/create: ${res.status} ${await res.text()}`);
+  return { ok: true, result: await res.json() };
+}
+
+// src/protocols/evm/continuum-dao/explainProposal.ts
+var PROPOSAL_TYPE_LABELS = ["Admin", "Constitution", "Decision", "Election", "Treasury"];
+var APPROVE_RE = /^(approve|increaseAllowance|increaseapproval)\(/i;
+var DENY_SIG_RE = /^(transfer|transferFrom|approve|increaseAllowance|setOwner|upgradeTo|upgradeToAndCall)\(/i;
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function str(v, fallback = "") {
+  return v == null ? fallback : String(v);
+}
+function isGovNoOpAction(action) {
+  const value = (action.value ?? "0").trim();
+  const sig = (action.signature ?? "").trim();
+  const data = (action.calldata ?? "").trim();
+  const emptyData = data === "" || data === "0x";
+  return (value === "" || value === "0") && sig === "" && emptyData;
+}
+function explainGovAction(raw) {
+  const a = asRecord2(raw) ?? {};
+  const net = asRecord2(a.network) ?? {};
+  const networkLabel = str(net.label || net.name, "Unknown network");
+  const chainId = str(net.chainId);
+  const c3 = str(net.c3governor);
+  const viaC3 = Boolean(c3 && c3 !== "0x0000000000000000000000000000000000000000");
+  const target = str(a.target);
+  const value = str(a.value, "0");
+  const signature = str(a.signature);
+  const inputs = Array.isArray(a.inputs) ? a.inputs : [];
+  const inputParts = inputs.map((inp) => {
+    const row = asRecord2(inp) ?? {};
+    return `${str(row.name || row.type, "arg")}=${str(row.value)}`;
+  });
+  const noOp = isGovNoOpAction({ value, signature, calldata: str(a.calldata) });
+  const flags = [];
+  if (noOp) flags.push("signaling-noop");
+  if (viaC3) flags.push("c3-remote");
+  if (BigInt(value || "0") > 0n) flags.push("sends-value");
+  if (APPROVE_RE.test(signature)) flags.push("allowance");
+  if (DENY_SIG_RE.test(signature)) flags.push("sensitive-signature");
+  if (!noOp && !signature) flags.push("unknown-signature");
+  const valueBit = BigInt(value || "0") > 0n ? `; send ${value} wei` : "";
+  const argsBit = inputParts.length ? ` with ${inputParts.join(", ")}` : "";
+  const c3Bit = viaC3 ? " via C3" : "";
+  const line = noOp ? `On ${networkLabel}${c3Bit}: no on-chain effect (encoder no-op / signaling).` : `On ${networkLabel} (chain ${chainId || "\u2014"})${c3Bit}: call ${signature || "(no signature)"} on ${target || "\u2014"} ${argsBit}${valueBit}.`.replace(/\s+/g, " ").trim();
+  return { line, noOp, networkLabel, chainId, viaC3, target, value, signature, flags };
+}
+function typeLabel(type) {
+  const n = Number(type);
+  return Number.isFinite(n) && PROPOSAL_TYPE_LABELS[n] ? PROPOSAL_TYPE_LABELS[n] : str(type, "Unknown");
+}
+function explainProposalRecord(raw) {
+  const row = asRecord2(raw);
+  if (!row) throw new Error("explain_proposal: empty proposal");
+  const onchainId = str(row.onchainId ?? row.onchain_id ?? row.proposalId);
+  if (!onchainId) throw new Error("explain_proposal: missing onchainId");
+  const configuration = Number(row.configuration) === 1 ? "delta" : "bravo";
+  const nWinners = row.nWinners != null ? Number(row.nWinners) : void 0;
+  const actionsRaw = Array.isArray(row.actions) ? row.actions : [];
+  const optionsRaw = Array.isArray(row.options) ? row.options : [];
+  const actions = actionsRaw.map(explainGovAction);
+  const options = optionsRaw.map((opt) => {
+    const o = asRecord2(opt) ?? {};
+    const optActions = Array.isArray(o.actions) ? o.actions.map(explainGovAction) : [];
+    return { label: str(o.label, "Untitled option"), actions: optActions };
+  });
+  const risks = [];
+  const t = typeLabel(row.type);
+  if (t === "Treasury" || t === "Admin" || t === "Constitution") {
+    risks.push(`${t} proposal \u2014 treat as high impact.`);
+  }
+  const all = configuration === "delta" ? options.flatMap((o) => o.actions) : actions;
+  if (all.some((a) => a.flags.includes("sends-value"))) risks.push("At least one action sends native value.");
+  if (all.some((a) => a.flags.includes("allowance"))) risks.push("At least one action changes token allowance.");
+  if (all.some((a) => a.flags.includes("sensitive-signature"))) risks.push("Sensitive signature (transfer / approve / upgrade / ownership).");
+  if (all.some((a) => a.flags.includes("unknown-signature") && !a.noOp)) risks.push("An action has no readable signature.");
+  if (all.some((a) => a.viaC3)) risks.push("One or more actions execute on another network via C3, not on Linea.");
+  if (!str(row.description).trim() && all.some((a) => !a.noOp)) {
+    risks.push("Empty description with on-chain actions.");
+  }
+  const lines = [];
+  lines.push(`#${row.id ?? "\u2014"} ${str(row.title, "Untitled")} (${t}, ${configuration === "delta" ? "Delta" : "Bravo"}).`);
+  lines.push(`Proposer ${str(row.proposer) || "\u2014"} (any EOA or contract \u2014 not required to be a KeyGen).`);
+  if (str(row.forumKey)) lines.push(`Forum: ${str(row.forumKey)}`);
+  if (configuration === "bravo") {
+    lines.push("If this passes, the DAO will execute, in order:");
+    for (const a of actions) lines.push(`- ${a.line}`);
+    if (actions.length === 0) lines.push("- No user actions (signaling / no-op).");
+  } else {
+    lines.push(`Delta: top ${nWinners ?? "?"} option(s) execute. None of the above (NOTA) is a vote slot, not an option with actions.`);
+    for (const [i, opt] of options.entries()) {
+      lines.push(`Option ${i + 1} \u2014 ${opt.label}:`);
+      for (const a of opt.actions) lines.push(`  - ${a.line}`);
+      if (opt.actions.length === 0) lines.push("  - No user actions (signaling / no-op).");
+    }
+  }
+  if (risks.length) {
+    lines.push("Risks:");
+    for (const r of risks) lines.push(`- ${r}`);
+  }
+  lines.push("Queue is not implemented. Vote while Active; execute from Succeeded.");
+  return {
+    id: typeof row.id === "number" ? row.id : Number(row.id) || void 0,
+    onchainId,
+    title: str(row.title, "Untitled"),
+    description: str(row.description),
+    proposer: str(row.proposer),
+    forumKey: str(row.forumKey),
+    typeLabel: t,
+    configuration,
+    nWinners: Number.isFinite(nWinners) ? nWinners : void 0,
+    briefing: lines.join("\n"),
+    actions,
+    options,
+    risks
+  };
+}
+async function withForumSection(out, forumUrl) {
+  if (!out.forumKey) return out;
+  try {
+    const thread = await continuumDaoForumFetchThread({ url: out.forumKey, index: 0, forumUrl });
+    return applyForumSectionCheck(out, thread.section ?? null, thread.cid ?? null);
+  } catch {
+    return { ...out, forumSection: null, forumCid: null };
+  }
+}
+async function continuumDaoExplainProposal(args) {
+  if (args.id != null && String(args.id).trim() !== "") {
+    const { proposal } = await continuumDaoFetchProposal({ id: args.id });
+    return withForumSection(explainProposalRecord(proposal), args.forumUrl);
+  }
+  const want = (args.onchainId ?? "").trim();
+  if (!want) throw new Error("explain_proposal: pass id or onchainId");
+  const listed = await continuumDaoFetchProposals({ start: 0, end: 80 });
+  const rawList = Array.isArray(listed.proposals) ? listed.proposals : [];
+  const hit = rawList.find((p) => {
+    const row = asRecord2(p);
+    return row && str(row.onchainId ?? row.onchain_id ?? row.proposalId) === want;
+  });
+  if (!hit) throw new Error(`explain_proposal: no catalog row with onchainId ${want}`);
+  const id = asRecord2(hit)?.id;
+  if (id != null) {
+    const { proposal } = await continuumDaoFetchProposal({ id: Number(id) });
+    return withForumSection(explainProposalRecord(proposal), args.forumUrl);
+  }
+  return withForumSection(explainProposalRecord(hit), args.forumUrl);
+}
+
+// src/protocols/evm/continuum-dao/index.ts
+var continuumDaoProtocolModule = {
+  id: CONTINUUM_DAO_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 isContinuumDaoSupportedChainId(n);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "erc20" || token.kind === "erc721");
+  },
+  actions: [
+    { id: "continuum-dao.create-lock", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Approve CTM + create_lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { amountHuman: { type: "string", required: true, description: "CTM amount" }, lockDurationSeconds: { type: "string", required: true, description: "Lock duration in seconds" } } },
+    { id: "continuum-dao.increase-amount", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Increase lock amount", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, amountHuman: { type: "string", required: true, description: "CTM amount to add" } } },
+    { id: "continuum-dao.increase-unlock-time", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Increase unlock time", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, lockDurationSeconds: { type: "string", required: true, description: "Duration from week boundary to new unlock" } } },
+    { id: "continuum-dao.split", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Split a veCTM lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "Source token id" }, extractedHuman: { type: "string", required: true, description: "CTM extracted into the new lock" } } },
+    { id: "continuum-dao.merge", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Merge two veCTM locks", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { fromTokenId: { type: "string", required: true, description: "Burned token id" }, toTokenId: { type: "string", required: true, description: "Surviving token id" } } },
+    { id: "continuum-dao.withdraw", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw an expired lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao.liquidate", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Liquidate a lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao.delegate", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Delegate voting power", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { delegatee: { type: "string", required: true, description: "Delegatee address" } } },
+    { id: "continuum-dao.undelegate", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Return voting power to the KeyGen (delegate to self)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "continuum-dao.fetch-delegates", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Read VotingEscrow.delegates(account)", commonParams: [], params: { account: { type: "string", required: true, description: "KeyGen or wallet address" } } },
+    { id: "continuum-dao.transfer", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Transfer a veCTM NFT", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, to: { type: "string", required: true, description: "Recipient" } } },
+    { id: "continuum-dao.attach", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Attach veCTM to the node (authority KeyGen)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { nodeKey: { type: "string", required: true, description: "Node key" }, tokenId: { type: "string", required: true, description: "veCTM token id" }, mpaWallet: { type: "string", required: true, description: "MultiSignAgentWallet address" } } },
+    { id: "continuum-dao.request-detach", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Request governance detach", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "Attached token id" }, nodeProperties: { type: "string", required: true, description: "NodeProperties address" } } },
+    { id: "continuum-dao.propose-bravo", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Propose a Bravo (For/Against/Abstain) proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { title: { type: "string", required: true, description: "On-chain description (title)" }, forumKey: { type: "string", required: true, description: "Created forum thread URL from forum_create_topic" } } },
+    { id: "continuum-dao.propose-delta", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Propose a Delta multi-option proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { title: { type: "string", required: true, description: "On-chain description (title)" }, nWinners: { type: "number", required: true, description: "Winning options to execute" }, forumKey: { type: "string", required: true, description: "Created forum thread URL from forum_create_topic" } } },
+    { id: "continuum-dao.cast-vote-bravo", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cast a Bravo vote", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" }, support: { type: "number", required: true, description: "0 against, 1 for, 2 abstain" } } },
+    { id: "continuum-dao.cast-vote-delta", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cast a Delta vote including NOTA", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" } } },
+    { id: "continuum-dao.execute", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Execute a succeeded proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" } } },
+    { id: "continuum-dao.cancel", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cancel a proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" } } },
+    { id: "continuum-dao.fetch-live-proposals", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List live/pending/succeeded proposals with on-chain state overlay", commonParams: [], params: { chainId: { type: "number", required: false, description: "Linea chain id" }, rpcUrl: { type: "string", required: false, description: "Linea RPC for state overlay" } } },
+    { id: "continuum-dao.explain-proposal", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Deconstruct a proposal into a readable briefing (actions, C3, no-ops, risks)", commonParams: [], params: { id: { type: "string", required: false, description: "Backend proposal id" }, onchainId: { type: "string", required: false, description: "Governor proposal id" } } },
+    { id: "continuum-dao.forum-sign-in", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "EIP-712 forum login (veCTM gate first)", commonParams: ["keyGen", "purposeText"], params: { nodeKey: { type: "string", required: false, description: "Attached node key" }, username: { type: "string", required: false, description: "Username when there is no node key" } } },
+    { id: "continuum-dao.forum-sign-in-eligible", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Check veCTM forum login eligibility", commonParams: [], params: { address: { type: "string", required: true, description: "KeyGen or wallet address" } } },
+    { id: "continuum-dao.forum-sign-out", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Revoke forum ticket and sessions", commonParams: [], params: { ticket: { type: "string", required: true, description: "Forum write ticket" } } },
+    { id: "continuum-dao.forum-create-topic", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Create a Governance proposal thread (not Ideas)", commonParams: [], params: { section: { type: "string", required: false, description: "decision | election | treasury | constitution | admin" }, title: { type: "string", required: true, description: "Thread title" }, content: { type: "string", required: true, description: "Proposal body" } } },
+    { id: "continuum-dao.forum-create-idea", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Post an Idea or Suggestion (not a proposal)", commonParams: [], params: { title: { type: "string", required: true, description: "Thread title" }, content: { type: "string", required: true, description: "Idea body" } } },
+    { id: "continuum-dao.forum-search", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Search forum titles and bodies; optional hours/since", commonParams: [], params: { query: { type: "string", required: false, description: "Case-insensitive title or body substring" }, hours: { type: "number", required: false, description: "Only posts from the last X hours" }, since: { type: "string", required: false, description: "Only posts since this ISO date or unix timestamp" } } },
+    { id: "continuum-dao.forum-recent", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List recent readable posts (id, title, username, createdAt); requires hours or since", commonParams: [], params: { hours: { type: "number", required: false, description: "Only posts from the last X hours" }, since: { type: "string", required: false, description: "Only posts since this ISO date or unix timestamp" } } },
+    { id: "continuum-dao.forum-delete", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Admin/moderator soft-delete a post, thread, or a user\u2019s posts", commonParams: [], params: { pid: { type: "string", required: false, description: "Post id" }, tid: { type: "string", required: false, description: "Thread id" }, username: { type: "string", required: false, description: "Delete all posts by this user" }, hours: { type: "number", required: false, description: "Only in the last X hours (default all)" }, since: { type: "string", required: false, description: "Only since this date (default all)" } } },
+    { id: "continuum-dao.forum-unread", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List unread topics for the logged-in user", commonParams: [], params: { filter: { type: "string", required: false, description: "all | new | watched | unreplied" } } },
+    { id: "continuum-dao.forum-mark-read", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Mark topic(s) read (tid/url, tids, or all)", commonParams: [], params: { tid: { type: "string", required: false, description: "Thread id" }, all: { type: "boolean", required: false, description: "Mark every unread topic read" } } },
+    { id: "continuum-dao.forum-mark-unread", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Mark one topic unread", commonParams: [], params: { tid: { type: "string", required: false, description: "Thread id" } } }
+  ]
+};
+registerProtocolModule(continuumDaoProtocolModule);
+
+export { ATTACH_VECTM_SIGNATURE, CONTINUUM_DAO_APPROVE_FALLBACK, CONTINUUM_DAO_ATTACH_FALLBACK, CONTINUUM_DAO_CANCEL_FALLBACK, 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_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_DECIMALS, CTM_TOKEN_NAME, CTM_TOKEN_SYMBOL, FORUM_GOVERNANCE_SECTIONS, FORUM_IDEA_SECTION, FORUM_LOGIN_DELIVERY_KIND, GOVERNOR_STATE, GOVERNOR_STATE_LABELS, MAXTIME_SECONDS, PROPOSAL_TYPE_LABELS, PROPOSAL_TYPE_TO_FORUM_SECTION, VECTM_NODE_INFO_TUPLE, VECTM_TOKEN_NAME, VECTM_TOKEN_SYMBOL, WEEK_SECONDS, applyForumSectionCheck, assertContinuumDaoForumDeleteInput, assertContinuumDaoForumMarkReadInput, assertContinuumDaoForumRecentInput, assertContinuumDaoForumSearchInput, assertContinuumDaoForumTopicKey, 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, continuumDaoDeployment, continuumDaoExplainProposal, continuumDaoFetchDelegates, continuumDaoFetchLiveProposals, continuumDaoFetchProposal, continuumDaoFetchProposalCount, continuumDaoFetchProposalState, continuumDaoFetchProposals, continuumDaoFetchVotingPower, continuumDaoForumCreateIdea, continuumDaoForumCreateTopic, continuumDaoForumDelete, continuumDaoForumFetchPost, continuumDaoForumFetchThread, continuumDaoForumMarkRead, continuumDaoForumMarkUnread, continuumDaoForumMe, continuumDaoForumReact, continuumDaoForumRecent, continuumDaoForumReply, continuumDaoForumReplyCount, continuumDaoForumResolve, continuumDaoForumSearch, continuumDaoForumSections, continuumDaoForumSignInEligible, continuumDaoForumSignInNonce, continuumDaoForumSignOut, continuumDaoForumUnread, continuumDaoForumUrl, continuumDaoForumUserPostIds, continuumDaoHashProposal, continuumDaoProtocolModule, continuumDaoRegisterProposal, ctmTokenAddressOnEvmChain, encodeContinuumDaoNodeInfo, encodeDeltaMetadata, encodeDeltaVoteParams, encodeGovActionCalldata, expectedForumSectionForProposalType, explainGovAction, explainProposalRecord, governorAddressOnEvmChain, isConfiguredAddress, isContinuumDaoCtmOnAssetsChain, isContinuumDaoLockChain, isContinuumDaoSupportedChainId, isContinuumDaoVeCtmOnAssetsChain, isCtmTokenSymbol, isForumIdeaSection, isGovNoOpAction, isVotingEscrowContinuumName, listContinuumDaoDefaultAssets, proposalDescriptionHash, summarizeLiveProposals, votingEscrowAddressOnEvmChain };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map