@continuumdao/ctm-mpc-defi 0.2.37 → 0.2.38

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

@@ -50,6 +50,11 @@ var VECTM_TOKEN_SYMBOL = "veCTM";
 var CTM_TOKEN_DECIMALS = 18;
 var WEEK_SECONDS = 7 * 86400;
 var MAXTIME_SECONDS = 4 * 365 * 86400;
+var VECTM_MAX_LOCK_WEEKS = 208;
+var VECTM_DEFAULT_MINIMUM_LOCK_WEI = 10n ** 18n;
+var VECTM_LIQ_MIN_LOCKED_WEI = 100n;
+var VECTM_LIQ_PENALTY_NUM = 50000n;
+var VECTM_LIQ_PENALTY_DEN = 100000n;
 var UNSET = {
   ctm: viem.zeroAddress,
   votingEscrow: viem.zeroAddress,
@@ -57,15 +62,18 @@ var UNSET = {
   rewards: viem.zeroAddress,
   governor: viem.zeroAddress
 };
+var CTM_TOKEN_ADDRESS = viem.getAddress("0x2026027054F5beBCEB650aBD62dC623e327658e7");
+var VOTING_ESCROW_LINEA_ADDRESS = viem.getAddress("0x221EC90B3B083A8501A37bdeb7035CeaedF3C31f");
 var CONTINUUM_DAO_DEPLOYMENTS = {
-  [CONTINUUM_DAO_LINEA_CHAIN_ID]: { ...UNSET },
+  [CONTINUUM_DAO_LINEA_CHAIN_ID]: {
+    ...UNSET,
+    ctm: CTM_TOKEN_ADDRESS,
+    votingEscrow: VOTING_ESCROW_LINEA_ADDRESS
+  },
   [CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID]: { ...UNSET },
   [CONTINUUM_DAO_ETHEREUM_CHAIN_ID]: {
-    ctm: viem.zeroAddress,
-    votingEscrow: viem.zeroAddress,
-    nodeProperties: viem.zeroAddress,
-    rewards: viem.zeroAddress,
-    governor: viem.zeroAddress
+    ...UNSET,
+    ctm: CTM_TOKEN_ADDRESS
   }
 };
 var CONTINUUM_DAO_GOVERNANCE_API = "https://app-api.continuumdao.org";
@@ -156,6 +164,544 @@ function listContinuumDaoDefaultAssets() {
   }
   return out;
 }
