@continuumdao/ctm-mpc-defi 0.2.37 → 0.2.39

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

@@ -1,4 +1,4 @@
-import { parseAbi, zeroAddress, getAddress, parseUnits, encodeFunctionData, createPublicClient, http, defineChain, keccak256, encodePacked, padHex, toHex, hashTypedData, parseGwei, serializeTransaction, stringToHex } from 'viem';
+import { getAddress, parseAbi, zeroAddress, 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
@@ -48,6 +48,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: zeroAddress,
   votingEscrow: zeroAddress,
@@ -55,15 +60,18 @@ var UNSET = {
   rewards: zeroAddress,
   governor: zeroAddress
 };
+var CTM_TOKEN_ADDRESS = getAddress("0x2026027054F5beBCEB650aBD62dC623e327658e7");
+var VOTING_ESCROW_LINEA_ADDRESS = 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: zeroAddress,
-    votingEscrow: zeroAddress,
-    nodeProperties: zeroAddress,
-    rewards: zeroAddress,
-    governor: zeroAddress
+    ...UNSET,
+    ctm: CTM_TOKEN_ADDRESS
   }
 };
 var CONTINUUM_DAO_GOVERNANCE_API = "https://app-api.continuumdao.org";
@@ -154,6 +162,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 = getAddress(delegateeRaw);
+  if (delegatee === zeroAddress) {
+    throw new Error("Zero address is not allowed. Use undelegate to return power to this KeyGen.");
+  }
+  const self = 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 (${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 = getAddress(toRaw);
+  const from = getAddress(fromRaw);
+  if (to === 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() !== getAddress(executor).toLowerCase()) {
+    throw new Error(`KeyGen ${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 = 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 = parseAbi(["function balanceOf(address owner) view returns (uint256)"]);
+var nodePropsAbi = parseAbi([
+  "function attachedKeyGen(uint256 tokenId) view returns (address)",
+  "function attachedTokenId(address keyGen) view returns (uint256)",
+  "function nodeRequestingDetachment(uint256 tokenId) view returns (bool)"
+]);
+var rewardsAbi = parseAbi(["function unclaimedRewards(uint256 tokenId) view returns (uint256)"]);
+var mpaReadAbi = 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 createPublicClient({
+    chain: defineChain({
+      id: chainId,
+      name: "ContinuumDAO escrow",
+      nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+      rpcUrls: { default: { http: [rpcUrl.trim()] } }
+    }),
+    transport: 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: getAddress(nodeProperties),
+        abi: nodePropsAbi,
+        functionName: "attachedKeyGen",
+        args: [args.tokenId]
+      });
+      attached = attachedKey !== zeroAddress;
+    } catch {
+      attached = false;
+    }
+  }
+  return {
+    tokenId: args.tokenId,
+    amountWei,
+    endSec: lockedPair[1],
+    owner: 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(getAddress(delegatee) === 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) ? getAddress(args.votingEscrow) : 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 = getAddress(args.owner);
+  if (authority === zeroAddress || getAddress(authority) !== executor) {
+    throw new Error(
+      `Compose attachVeCtm from the claimed authority KeyGen (${authority}), which must own the NFT.`
+    );
+  }
+  if (isConfiguredAddress(nodeProperties)) {
+    const np = 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 !== 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 === 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 (getAddress(attachedKey) !== getAddress(args.owner)) {
+    throw new Error(
+      `Request detach from the attached KeyGen (${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) {
@@ -245,25 +791,25 @@ async function buildEvmMultisignBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [rpcUrl] } }
   });
-  const publicClient2 = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const publicClient3 = 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 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 = 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,
@@ -275,7 +821,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 {
@@ -285,7 +831,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;
       }
@@ -402,9 +948,8 @@ 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([
+var INCREASE_UNLOCK_TIME_SIGNATURE = "increase_unlock_time(uint256,uint256)";
+var erc20Abi2 = parseAbi([
   "function allowance(address owner, address spender) view returns (uint256)",
   "function approve(address spender, uint256 amount) returns (bool)"
 ]);
@@ -420,7 +965,7 @@ var veWriteAbi = parseAbi([
   "function transferFrom(address _from, address _to, uint256 _tokenId)"
 ]);
 var attachAbi = 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 = parseAbi(["function setNodeRemovalStatus(uint256 tokenId, bool status)"]);
 var CONTINUUM_DAO_EVM_TYPES = /* @__PURE__ */ new Set([
@@ -459,14 +1004,17 @@ function parseTokenId(raw) {
   if (id <= 0n) throw new Error("veCTM token id must be greater than zero.");
   return id;
 }
+function continuumDaoSignatureText(extra, chainId) {
+  return JSON.stringify({
+    kind: "ContinuumDAO",
+    ...extra,
+    chainId
+  });
+}
 function meta(evmType, chainId, to, extra, gasLimit) {
   return {
     destinationAddress: to,
-    signatureText: JSON.stringify({
-      kind: "ContinuumDAO",
-      ...extra,
-      chainId
-    }),
+    signatureText: continuumDaoSignatureText(extra, chainId),
     evm: { type: evmType, version: 1, chainId: String(chainId), protocolId: CONTINUUM_DAO_PROTOCOL_ID },
     continuumDao: { ...extra, gas: { baseGasUnits: gasLimit.toString() } }
   };
@@ -511,7 +1059,7 @@ async function maybeApproveCtmStep(args) {
   try {
     allowance = await client.readContract({
       address: args.ctm,
-      abi: erc20Abi,
+      abi: erc20Abi2,
       functionName: "allowance",
       args: [args.owner, args.spender]
     });
@@ -520,7 +1068,7 @@ async function maybeApproveCtmStep(args) {
   }
   if (allowance >= args.amountWei) return null;
   const data = encodeFunctionData({
-    abi: erc20Abi,
+    abi: erc20Abi2,
     functionName: "approve",
     args: [args.spender, args.amountWei]
   });
@@ -540,10 +1088,17 @@ 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);
+  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,
@@ -576,8 +1131,16 @@ async function buildEvmMultisignBodyContinuumDaoIncreaseAmount(args) {
   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);
+  await preflightIncreaseAmount({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    ctm,
+    owner,
+    tokenId,
+    amountWei
+  });
   const approve = await maybeApproveCtmStep({
     rpcUrl: args.rpcUrl,
     chainId: args.chainId,
@@ -609,7 +1172,15 @@ 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 owner = getAddress(args.executorAddress);
+  await preflightIncreaseUnlockTime({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner,
+    tokenId,
+    durationSec: duration
+  });
   const data = encodeFunctionData({
     abi: veWriteAbi,
     functionName: "increase_unlock_time",
@@ -622,6 +1193,7 @@ async function buildEvmMultisignBodyContinuumDaoIncreaseUnlockTime(args) {
     fallbackGas: CONTINUUM_DAO_INCREASE_UNLOCK_FALLBACK,
     buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_increase_unlock_time", args.chainId, ve, {
       name: "VotingEscrow.increase_unlock_time",
+      signature: INCREASE_UNLOCK_TIME_SIGNATURE,
       tokenId: tokenId.toString(),
       lockDurationSeconds: duration.toString()
     }, gasLimit)
@@ -632,7 +1204,14 @@ 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.");
+  await preflightSplit({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: getAddress(args.executorAddress),
+    tokenId,
+    extractedWei: extracted
+  });
   const data = encodeFunctionData({
     abi: veWriteAbi,
     functionName: "split",
@@ -655,7 +1234,14 @@ 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.");
+  await preflightMerge({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: getAddress(args.executorAddress),
+    fromTokenId: fromId,
+    toTokenId: toId
+  });
   const data = encodeFunctionData({
     abi: veWriteAbi,
     functionName: "merge",
@@ -677,6 +1263,13 @@ async function buildEvmMultisignBodyContinuumDaoMerge(args) {
 async function buildEvmMultisignBodyContinuumDaoWithdraw(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
+  await preflightWithdraw({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: getAddress(args.executorAddress),
+    tokenId
+  });
   const data = encodeFunctionData({ abi: veWriteAbi, functionName: "withdraw", args: [tokenId] });
   const step = {
     to: ve,
@@ -693,6 +1286,13 @@ async function buildEvmMultisignBodyContinuumDaoWithdraw(args) {
 async function buildEvmMultisignBodyContinuumDaoLiquidate(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
+  await preflightLiquidate({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: getAddress(args.executorAddress),
+    tokenId
+  });
   const data = encodeFunctionData({ abi: veWriteAbi, functionName: "liquidate", args: [tokenId] });
   const step = {
     to: ve,
@@ -708,7 +1308,12 @@ async function buildEvmMultisignBodyContinuumDaoLiquidate(args) {
 }
 async function buildEvmMultisignBodyContinuumDaoDelegate(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
-  const delegatee = getAddress(args.delegatee);
+  const delegatee = await preflightDelegate({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    owner: getAddress(args.executorAddress),
+    delegatee: args.delegatee
+  });
   const data = encodeFunctionData({ abi: veWriteAbi, functionName: "delegate", args: [delegatee] });
   const step = {
     to: ve,
@@ -725,6 +1330,12 @@ async function buildEvmMultisignBodyContinuumDaoDelegate(args) {
 async function buildEvmMultisignBodyContinuumDaoUndelegate(args) {
   const ve = args.votingEscrow && isConfiguredAddress(args.votingEscrow) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
   const self = getAddress(args.executorAddress);
+  await preflightUndelegate({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: self
+  });
   const data = encodeFunctionData({ abi: veWriteAbi, functionName: "delegate", args: [self] });
   const step = {
     to: ve,
@@ -739,7 +1350,7 @@ async function buildEvmMultisignBodyContinuumDaoUndelegate(args) {
   };
   return finalize([step], args, `ContinuumDAO: undelegate voting power (delegate back to ${self}).`);
 }
-var veReadAbi = parseAbi(["function delegates(address account) view returns (address)"]);
+var veReadAbi2 = parseAbi(["function delegates(address account) view returns (address)"]);
 async function continuumDaoFetchDelegates(args) {
   const chainId = Number(args.chainId);
   requireLockChain(chainId);
@@ -755,15 +1366,22 @@ async function continuumDaoFetchDelegates(args) {
     transport: http(args.rpcUrl.trim())
   });
   const delegatee = 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) ? getAddress(args.votingEscrow) : requireVe(args.chainId);
   const tokenId = parseTokenId(args.tokenId);
-  const to = getAddress(args.to);
   const from = getAddress(args.executorAddress);
+  const to = await preflightTransfer({
+    rpcUrl: args.rpcUrl,
+    chainId: args.chainId,
+    votingEscrow: ve,
+    owner: from,
+    tokenId,
+    to: args.to
+  });
   const data = encodeFunctionData({
     abi: veWriteAbi,
     functionName: "transferFrom",
@@ -824,11 +1442,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: getAddress(args.executorAddress)
+  });
   const tuple = args.nodeInfoTuple ?? encodeContinuumDaoNodeInfo(args.nodeInfo);
   const data = encodeFunctionData({
     abi: attachAbi,
     functionName: "attachVeCtm",
-    args: [nodeKey, tokenId, tuple]
+    args: [nodeKey, tokenId, tuple, groupId]
   });
   const step = {
     to: wallet,
@@ -837,17 +1464,26 @@ async function buildEvmMultisignBodyContinuumDaoAttachVeCtm(args) {
     fallbackGas: CONTINUUM_DAO_ATTACH_FALLBACK,
     buildBatchMeta: ({ gasLimit }) => meta("continuum_dao_attach", args.chainId, wallet, {
       name: "MultiSignAgentWallet.attachVeCtm",
+      signature: ATTACH_VECTM_SIGNATURE,
       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 = getAddress(args.nodeProperties);
   if (np === 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: getAddress(args.executorAddress),
+    tokenId
+  });
   const data = encodeFunctionData({
     abi: detachAbi,
     functionName: "setNodeRemovalStatus",
@@ -1447,7 +2083,9 @@ var governorReadAbi = 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 = [];
@@ -1699,9 +2337,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 = encodeFunctionData({
     abi: governorWriteAbi,
     functionName: "castVote",
@@ -1720,6 +2381,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 = encodeFunctionData({
     abi: governorWriteAbi,
@@ -1772,7 +2437,7 @@ async function buildEvmMultisignBodyContinuumDaoCancel(args) {
     "continuum-dao cancel"
   );
 }
-function publicClient(rpcUrl, chainId) {
+function publicClient2(rpcUrl, chainId) {
   return createPublicClient({
     chain: defineChain({
       id: chainId,
@@ -1786,7 +2451,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,
@@ -1798,7 +2463,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([
@@ -1815,22 +2480,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 = 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() };
 }
@@ -2165,7 +2882,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" } } },
@@ -2190,6 +2907,6 @@ var continuumDaoProtocolModule = {
 };
 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, continuumDaoMpaFlag, continuumDaoMpaListing, continuumDaoMpaMailboxList, continuumDaoMpaMailboxOpen, continuumDaoMpaMailboxSend, continuumDaoMpaRetract, continuumDaoProtocolModule, continuumDaoRegisterProposal, continuumDaoTechnocoreBind, ctmTokenAddressOnEvmChain, encodeContinuumDaoNodeInfo, encodeDeltaMetadata, encodeDeltaVoteParams, encodeGovActionCalldata, expectedForumSectionForProposalType, explainGovAction, explainProposalRecord, governorAddressOnEvmChain, isConfiguredAddress, isContinuumDaoCtmOnAssetsChain, isContinuumDaoLockChain, isContinuumDaoSupportedChainId, isContinuumDaoVeCtmOnAssetsChain, isCtmTokenSymbol, isForumIdeaSection, isGovNoOpAction, isVotingEscrowContinuumName, listContinuumDaoDefaultAssets, proposalDescriptionHash, summarizeLiveProposals, votingEscrowAddressOnEvmChain };
+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_ADDRESS, CTM_TOKEN_DECIMALS, CTM_TOKEN_NAME, CTM_TOKEN_SYMBOL, FORUM_GOVERNANCE_SECTIONS, FORUM_IDEA_SECTION, FORUM_LOGIN_DELIVERY_KIND, GOVERNOR_STATE, GOVERNOR_STATE_LABELS, INCREASE_UNLOCK_TIME_SIGNATURE, MAXTIME_SECONDS, PROPOSAL_TYPE_LABELS, PROPOSAL_TYPE_TO_FORUM_SECTION, VECTM_DEFAULT_MINIMUM_LOCK_WEI, VECTM_LIQ_MIN_LOCKED_WEI, VECTM_LIQ_PENALTY_DEN, VECTM_LIQ_PENALTY_NUM, VECTM_MAX_LOCK_WEEKS, VECTM_NODE_INFO_TUPLE, VECTM_TOKEN_NAME, VECTM_TOKEN_SYMBOL, VOTING_ESCROW_LINEA_ADDRESS, WEEK_SECONDS, applyForumSectionCheck, assertContinuumDaoForumDeleteInput, assertContinuumDaoForumMarkReadInput, assertContinuumDaoForumRecentInput, assertContinuumDaoForumSearchInput, assertContinuumDaoForumTopicKey, assertCreateLockAmount, assertCtmAmountAtLeastMinimum, assertDelegatee, assertExecutorOwnsLock, assertIncreaseAmount, assertIncreaseUnlockTime, assertLiquidate, assertLockDurationSeconds, assertMerge, assertSplitExtracted, assertTransfer, assertUndelegateNotAlreadySelf, assertWithdraw, 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, computeLiquidationAmounts, continuumDaoDeployment, continuumDaoExplainProposal, continuumDaoFetchDelegates, continuumDaoFetchLiveProposals, continuumDaoFetchProposal, continuumDaoFetchProposalCount, continuumDaoFetchProposalState, continuumDaoFetchProposalVoteEligibility, continuumDaoFetchProposals, continuumDaoFetchVotingPower, continuumDaoForumCreateIdea, continuumDaoForumCreateTopic, continuumDaoForumDelete, continuumDaoForumFetchPost, continuumDaoForumFetchThread, continuumDaoForumMarkRead, continuumDaoForumMarkUnread, continuumDaoForumMe, continuumDaoForumReact, continuumDaoForumRecent, continuumDaoForumReply, continuumDaoForumReplyCount, continuumDaoForumResolve, continuumDaoForumSearch, continuumDaoForumSections, continuumDaoForumSignInEligible, continuumDaoForumSignInNonce, continuumDaoForumSignOut, continuumDaoForumUnread, continuumDaoForumUrl, continuumDaoForumUserPostIds, continuumDaoHashProposal, continuumDaoMpaFlag, continuumDaoMpaListing, continuumDaoMpaMailboxList, continuumDaoMpaMailboxOpen, continuumDaoMpaMailboxSend, continuumDaoMpaRetract, continuumDaoProtocolModule, continuumDaoRegisterProposal, continuumDaoSignatureText, continuumDaoTechnocoreBind, ctmTokenAddressOnEvmChain, encodeContinuumDaoNodeInfo, encodeDeltaMetadata, encodeDeltaVoteParams, encodeGovActionCalldata, expectedForumSectionForProposalType, explainGovAction, explainProposalRecord, floorUnlockTimeSeconds, governorAddressOnEvmChain, isConfiguredAddress, isContinuumDaoCtmOnAssetsChain, isContinuumDaoLockChain, isContinuumDaoSupportedChainId, isContinuumDaoVeCtmOnAssetsChain, isCtmTokenSymbol, isForumIdeaSection, isGovNoOpAction, isVotingEscrowContinuumName, listContinuumDaoDefaultAssets, maxLockDurationSeconds, preflightAttachVeCtm, preflightCreateLock, preflightDelegate, preflightIncreaseAmount, preflightIncreaseUnlockTime, preflightLiquidate, preflightMerge, preflightRequestDetach, preflightSplit, preflightTransfer, preflightUndelegate, preflightWithdraw, proposalDescriptionHash, readCtmBalanceWei, readMinimumLockWei, readVeCtmLockState, resolveAttachGroupId, summarizeLiveProposals, votingEscrowAddressOnEvmChain };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map