+function maxLockDurationSeconds() {
+  return Math.min(VECTM_MAX_LOCK_WEEKS * WEEK_SECONDS, MAXTIME_SECONDS);
+}
+function floorUnlockTimeSeconds(nowSec, durationSec) {
+  return (BigInt(nowSec) + durationSec) / BigInt(WEEK_SECONDS) * BigInt(WEEK_SECONDS);
+}
+function assertCtmAmountAtLeastMinimum(amountWei, minimumLockWei, label) {
+  const min = minimumLockWei > 0n ? minimumLockWei : VECTM_DEFAULT_MINIMUM_LOCK_WEI;
+  if (amountWei < min) {
+    throw new Error(`${label} must be at least ${formatCtmWei(min)} CTM (VotingEscrow.minimumLock).`);
+  }
+}
+function assertCreateLockAmount(amountWei, minimumLockWei, balanceWei) {
+  if (amountWei <= 0n) throw new Error("CTM amount must be greater than zero.");
+  assertCtmAmountAtLeastMinimum(amountWei, minimumLockWei, "Create lock");
+  if (balanceWei != null && amountWei > balanceWei) {
+    throw new Error(`Create lock ${formatCtmWei(amountWei)} CTM exceeds KeyGen balance ${formatCtmWei(balanceWei)} CTM.`);
+  }
+}
+function assertLockDurationSeconds(durationSec, nowSec, label) {
+  if (durationSec <= 0n) throw new Error(`${label} duration must be greater than zero.`);
+  if (durationSec < BigInt(WEEK_SECONDS)) {
+    throw new Error(`${label} duration must be at least 1 week (${WEEK_SECONDS} seconds).`);
+  }
+  if (durationSec > BigInt(maxLockDurationSeconds())) {
+    throw new Error(
+      `${label} duration cannot exceed ${VECTM_MAX_LOCK_WEEKS} weeks (VotingEscrow MAXTIME, week-aligned).`
+    );
+  }
+  const unlock = floorUnlockTimeSeconds(nowSec, durationSec);
+  if (unlock <= BigInt(nowSec)) {
+    throw new Error(`${label} unlock time must be after the current week boundary.`);
+  }
+  if (unlock > BigInt(nowSec) + BigInt(MAXTIME_SECONDS)) {
+    throw new Error(`${label} unlock time exceeds VotingEscrow MAXTIME (4 years).`);
+  }
+  return unlock;
+}
+function assertIncreaseAmount(amountWei, lock, nowSec, balanceWei) {
+  if (amountWei <= 0n) throw new Error("CTM amount must be greater than zero.");
+  if (lock.amountWei === 0n) throw new Error(`veCTM #${lock.tokenId} has no existing lock.`);
+  if (lock.endSec <= BigInt(nowSec)) {
+    throw new Error(`Cannot increase amount on expired veCTM #${lock.tokenId}. Withdraw or create a new lock.`);
+  }
+  if (balanceWei != null && amountWei > balanceWei) {
+    throw new Error(
+      `Increase amount ${formatCtmWei(amountWei)} CTM exceeds KeyGen balance ${formatCtmWei(balanceWei)} CTM.`
+    );
+  }
+}
+function assertIncreaseUnlockTime(durationSec, lock, nowSec) {
+  if (lock.amountWei === 0n) throw new Error(`veCTM #${lock.tokenId} has no existing lock.`);
+  if (lock.endSec <= BigInt(nowSec)) {
+    throw new Error(`Cannot increase unlock time on expired veCTM #${lock.tokenId}.`);
+  }
+  const unlock = assertLockDurationSeconds(durationSec, nowSec, "Increase unlock time");
+  if (unlock <= lock.endSec) {
+    throw new Error(
+      `New unlock time must be after the current lock end (${lock.endSec.toString()}). Pick a later week-aligned date.`
+    );
+  }
+  return unlock;
+}
+function assertSplitExtracted(extractedWei, lock, minimumLockWei, nowSec) {
+  if (lock.attached) {
+    throw new Error(`Split is blocked while veCTM #${lock.tokenId} is attached to a node. Request detach first.`);
+  }
+  if (lock.amountWei === 0n) throw new Error(`veCTM #${lock.tokenId} has no existing lock.`);
+  if (lock.endSec <= BigInt(nowSec)) {
+    throw new Error(`Cannot split expired veCTM #${lock.tokenId}.`);
+  }
+  const min = minimumLockWei > 0n ? minimumLockWei : VECTM_DEFAULT_MINIMUM_LOCK_WEI;
+  if (lock.amountWei < min * 2n) {
+    throw new Error("Split requires at least 2 CTM locked (1 CTM minimum per resulting lock).");
+  }
+  if (extractedWei < min) {
+    throw new Error(`Extract at least ${formatCtmWei(min)} CTM into the new lock.`);
+  }
+  if (extractedWei > lock.amountWei - min) {
+    throw new Error(`The original lock must keep at least ${formatCtmWei(min)} CTM after the split.`);
+  }
+}
+function assertMerge(fromLock, toLock) {
+  if (fromLock.tokenId === toLock.tokenId) throw new Error("Merge requires two different token ids.");
+  if (fromLock.attached) {
+    throw new Error(`Merge is blocked while veCTM #${fromLock.tokenId} is attached to a node.`);
+  }
+  if (toLock.attached) {
+    throw new Error(`Merge is blocked while veCTM #${toLock.tokenId} is attached to a node.`);
+  }
+  if (fromLock.owner.toLowerCase() !== toLock.owner.toLowerCase()) {
+    throw new Error("Merge requires both veCTM locks to have the same owner.");
+  }
+}
+function assertWithdraw(lock, nowSec) {
+  if (lock.attached) {
+    throw new Error(`Withdraw is blocked while veCTM #${lock.tokenId} is attached to a node. Request detach first.`);
+  }
+  if (lock.endSec <= 0n) throw new Error(`Unlock time unavailable for veCTM #${lock.tokenId}.`);
+  if (lock.endSec > BigInt(nowSec)) {
+    throw new Error(`Withdraw is available after the lock expires (unlock ${lock.endSec.toString()}).`);
+  }
+}
+function computeLiquidationAmounts(args) {
+  if (args.lockEndSec > 0n && BigInt(args.nowSec) >= args.lockEndSec) {
+    return {
+      userWei: args.lockedAmountWei,
+      treasuryWei: 0n,
+      lockExpired: true,
+      tooSmall: false,
+      zeroPenalty: false
+    };
+  }
+  if (args.lockedAmountWei <= VECTM_LIQ_MIN_LOCKED_WEI) {
+    return {
+      userWei: 0n,
+      treasuryWei: 0n,
+      lockExpired: false,
+      tooSmall: true,
+      zeroPenalty: false
+    };
+  }
+  const penalty = args.vePowerWei * VECTM_LIQ_PENALTY_NUM / VECTM_LIQ_PENALTY_DEN;
+  if (penalty === 0n) {
+    return {
+      userWei: 0n,
+      treasuryWei: 0n,
+      lockExpired: false,
+      tooSmall: false,
+      zeroPenalty: true
+    };
+  }
+  return {
+    userWei: args.lockedAmountWei - penalty,
+    treasuryWei: penalty,
+    lockExpired: false,
+    tooSmall: false,
+    zeroPenalty: false
+  };
+}
+function assertLiquidate(lock, liquidationsEnabled, nowSec) {
+  if (lock.attached) {
+    throw new Error(`Liquidate is blocked while veCTM #${lock.tokenId} is attached to a node. Request detach first.`);
+  }
+  if (liquidationsEnabled === false) {
+    throw new Error("Liquidations are currently disabled on-chain.");
+  }
+  const preview = computeLiquidationAmounts({
+    lockedAmountWei: lock.amountWei,
+    vePowerWei: lock.vePowerWei,
+    lockEndSec: lock.endSec,
+    nowSec
+  });
+  if (preview.tooSmall) throw new Error("Locked amount is too small to liquidate.");
+  if (preview.zeroPenalty) throw new Error("Voting power is too low to compute a liquidation penalty.");
+}
+function assertDelegatee(delegateeRaw, executor) {
+  const delegatee = viem.getAddress(delegateeRaw);
+  if (delegatee === viem.zeroAddress) {
+    throw new Error("Zero address is not allowed. Use undelegate to return power to this KeyGen.");
+  }
+  const self = viem.getAddress(executor);
+  if (delegatee === self) {
+    throw new Error("This is this KeyGen\u2019s address \u2014 use undelegate instead.");
+  }
+  return delegatee;
+}
+function assertUndelegateNotAlreadySelf(alreadySelf, account) {
+  if (alreadySelf) {
+    throw new Error(`Voting power is already at this KeyGen (${viem.getAddress(account)}).`);
+  }
+}
+function assertTransfer(lock, toRaw, fromRaw) {
+  if (lock.attached) {
+    throw new Error(`Transfer is blocked while veCTM #${lock.tokenId} is attached to a node.`);
+  }
+  const to = viem.getAddress(toRaw);
+  const from = viem.getAddress(fromRaw);
+  if (to === viem.zeroAddress) throw new Error("Cannot transfer veCTM to the zero address.");
+  if (to === from) throw new Error("Transfer recipient must be different from this KeyGen.");
+  return to;
+}
+function assertExecutorOwnsLock(lock, executor) {
+  if (lock.owner.toLowerCase() !== viem.getAddress(executor).toLowerCase()) {
+    throw new Error(`KeyGen ${viem.getAddress(executor)} does not own veCTM #${lock.tokenId} (owner ${lock.owner}).`);
+  }
+}
+function formatCtmWei(wei) {
+  const whole = wei / 10n ** 18n;
+  const frac = wei % 10n ** 18n;
+  if (frac === 0n) return whole.toString();
+  const fracStr = frac.toString().padStart(18, "0").replace(/0+$/, "");
+  return `${whole.toString()}.${fracStr}`;
+}
+var veReadAbi = viem.parseAbi([
+  "function minimumLock() view returns (uint256)",
+  "function locked(uint256 tokenId) view returns (int128 amount, uint256 end)",
+  "function ownerOf(uint256 tokenId) view returns (address)",
+  "function balanceOfNFT(uint256 tokenId) view returns (uint256)",
+  "function liquidationsEnabled() view returns (bool)",
+  "function nodeProperties() view returns (address)",
+  "function rewards() view returns (address)",
+  "function delegates(address account) view returns (address)",
+  "function token() view returns (address)"
+]);
+var erc20Abi = viem.parseAbi(["function balanceOf(address owner) view returns (uint256)"]);
+var nodePropsAbi = viem.parseAbi([
+  "function attachedKeyGen(uint256 tokenId) view returns (address)",
+  "function attachedTokenId(address keyGen) view returns (uint256)",
+  "function nodeRequestingDetachment(uint256 tokenId) view returns (bool)"
+]);
+var rewardsAbi = viem.parseAbi(["function unclaimedRewards(uint256 tokenId) view returns (uint256)"]);
+var mpaReadAbi = viem.parseAbi([
+  "function getNodeWithdrawAuthority(string nodeKey) view returns (address)",
+  "function ve() view returns (address)",
+  "function veCtmThresholdPower() view returns (uint256)",
+  "function nodeProperties() view returns (address)"
+]);
+function publicClient(rpcUrl, chainId) {
+  return viem.createPublicClient({
+    chain: viem.defineChain({
+      id: chainId,
+      name: "ContinuumDAO escrow",
+      nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+      rpcUrls: { default: { http: [rpcUrl.trim()] } }
+    }),
+    transport: viem.http(rpcUrl.trim())
+  });
+}
+async function readMinimumLockWei(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  try {
+    const min = await client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "minimumLock"
+    });
+    return min > 0n ? min : VECTM_DEFAULT_MINIMUM_LOCK_WEI;
+  } catch {
+    return VECTM_DEFAULT_MINIMUM_LOCK_WEI;
+  }
+}
+async function readCtmBalanceWei(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  try {
+    return await client.readContract({
+      address: args.ctm,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [args.owner]
+    });
+  } catch {
+    return void 0;
+  }
+}
+async function readVeCtmLockState(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const [lockedPair, owner, vePower, nodeProperties] = await Promise.all([
+    client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "locked",
+      args: [args.tokenId]
+    }),
+    client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "ownerOf",
+      args: [args.tokenId]
+    }),
+    client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "balanceOfNFT",
+      args: [args.tokenId]
+    }),
+    client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "nodeProperties"
+    })
+  ]);
+  const amountRaw = lockedPair[0];
+  const amountWei = amountRaw < 0n ? 0n : BigInt(amountRaw);
+  let attached = false;
+  if (isConfiguredAddress(nodeProperties)) {
+    try {
+      const attachedKey = await client.readContract({
+        address: viem.getAddress(nodeProperties),
+        abi: nodePropsAbi,
+        functionName: "attachedKeyGen",
+        args: [args.tokenId]
+      });
+      attached = attachedKey !== viem.zeroAddress;
+    } catch {
+      attached = false;
+    }
+  }
+  return {
+    tokenId: args.tokenId,
+    amountWei,
+    endSec: lockedPair[1],
+    owner: viem.getAddress(owner),
+    attached,
+    vePowerWei: vePower
+  };
+}
+async function assertNoUnclaimedRewards(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  let rewards;
+  try {
+    rewards = await client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "rewards"
+    });
+  } catch {
+    return;
+  }
+  if (!isConfiguredAddress(rewards)) return;
+  try {
+    const unclaimed = await client.readContract({
+      address: rewards,
+      abi: rewardsAbi,
+      functionName: "unclaimedRewards",
+      args: [args.tokenId]
+    });
+    if (unclaimed !== 0n) {
+      throw new Error(`veCTM #${args.tokenId} has unclaimed rewards. Claim them before this escrow action.`);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("unclaimed rewards")) throw err;
+  }
+}
+async function preflightCreateLock(args) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const [minimumLockWei, balanceWei] = await Promise.all([
+    readMinimumLockWei(args),
+    readCtmBalanceWei(args)
+  ]);
+  assertCreateLockAmount(args.amountWei, minimumLockWei, balanceWei);
+  assertLockDurationSeconds(args.durationSec, nowSec, "Create lock");
+}
+async function preflightIncreaseAmount(args) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const [lock, balanceWei] = await Promise.all([
+    readVeCtmLockState(args),
+    readCtmBalanceWei(args)
+  ]);
+  assertExecutorOwnsLock(lock, args.owner);
+  assertIncreaseAmount(args.amountWei, lock, nowSec, balanceWei);
+  await assertNoUnclaimedRewards(args);
+}
+async function preflightIncreaseUnlockTime(args) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const lock = await readVeCtmLockState(args);
+  assertExecutorOwnsLock(lock, args.owner);
+  assertIncreaseUnlockTime(args.durationSec, lock, nowSec);
+  await assertNoUnclaimedRewards(args);
+}
+async function preflightSplit(args) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const [lock, minimumLockWei] = await Promise.all([
+    readVeCtmLockState(args),
+    readMinimumLockWei(args)
+  ]);
+  assertExecutorOwnsLock(lock, args.owner);
+  assertSplitExtracted(args.extractedWei, lock, minimumLockWei, nowSec);
+  await assertNoUnclaimedRewards(args);
+}
+async function preflightMerge(args) {
+  const [fromLock, toLock] = await Promise.all([
+    readVeCtmLockState({ ...args, tokenId: args.fromTokenId }),
+    readVeCtmLockState({ ...args, tokenId: args.toTokenId })
+  ]);
+  assertExecutorOwnsLock(fromLock, args.owner);
+  assertExecutorOwnsLock(toLock, args.owner);
+  assertMerge(fromLock, toLock);
+  await Promise.all([
+    assertNoUnclaimedRewards({ ...args, tokenId: args.fromTokenId }),
+    assertNoUnclaimedRewards({ ...args, tokenId: args.toTokenId })
+  ]);
+}
+async function preflightWithdraw(args) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const lock = await readVeCtmLockState(args);
+  assertExecutorOwnsLock(lock, args.owner);
+  assertWithdraw(lock, nowSec);
+  await assertNoUnclaimedRewards(args);
+}
+async function preflightLiquidate(args) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const [lock, liquidationsEnabled] = await Promise.all([
+    readVeCtmLockState(args),
+    client.readContract({
+      address: args.votingEscrow,
+      abi: veReadAbi,
+      functionName: "liquidationsEnabled"
+    }).catch(() => null)
+  ]);
+  assertExecutorOwnsLock(lock, args.owner);
+  assertLiquidate(lock, liquidationsEnabled, nowSec);
+  await assertNoUnclaimedRewards(args);
+}
+async function preflightDelegate(args) {
+  return assertDelegatee(args.delegatee, args.owner);
+}
+async function preflightUndelegate(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const delegatee = await client.readContract({
+    address: args.votingEscrow,
+    abi: veReadAbi,
+    functionName: "delegates",
+    args: [args.owner]
+  });
+  assertUndelegateNotAlreadySelf(viem.getAddress(delegatee) === viem.getAddress(args.owner), args.owner);
+}
+async function preflightTransfer(args) {
+  const lock = await readVeCtmLockState(args);
+  assertExecutorOwnsLock(lock, args.owner);
+  return assertTransfer(lock, args.to, args.owner);
+}
+async function preflightAttachVeCtm(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const [authority, veFromWallet, threshold, nodeProperties] = await Promise.all([
+    client.readContract({
+      address: args.mpaWallet,
+      abi: mpaReadAbi,
+      functionName: "getNodeWithdrawAuthority",
+      args: [args.nodeKey]
+    }),
+    client.readContract({ address: args.mpaWallet, abi: mpaReadAbi, functionName: "ve" }),
+    client.readContract({
+      address: args.mpaWallet,
+      abi: mpaReadAbi,
+      functionName: "veCtmThresholdPower"
+    }),
+    client.readContract({
+      address: args.mpaWallet,
+      abi: mpaReadAbi,
+      functionName: "nodeProperties"
+    })
+  ]);
+  const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : viem.getAddress(veFromWallet);
+  if (!isConfiguredAddress(ve)) throw new Error("veCTM is not live on the fee contract yet.");
+  const lock = await readVeCtmLockState({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    tokenId: args.tokenId
+  });
+  assertExecutorOwnsLock(lock, args.owner);
+  const executor = viem.getAddress(args.owner);
+  if (authority === viem.zeroAddress || viem.getAddress(authority) !== executor) {
+    throw new Error(
+      `Compose attachVeCtm from the claimed authority KeyGen (${authority}), which must own the NFT.`
+    );
+  }
+  if (isConfiguredAddress(nodeProperties)) {
+    const np = viem.getAddress(nodeProperties);
+    const [attachedKey, attachedForKey] = await Promise.all([
+      client.readContract({
+        address: np,
+        abi: nodePropsAbi,
+        functionName: "attachedKeyGen",
+        args: [args.tokenId]
+      }),
+      client.readContract({
+        address: np,
+        abi: nodePropsAbi,
+        functionName: "attachedTokenId",
+        args: [executor]
+      })
+    ]);
+    if (attachedKey !== viem.zeroAddress) {
+      throw new Error(`veCTM #${args.tokenId} is already attached. You cannot replace an attached NFT.`);
+    }
+    if (attachedForKey !== 0n) {
+      throw new Error(
+        `This KeyGen already has veCTM #${attachedForKey} attached. Request detach and wait for governance. A second group on this node attaches after rotating nodeWithdrawAuthority to that group's secp256k1 KeyGen.`
+      );
+    }
+  }
+  if (threshold > 0n && lock.amountWei < threshold) {
+    throw new Error(
+      `Locked CTM on veCTM #${args.tokenId} is below MultiSignAgentWallet.veCtmThresholdPower (${threshold.toString()} wei).`
+    );
+  }
+}
+async function preflightRequestDetach(args) {
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const [attachedKey, alreadyRequested] = await Promise.all([
+    client.readContract({
+      address: args.nodeProperties,
+      abi: nodePropsAbi,
+      functionName: "attachedKeyGen",
+      args: [args.tokenId]
+    }),
+    client.readContract({
+      address: args.nodeProperties,
+      abi: nodePropsAbi,
+      functionName: "nodeRequestingDetachment",
+      args: [args.tokenId]
+    })
+  ]);
+  if (attachedKey === viem.zeroAddress) {
+    throw new Error(`veCTM #${args.tokenId} is not attached to a node.`);
+  }
+  if (alreadyRequested) {
+    throw new Error(
+      `Detach already requested for veCTM #${args.tokenId}. The NFT stays attached until governance executes detach.`
+    );
+  }
+  if (viem.getAddress(attachedKey) !== viem.getAddress(args.owner)) {
+    throw new Error(
+      `Request detach from the attached KeyGen (${viem.getAddress(attachedKey)}).`
+    );
+  }
+}
+
+// src/protocols/evm/continuum-dao/attachGroup.ts
+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},string)`;
+function resolveAttachGroupId(keyGen, explicit) {
+  const fromKg = (keyGen.groupId ?? keyGen.GroupId ?? "").trim();
+  const fromArg = (explicit ?? "").trim();
+  if (fromKg && fromArg && fromKg !== fromArg) {
+    throw new Error(
+      `groupId must be the attaching KeyGen's mpc-auth GroupId (${fromKg}), not a different group.`
+    );
+  }
+  if (fromKg) return fromKg;
+  if (fromArg) return fromArg;
+  throw new Error(
+    "groupId is required to attach veCTM (use the attaching KeyGen's mpc-auth GroupId)."
+  );
+}
 
 // src/core/purpose.ts
 function mergePurposeText(purposeText, purposeSuffix) {
@@ -247,25 +793,25 @@ async function buildEvmMultisignBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient2 = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const publicClient3 = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
   const feeParams = await continuumNodeSdk.fetchChainFeeParams(rpcUrl, chainId);
   const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
-  const latestBaseFeeWei = !legacy ? (await publicClient2.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
+  const latestBaseFeeWei = !legacy ? (await publicClient3.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 = viem.getAddress(executorAddress);
-  const baseNonce = await publicClient2.getTransactionCount({ address: executor, blockTag: "pending" });
+  const baseNonce = await publicClient3.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 });
+      estimatedGas = await args.estimateGasForStep({ step, index: i, publicClient: publicClient3, executor });
     } else {
       try {
-        estimatedGas = await publicClient2.estimateGas({
+        estimatedGas = await publicClient3.estimateGas({
           to: step.to,
           data: step.data,
           value: step.value,
@@ -277,7 +823,7 @@ async function buildEvmMultisignBatch(args) {
     }
     let gasLimitI;
     if (args.resolveGasLimit) {
-      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient: publicClient2 });
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient: publicClient3 });
     } else if (step.routerSwap) {
       gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
     } else {
@@ -287,7 +833,7 @@ async function buildEvmMultisignBatch(args) {
     let feeSnapshot;
     let serialized;
     if (legacy) {
-      let gasPriceWei = await publicClient2.getGasPrice();
+      let gasPriceWei = await publicClient3.getGasPrice();
       if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
         gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
       }
@@ -404,9 +950,7 @@ 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 = viem.parseAbi([
+var erc20Abi2 = viem.parseAbi([
   "function allowance(address owner, address spender) view returns (uint256)",
   "function approve(address spender, uint256 amount) returns (bool)"
 ]);
@@ -422,7 +966,7 @@ var veWriteAbi = viem.parseAbi([
   "function transferFrom(address _from, address _to, uint256 _tokenId)"
 ]);
 var attachAbi = viem.parseAbi([
-  `function attachVeCtm(string nodeKey, uint256 tokenId, ${VECTM_NODE_INFO_TUPLE} nodeInfo)`
+  `function attachVeCtm(string nodeKey, uint256 tokenId, ${VECTM_NODE_INFO_TUPLE} nodeInfo, string groupId)`
 ]);
 var detachAbi = viem.parseAbi(["function setNodeRemovalStatus(uint256 tokenId, bool status)"]);
 var CONTINUUM_DAO_EVM_TYPES = /* @__PURE__ */ new Set([
@@ -513,7 +1057,7 @@ async function maybeApproveCtmStep(args) {
   try {
     allowance = await client.readContract({
       address: args.ctm,
-      abi: erc20Abi,
+      abi: erc20Abi2,
       functionName: "allowance",
       args: [args.owner, args.spender]
     });
@@ -522,7 +1066,7 @@ async function maybeApproveCtmStep(args) {
   }
   if (allowance >= args.amountWei) return null;
   const data = viem.encodeFunctionData({
-    abi: erc20Abi,
+    abi: erc20Abi2,
     functionName: "approve",
     args: [args.spender, args.amountWei]
   });
@@ -542,10 +1086,17 @@ async function buildEvmMultisignBodyContinuumDaoCreateLock(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
   const ctm = args.ctm && isConfiguredAddress(args.ctm) ? viem.getAddress(args.ctm) : requireCtm(args.chainId);
   const amountWei = viem.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 = viem.getAddress(args.executorAddress);
+  await preflightCreateLock({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    ctm,
+    owner,
+    amountWei,
+    durationSec: duration
+  });
   const approve = await maybeApproveCtmStep({
     rpcUrl: args.rpcUrl,
     chainId: args.chainId,
@@ -578,8 +1129,16 @@ async function buildEvmMultisignBodyContinuumDaoIncreaseAmount(args) {
   const ctm = args.ctm && isConfiguredAddress(args.ctm) ? viem.getAddress(args.ctm) : requireCtm(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
   const amountWei = viem.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 = viem.getAddress(args.executorAddress);
+  await preflightIncreaseAmount({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    ctm,
+    owner,
+    tokenId,
+    amountWei
+  });
   const approve = await maybeApproveCtmStep({
     rpcUrl: args.rpcUrl,
     chainId: args.chainId,
@@ -611,7 +1170,15 @@ async function buildEvmMultisignBodyContinuumDaoIncreaseUnlockTime(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.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 owner = viem.getAddress(args.executorAddress);
+  await preflightIncreaseUnlockTime({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner,
+    tokenId,
+    durationSec: duration
+  });
   const data = viem.encodeFunctionData({
     abi: veWriteAbi,
     functionName: "increase_unlock_time",
@@ -634,7 +1201,14 @@ async function buildEvmMultisignBodyContinuumDaoSplit(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
   const extracted = viem.parseUnits(String(args.extractedHuman).trim().replace(/,/g, ""), CTM_TOKEN_DECIMALS);
-  if (extracted <= 0n) throw new Error("Split amount must be greater than zero.");
+  await preflightSplit({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: viem.getAddress(args.executorAddress),
+    tokenId,
+    extractedWei: extracted
+  });
   const data = viem.encodeFunctionData({
     abi: veWriteAbi,
     functionName: "split",
@@ -657,7 +1231,14 @@ async function buildEvmMultisignBodyContinuumDaoMerge(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.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.");
+  await preflightMerge({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: viem.getAddress(args.executorAddress),
+    fromTokenId: fromId,
+    toTokenId: toId
+  });
   const data = viem.encodeFunctionData({
     abi: veWriteAbi,
     functionName: "merge",
@@ -679,6 +1260,13 @@ async function buildEvmMultisignBodyContinuumDaoMerge(args) {
 async function buildEvmMultisignBodyContinuumDaoWithdraw(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
+  await preflightWithdraw({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: viem.getAddress(args.executorAddress),
+    tokenId
+  });
   const data = viem.encodeFunctionData({ abi: veWriteAbi, functionName: "withdraw", args: [tokenId] });
   const step = {
     to: ve,
@@ -695,6 +1283,13 @@ async function buildEvmMultisignBodyContinuumDaoWithdraw(args) {
 async function buildEvmMultisignBodyContinuumDaoLiquidate(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
+  await preflightLiquidate({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: viem.getAddress(args.executorAddress),
+    tokenId
+  });
   const data = viem.encodeFunctionData({ abi: veWriteAbi, functionName: "liquidate", args: [tokenId] });
   const step = {
     to: ve,
@@ -710,7 +1305,12 @@ async function buildEvmMultisignBodyContinuumDaoLiquidate(args) {
 }
 async function buildEvmMultisignBodyContinuumDaoDelegate(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
-  const delegatee = viem.getAddress(args.delegatee);
+  const delegatee = await preflightDelegate({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    owner: viem.getAddress(args.executorAddress),
+    delegatee: args.delegatee
+  });
   const data = viem.encodeFunctionData({ abi: veWriteAbi, functionName: "delegate", args: [delegatee] });
   const step = {
     to: ve,
@@ -727,6 +1327,12 @@ async function buildEvmMultisignBodyContinuumDaoDelegate(args) {
 async function buildEvmMultisignBodyContinuumDaoUndelegate(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
   const self = viem.getAddress(args.executorAddress);
+  await preflightUndelegate({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: self
+  });
   const data = viem.encodeFunctionData({ abi: veWriteAbi, functionName: "delegate", args: [self] });
   const step = {
     to: ve,
@@ -741,7 +1347,7 @@ async function buildEvmMultisignBodyContinuumDaoUndelegate(args) {
   };
   return finalize([step], args, `ContinuumDAO: undelegate voting power (delegate back to ${self}).`);
 }
-var veReadAbi = viem.parseAbi(["function delegates(address account) view returns (address)"]);
+var veReadAbi2 = viem.parseAbi(["function delegates(address account) view returns (address)"]);
 async function continuumDaoFetchDelegates(args) {
   const chainId = Number(args.chainId);
   requireLockChain(chainId);
@@ -757,15 +1363,22 @@ async function continuumDaoFetchDelegates(args) {
     transport: viem.http(args.rpcUrl.trim())
   });
   const delegatee = viem.getAddress(
-    await client.readContract({ address: ve, abi: veReadAbi, functionName: "delegates", args: [account] })
+    await client.readContract({ address: ve, abi: veReadAbi2, functionName: "delegates", args: [account] })
   );
   return { account, delegatee, self: delegatee === account };
 }
 async function buildEvmMultisignBodyContinuumDaoTransfer(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? viem.getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
-  const to = viem.getAddress(args.to);
   const from = viem.getAddress(args.executorAddress);
+  const to = await preflightTransfer({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: from,
+    tokenId,
+    to: args.to
+  });
   const data = viem.encodeFunctionData({
     abi: veWriteAbi,
     functionName: "transferFrom",
@@ -826,11 +1439,20 @@ async function buildEvmMultisignBodyContinuumDaoAttachVeCtm(args) {
   const tokenId = parseTokenId(args.tokenId);
   const nodeKey = args.nodeKey.trim();
   if (!nodeKey) throw new Error("nodeKey is required to attach veCTM.");
+  const groupId = resolveAttachGroupId(args.keyGen, args.groupId);
+  await preflightAttachVeCtm({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    mpaWallet: wallet,
+    nodeKey,
+    tokenId,
+    owner: viem.getAddress(args.executorAddress)
+  });
   const tuple = args.nodeInfoTuple ?? encodeContinuumDaoNodeInfo(args.nodeInfo);
   const data = viem.encodeFunctionData({
     abi: attachAbi,
     functionName: "attachVeCtm",
-    args: [nodeKey, tokenId, tuple]
+    args: [nodeKey, tokenId, tuple, groupId]
   });
   const step = {
     to: wallet,
@@ -840,16 +1462,24 @@ async function buildEvmMultisignBodyContinuumDaoAttachVeCtm(args) {
     buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_attach", args.chainId, wallet, {
       name: "MultiSignAgentWallet.attachVeCtm",
       nodeKey,
-      tokenId: tokenId.toString()
+      tokenId: tokenId.toString(),
+      groupId
     }, gasLimit)
   };
-  return finalize([step], args, `ContinuumDAO: attach veCTM #${tokenId}.`);
+  return finalize([step], args, `ContinuumDAO: attach veCTM #${tokenId} (group ${groupId}).`);
 }
 async function buildEvmMultisignBodyContinuumDaoRequestDetach(args) {
   requireLockChain(args.chainId);
   const np = viem.getAddress(args.nodeProperties);
   if (np === viem.zeroAddress) throw new Error("NodeProperties address is required to request detach.");
   const tokenId = parseTokenId(args.tokenId);
+  await preflightRequestDetach({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    nodeProperties: np,
+    owner: viem.getAddress(args.executorAddress),
+    tokenId
+  });
   const data = viem.encodeFunctionData({
     abi: detachAbi,
     functionName: "setNodeRemovalStatus",
@@ -1449,7 +2079,9 @@ var governorReadAbi = viem.parseAbi([
   "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 proposalVotes(uint256 proposalId) view returns (uint256 againstVotes, uint256 forVotes, uint256 abstainVotes)",
+  "function hasVoted(uint256 proposalId, address account) view returns (bool)",
+  "function proposalSnapshot(uint256 proposalId) view returns (uint256)"
 ]);
 function splitAbiParamList(inner) {
   const out = [];
@@ -1701,9 +2333,32 @@ async function buildEvmMultisignBodyContinuumDaoProposeDelta(args) {
   );
   return { ...built, proposalArgs };
 }
+async function requireVoteEligible(args) {
+  const st = await continuumDaoFetchProposalState({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    proposalId: args.proposalId,
+    governor: args.governor
+  });
+  if (st.state !== 1) {
+    throw new Error(`Proposal is not Active (on-chain state ${st.state}).`);
+  }
+  const elig = await continuumDaoFetchProposalVoteEligibility({
+    chainId: args.chainId,
+    rpcUrl: args.rpcUrl,
+    proposalId: args.proposalId,
+    account: args.executorAddress,
+    governor: args.governor
+  });
+  if (elig.hasVoted) throw new Error("This KeyGen has already voted on this proposal.");
+  if (BigInt(elig.snapshotVotes) === 0n) {
+    throw new Error("No veCTM voting power at snapshot for this KeyGen.");
+  }
+}
 async function buildEvmMultisignBodyContinuumDaoCastVoteBravo(args) {
   const gov = requireGovernor(args.chainId, args.governor);
   const proposalId = BigInt(String(args.proposalId).trim());
+  await requireVoteEligible(args);
   const data = viem.encodeFunctionData({
     abi: governorWriteAbi,
     functionName: "castVote",
@@ -1722,6 +2377,10 @@ async function buildEvmMultisignBodyContinuumDaoCastVoteBravo(args) {
 async function buildEvmMultisignBodyContinuumDaoCastVoteDelta(args) {
   const gov = requireGovernor(args.chainId, args.governor);
   const proposalId = BigInt(String(args.proposalId).trim());
+  if (args.weights.length < 3) {
+    throw new Error("Delta vote must include one weight per option plus a NOTA slot.");
+  }
+  await requireVoteEligible(args);
   const params = encodeDeltaVoteParams(args.weights);
   const data = viem.encodeFunctionData({
     abi: governorWriteAbi,
@@ -1774,7 +2433,7 @@ async function buildEvmMultisignBodyContinuumDaoCancel(args) {
     "continuum-dao cancel"
   );
 }
-function publicClient(rpcUrl, chainId) {
+function publicClient2(rpcUrl, chainId) {
   return viem.createPublicClient({
     chain: viem.defineChain({
       id: chainId,
@@ -1788,7 +2447,7 @@ function publicClient(rpcUrl, chainId) {
 async function continuumDaoHashProposal(args) {
   const chainId = Number(args.chainId);
   const gov = requireGovernor(chainId, args.governor);
-  const client = publicClient(args.rpcUrl, chainId);
+  const client = publicClient2(args.rpcUrl, chainId);
   const id = await client.readContract({
     address: gov,
     abi: governorReadAbi,
@@ -1800,7 +2459,7 @@ async function continuumDaoHashProposal(args) {
 async function continuumDaoFetchVotingPower(args) {
   const chainId = Number(args.chainId);
   const gov = requireGovernor(chainId, args.governor);
-  const client = publicClient(args.rpcUrl, chainId);
+  const client = publicClient2(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([
@@ -1817,22 +2476,74 @@ async function continuumDaoFetchVotingPower(args) {
 async function continuumDaoFetchProposalState(args) {
   const chainId = Number(args.chainId);
   const gov = requireGovernor(chainId, args.governor);
-  const client = publicClient(args.rpcUrl, chainId);
+  const client = publicClient2(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] })
-  ]);
+  const state = await client.readContract({
+    address: gov,
+    abi: governorReadAbi,
+    functionName: "state",
+    args: [proposalId]
+  });
+  let againstVotes = "0";
+  let forVotes = "0";
+  let abstainVotes = "0";
+  let votesPartial = false;
+  try {
+    const votes = await client.readContract({
+      address: gov,
+      abi: governorReadAbi,
+      functionName: "proposalVotes",
+      args: [proposalId]
+    });
+    againstVotes = votes[0].toString();
+    forVotes = votes[1].toString();
+    abstainVotes = votes[2].toString();
+  } catch {
+    votesPartial = true;
+  }
   return {
     state: Number(state),
-    againstVotes: votes[0].toString(),
-    forVotes: votes[1].toString(),
-    abstainVotes: votes[2].toString()
+    againstVotes,
+    forVotes,
+    abstainVotes,
+    votesPartial
+  };
+}
+async function continuumDaoFetchProposalVoteEligibility(args) {
+  const chainId = Number(args.chainId);
+  const gov = requireGovernor(chainId, args.governor);
+  const client = publicClient2(args.rpcUrl, chainId);
+  const proposalId = BigInt(String(args.proposalId).trim());
+  const account = viem.getAddress(args.account);
+  const [hasVoted, snapshotBlock] = await Promise.all([
+    client.readContract({
+      address: gov,
+      abi: governorReadAbi,
+      functionName: "hasVoted",
+      args: [proposalId, account]
+    }),
+    client.readContract({
+      address: gov,
+      abi: governorReadAbi,
+      functionName: "proposalSnapshot",
+      args: [proposalId]
+    })
+  ]);
+  const snapshotVotes = await client.readContract({
+    address: gov,
+    abi: governorReadAbi,
+    functionName: "getVotes",
+    args: [account, snapshotBlock]
+  });
+  return {
+    hasVoted,
+    snapshotVotes: snapshotVotes.toString(),
+    snapshotBlock: snapshotBlock.toString()
   };
 }
 async function continuumDaoFetchProposalCount(args) {
   const gov = requireGovernor(args.chainId, args.governor);
-  const client = publicClient(args.rpcUrl, args.chainId);
+  const client = publicClient2(args.rpcUrl, args.chainId);
   const count = await client.readContract({ address: gov, abi: governorReadAbi, functionName: "proposalCount" });
   return { count: count.toString() };
 }
@@ -2167,7 +2878,7 @@ var continuumDaoProtocolModule = {
     { 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.attach", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Attach veCTM to the node (authority KeyGen). groupId is implicit from that KeyGen and binds the fee waiver. A second group attaches after rotating authority.", 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" } } },
@@ -2217,6 +2928,7 @@ exports.CONTINUUM_DAO_SPLIT_FALLBACK = CONTINUUM_DAO_SPLIT_FALLBACK;
 exports.CONTINUUM_DAO_TRANSFER_FALLBACK = CONTINUUM_DAO_TRANSFER_FALLBACK;
 exports.CONTINUUM_DAO_VOTE_FALLBACK = CONTINUUM_DAO_VOTE_FALLBACK;
 exports.CONTINUUM_DAO_WITHDRAW_FALLBACK = CONTINUUM_DAO_WITHDRAW_FALLBACK;
+exports.CTM_TOKEN_ADDRESS = CTM_TOKEN_ADDRESS;
 exports.CTM_TOKEN_DECIMALS = CTM_TOKEN_DECIMALS;
 exports.CTM_TOKEN_NAME = CTM_TOKEN_NAME;
 exports.CTM_TOKEN_SYMBOL = CTM_TOKEN_SYMBOL;
@@ -2228,9 +2940,15 @@ exports.GOVERNOR_STATE_LABELS = GOVERNOR_STATE_LABELS;
 exports.MAXTIME_SECONDS = MAXTIME_SECONDS;
 exports.PROPOSAL_TYPE_LABELS = PROPOSAL_TYPE_LABELS;
 exports.PROPOSAL_TYPE_TO_FORUM_SECTION = PROPOSAL_TYPE_TO_FORUM_SECTION;
+exports.VECTM_DEFAULT_MINIMUM_LOCK_WEI = VECTM_DEFAULT_MINIMUM_LOCK_WEI;
+exports.VECTM_LIQ_MIN_LOCKED_WEI = VECTM_LIQ_MIN_LOCKED_WEI;
+exports.VECTM_LIQ_PENALTY_DEN = VECTM_LIQ_PENALTY_DEN;
+exports.VECTM_LIQ_PENALTY_NUM = VECTM_LIQ_PENALTY_NUM;
+exports.VECTM_MAX_LOCK_WEEKS = VECTM_MAX_LOCK_WEEKS;
 exports.VECTM_NODE_INFO_TUPLE = VECTM_NODE_INFO_TUPLE;
 exports.VECTM_TOKEN_NAME = VECTM_TOKEN_NAME;
 exports.VECTM_TOKEN_SYMBOL = VECTM_TOKEN_SYMBOL;
+exports.VOTING_ESCROW_LINEA_ADDRESS = VOTING_ESCROW_LINEA_ADDRESS;
 exports.WEEK_SECONDS = WEEK_SECONDS;
 exports.applyForumSectionCheck = applyForumSectionCheck;
 exports.assertContinuumDaoForumDeleteInput = assertContinuumDaoForumDeleteInput;
@@ -2238,6 +2956,19 @@ exports.assertContinuumDaoForumMarkReadInput = assertContinuumDaoForumMarkReadIn
 exports.assertContinuumDaoForumRecentInput = assertContinuumDaoForumRecentInput;
 exports.assertContinuumDaoForumSearchInput = assertContinuumDaoForumSearchInput;
 exports.assertContinuumDaoForumTopicKey = assertContinuumDaoForumTopicKey;
+exports.assertCreateLockAmount = assertCreateLockAmount;
+exports.assertCtmAmountAtLeastMinimum = assertCtmAmountAtLeastMinimum;
+exports.assertDelegatee = assertDelegatee;
+exports.assertExecutorOwnsLock = assertExecutorOwnsLock;
+exports.assertIncreaseAmount = assertIncreaseAmount;
+exports.assertIncreaseUnlockTime = assertIncreaseUnlockTime;
+exports.assertLiquidate = assertLiquidate;
+exports.assertLockDurationSeconds = assertLockDurationSeconds;
+exports.assertMerge = assertMerge;
+exports.assertSplitExtracted = assertSplitExtracted;
+exports.assertTransfer = assertTransfer;
+exports.assertUndelegateNotAlreadySelf = assertUndelegateNotAlreadySelf;
+exports.assertWithdraw = assertWithdraw;
 exports.bucketGovernorState = bucketGovernorState;
 exports.buildBravoProposalArgs = buildBravoProposalArgs;
 exports.buildDeltaProposalArgs = buildDeltaProposalArgs;
@@ -2263,6 +2994,7 @@ exports.buildEvmMultisignBodyContinuumDaoSplit = buildEvmMultisignBodyContinuumD
 exports.buildEvmMultisignBodyContinuumDaoTransfer = buildEvmMultisignBodyContinuumDaoTransfer;
 exports.buildEvmMultisignBodyContinuumDaoUndelegate = buildEvmMultisignBodyContinuumDaoUndelegate;
 exports.buildEvmMultisignBodyContinuumDaoWithdraw = buildEvmMultisignBodyContinuumDaoWithdraw;
+exports.computeLiquidationAmounts = computeLiquidationAmounts;
 exports.continuumDaoDeployment = continuumDaoDeployment;
 exports.continuumDaoExplainProposal = continuumDaoExplainProposal;
 exports.continuumDaoFetchDelegates = continuumDaoFetchDelegates;
@@ -2270,6 +3002,7 @@ exports.continuumDaoFetchLiveProposals = continuumDaoFetchLiveProposals;
 exports.continuumDaoFetchProposal = continuumDaoFetchProposal;
 exports.continuumDaoFetchProposalCount = continuumDaoFetchProposalCount;
 exports.continuumDaoFetchProposalState = continuumDaoFetchProposalState;
+exports.continuumDaoFetchProposalVoteEligibility = continuumDaoFetchProposalVoteEligibility;
 exports.continuumDaoFetchProposals = continuumDaoFetchProposals;
 exports.continuumDaoFetchVotingPower = continuumDaoFetchVotingPower;
 exports.continuumDaoForumCreateIdea = continuumDaoForumCreateIdea;
@@ -2311,6 +3044,7 @@ exports.encodeGovActionCalldata = encodeGovActionCalldata;
 exports.expectedForumSectionForProposalType = expectedForumSectionForProposalType;
 exports.explainGovAction = explainGovAction;
 exports.explainProposalRecord = explainProposalRecord;
+exports.floorUnlockTimeSeconds = floorUnlockTimeSeconds;
 exports.governorAddressOnEvmChain = governorAddressOnEvmChain;
 exports.isConfiguredAddress = isConfiguredAddress;
 exports.isContinuumDaoCtmOnAssetsChain = isContinuumDaoCtmOnAssetsChain;
@@ -2322,7 +3056,24 @@ exports.isForumIdeaSection = isForumIdeaSection;
 exports.isGovNoOpAction = isGovNoOpAction;
 exports.isVotingEscrowContinuumName = isVotingEscrowContinuumName;
 exports.listContinuumDaoDefaultAssets = listContinuumDaoDefaultAssets;
+exports.maxLockDurationSeconds = maxLockDurationSeconds;
+exports.preflightAttachVeCtm = preflightAttachVeCtm;
+exports.preflightCreateLock = preflightCreateLock;
+exports.preflightDelegate = preflightDelegate;
+exports.preflightIncreaseAmount = preflightIncreaseAmount;
+exports.preflightIncreaseUnlockTime = preflightIncreaseUnlockTime;
+exports.preflightLiquidate = preflightLiquidate;
+exports.preflightMerge = preflightMerge;
+exports.preflightRequestDetach = preflightRequestDetach;
+exports.preflightSplit = preflightSplit;
+exports.preflightTransfer = preflightTransfer;
+exports.preflightUndelegate = preflightUndelegate;
+exports.preflightWithdraw = preflightWithdraw;
 exports.proposalDescriptionHash = proposalDescriptionHash;
+exports.readCtmBalanceWei = readCtmBalanceWei;
+exports.readMinimumLockWei = readMinimumLockWei;
+exports.readVeCtmLockState = readVeCtmLockState;
+exports.resolveAttachGroupId = resolveAttachGroupId;
 exports.summarizeLiveProposals = summarizeLiveProposals;
 exports.votingEscrowAddressOnEvmChain = votingEscrowAddressOnEvmChain;
 //# sourceMappingURL=index.cjs.map