@continuumdao/ctm-mpc-defi 0.2.25 → 0.2.26

package/dist/protocols/evm/venice/index.js

@@ -0,0 +1,901 @@
+import { parseAbi, getAddress, formatUnits, parseUnits, encodeFunctionData, defineChain, createPublicClient, http, parseGwei, serializeTransaction, keccak256 } from 'viem';
+import { fetchChainFeeParams, gasLimitFromEstimateAndChainConfig, gweiToDecimalString, proposalTxParamsToFeeSnapshot, alignEip1559FeesWithLatestBase, getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+var VENICE_PROTOCOL_ID = "venice";
+var VENICE_BASE_CHAIN_ID = 8453;
+var VVV_BASE = "0xacfE6019Ed1A7Dc6f7B508C02d1b04ec88cC21bf";
+var DIEM_BASE = "0xF4d97F2da56e8c3098f3a8D538DB630A2606a024";
+var VENICE_STAKING_BASE = "0x321b7ff75154472B18EDb199033fF4D116F340Ff";
+var VENICE_TOKEN_DECIMALS = 18;
+var DIEM_TARGET_SUPPLY_HUMAN = 38e3;
+var VENICE_DOCS_VVV_DIEM = "https://docs.venice.ai/overview/vvv-diem";
+var VENICE_DIEM_CALCULATOR = "https://diem-calculator.venice.ai/";
+var VENICE_TOKEN_DASHBOARD = "https://venice.ai/token";
+function isVeniceBaseChain(chainId) {
+  return chainId === VENICE_BASE_CHAIN_ID;
+}
+function isVeniceVvvOnBase(chainId, tokenAddress) {
+  if (!isVeniceBaseChain(chainId)) return false;
+  try {
+    return getAddress(tokenAddress).toLowerCase() === getAddress(VVV_BASE).toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function isVeniceDiemOnBase(chainId, tokenAddress) {
+  if (!isVeniceBaseChain(chainId)) return false;
+  try {
+    return getAddress(tokenAddress).toLowerCase() === getAddress(DIEM_BASE).toLowerCase();
+  } catch {
+    return false;
+  }
+}
+function isVeniceTokenOnBase(chainId, tokenAddress) {
+  return isVeniceVvvOnBase(chainId, tokenAddress) || isVeniceDiemOnBase(chainId, tokenAddress);
+}
+function computeMintRateSvvcPerDiem(diemTotalSupplyWei) {
+  const supplyHuman = Number(formatUnits(diemTotalSupplyWei, VENICE_TOKEN_DECIMALS));
+  if (!Number.isFinite(supplyHuman) || supplyHuman < 0) return 90;
+  const ratio = supplyHuman / DIEM_TARGET_SUPPLY_HUMAN;
+  return 90 * Math.exp(2 * ratio ** 3);
+}
+function previewDiemMintedFromSvvcLock(args) {
+  const { svvvLockWei, diemTotalSupplyWei } = args;
+  if (svvvLockWei <= 0n) return 0n;
+  const rate = computeMintRateSvvcPerDiem(diemTotalSupplyWei);
+  if (!Number.isFinite(rate) || rate <= 0) return 0n;
+  const svvvHuman = Number(formatUnits(svvvLockWei, VENICE_TOKEN_DECIMALS));
+  const diemHuman = svvvHuman / rate;
+  if (!Number.isFinite(diemHuman) || diemHuman <= 0) return 0n;
+  return parseUnits(diemHuman.toFixed(12), VENICE_TOKEN_DECIMALS);
+}
+function applyMinOutSlippage(amountWei, slippageBps) {
+  if (amountWei <= 0n) return 0n;
+  const bps = Math.max(0, Math.min(1e4, slippageBps));
+  return amountWei * BigInt(1e4 - bps) / 10000n;
+}
+var erc20Abi = parseAbi([
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function totalSupply() view returns (uint256)"
+]);
+var diemStakingAbi = parseAbi([
+  "function stakedInfos(address) view returns (uint256 amountStaked, uint256 coolDownEnd, uint256 coolDownAmount)",
+  "function cooldownDuration() view returns (uint256)"
+]);
+var stakingCooldownAbi = parseAbi(["function cooldownDuration() view returns (uint256)"]);
+function basePublicClient(rpcUrl) {
+  const ch = defineChain({
+    id: VENICE_BASE_CHAIN_ID,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl.trim()] } }
+  });
+  return createPublicClient({ chain: ch, transport: http(rpcUrl.trim()) });
+}
+async function readVeniceDiemStakedInfo(args) {
+  const client = basePublicClient(args.rpcUrl);
+  const wallet = getAddress(args.wallet);
+  const diem = getAddress(DIEM_BASE);
+  const [amountStaked, coolDownEnd, coolDownAmount] = await client.readContract({
+    address: diem,
+    abi: diemStakingAbi,
+    functionName: "stakedInfos",
+    args: [wallet]
+  });
+  return {
+    amountStakedWei: amountStaked,
+    coolDownEndSec: coolDownEnd,
+    coolDownAmountWei: coolDownAmount
+  };
+}
+async function readVeniceWalletStakingState(args) {
+  const client = basePublicClient(args.rpcUrl);
+  const wallet = getAddress(args.wallet);
+  const vvv = getAddress(VVV_BASE);
+  const diem = getAddress(DIEM_BASE);
+  const staking = getAddress(VENICE_STAKING_BASE);
+  const [vvvBalanceWei, svvvBalanceWei, diemBalanceWei, diemTotalSupplyWei, diemStaked, diemCooldown, svvvCooldown] = await Promise.all([
+    client.readContract({ address: vvv, abi: erc20Abi, functionName: "balanceOf", args: [wallet] }),
+    client.readContract({ address: staking, abi: erc20Abi, functionName: "balanceOf", args: [wallet] }),
+    client.readContract({ address: diem, abi: erc20Abi, functionName: "balanceOf", args: [wallet] }),
+    client.readContract({ address: diem, abi: erc20Abi, functionName: "totalSupply" }),
+    readVeniceDiemStakedInfo({ rpcUrl: args.rpcUrl, wallet }),
+    client.readContract({ address: diem, abi: diemStakingAbi, functionName: "cooldownDuration" }),
+    client.readContract({ address: staking, abi: stakingCooldownAbi, functionName: "cooldownDuration" })
+  ]);
+  const mintRateSvvcPerDiem = computeMintRateSvvcPerDiem(diemTotalSupplyWei);
+  const stakedDiemHuman = formatUnits(diemStaked.amountStakedWei, VENICE_TOKEN_DECIMALS);
+  return {
+    chainId: VENICE_BASE_CHAIN_ID,
+    wallet,
+    vvvBalanceWei,
+    svvvBalanceWei,
+    diemBalanceWei,
+    diemStaked,
+    diemTotalSupplyWei,
+    mintRateSvvcPerDiem,
+    diemCooldownDurationSec: diemCooldown,
+    svvvCooldownDurationSec: svvvCooldown,
+    estimatedApiCreditUsdPerDay: stakedDiemHuman
+  };
+}
+function formatVeniceStakingStateSummary(state) {
+  return {
+    chainId: state.chainId,
+    wallet: state.wallet,
+    balances: {
+      vvvWei: state.vvvBalanceWei.toString(),
+      svvvWei: state.svvvBalanceWei.toString(),
+      diemWei: state.diemBalanceWei.toString(),
+      diemStakedWei: state.diemStaked.amountStakedWei.toString()
+    },
+    diemCooldown: {
+      pendingUnstakeWei: state.diemStaked.coolDownAmountWei.toString(),
+      unlockAtSec: state.diemStaked.coolDownEndSec.toString(),
+      cooldownDurationSec: state.diemCooldownDurationSec.toString()
+    },
+    svvvCooldownDurationSec: state.svvvCooldownDurationSec.toString(),
+    mintRateSvvcPerDiem: state.mintRateSvvcPerDiem,
+    diemTotalSupplyWei: state.diemTotalSupplyWei.toString(),
+    estimatedApiCreditUsdPerDay: state.estimatedApiCreditUsdPerDay
+  };
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
+  }
+  return (estimatedGas * 12n + 9n) / 10n;
+}
+
+// src/chains/evm/buildBatch.ts
+async function buildEvmMultisignBatch(args) {
+  const { context, steps } = args;
+  const {
+    chainId,
+    rpcUrl,
+    executorAddress,
+    chainDetail,
+    useCustomGas,
+    customGasChainDetails,
+    keyGen,
+    purposeText
+  } = context;
+  if (steps.length === 0) throw new Error("buildEvmMultisignBatch requires at least one step");
+  const ch = defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpcUrl) });
+  const feeParams = await fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await publicClient.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 publicClient.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, executor });
+    } else {
+      try {
+        estimatedGas = await publicClient.estimateGas({
+          to: step.to,
+          data: step.data,
+          value: step.value,
+          account: executor
+        });
+      } catch {
+        estimatedGas = step.fallbackGas ?? 100000n;
+      }
+    }
+    let gasLimitI;
+    if (args.resolveGasLimit) {
+      gasLimitI = await args.resolveGasLimit({ step, index: i, estimatedGas, publicClient });
+    } else if (step.routerSwap) {
+      gasLimitI = routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimitRouter);
+    } else {
+      gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    }
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
+    if (legacy) {
+      let gasPriceWei = await publicClient.getGasPrice();
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = parseGwei(gweiToDecimalString(Number(chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      serialized = serializeTransaction({
+        type: "legacy",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "legacy",
+        gasPrice: gasPriceWei.toString()
+      };
+      feeSnapshot = proposalTxParamsToFeeSnapshot(proposalTxParams);
+    } else {
+      const fetchedBase = feeParams.baseFeeGwei ?? 0;
+      const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
+      const configuredBase = useCustomGas && chainDetail?.baseFee != null ? Number(chainDetail.baseFee) : 0;
+      const configuredPriority = useCustomGas && chainDetail?.priorityFee != null ? Number(chainDetail.priorityFee) : 0;
+      const effectiveBaseFeeGwei = Math.max(fetchedBase, configuredBase);
+      const effectivePriorityFeeGwei = Math.max(fetchedPriority, configuredPriority);
+      const baseFeeMultiplierPct = useCustomGas && chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(chainDetail.baseFeeMultiplier)) : 100;
+      const baseComponentGwei = effectiveBaseFeeGwei * baseFeeMultiplierPct / 100;
+      const maxFeePerGasGwei = baseComponentGwei + effectivePriorityFeeGwei;
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : parseGwei("1");
+      let maxFeePerGas = parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
+        maxPriorityFeePerGas = maxPriorityFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+        maxFeePerGas = maxFeePerGas * BigInt(100 + gasFeeMultiplier) / 100n;
+      }
+      ({ maxFeePerGas, maxPriorityFeePerGas } = alignEip1559FeesWithLatestBase(
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        latestBaseFeeWei
+      ));
+      serialized = serializeTransaction({
+        type: "eip1559",
+        to: step.to,
+        data: step.data,
+        value: step.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId
+      });
+      proposalTxParams = {
+        nonce: currentNonce,
+        gasLimit: gasLimitI.toString(),
+        txType: "eip1559",
+        maxFeePerGas: maxFeePerGas.toString(),
+        maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
+      };
+      feeSnapshot = i === 0 ? proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = keccak256(serialized);
+    const msgHash = h.startsWith("0x") ? h.slice(2) : h;
+    const batchMetaExtra = args.buildBatchMeta({ step, index: i, gasLimit: gasLimitI });
+    legs.push({
+      msgHash,
+      msgRaw: i === 0 && args.firstMsgRawNo0x != null ? args.firstMsgRawNo0x : serialized,
+      destinationAddress: step.to,
+      signatureText: typeof batchMetaExtra.signatureText === "string" ? batchMetaExtra.signatureText : JSON.stringify(batchMetaExtra.signatureText ?? {}),
+      audit: batchMetaExtra,
+      feeSnapshot: i === 0 ? feeSnapshot : {},
+      proposalTxParams,
+      valueWei: i === 0 ? step.value : void 0
+    });
+    if (i === 0 && args.firstMsgRawNo0x != null) {
+      legs[0].msgRaw = args.firstMsgRawNo0x;
+    }
+  }
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
+  }
+  const result = finalizeMultisign({
+    keyGen,
+    purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: String(chainId),
+    destinationAddress: args.destinationAddress ?? steps[0].to,
+    legs,
+    extraJSON: Object.keys(extraJSON).length > 0 ? extraJSON : void 0,
+    expiryDate: context.expiryDate
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+var ERC20_APPROVE_FALLBACK = 100000n;
+var VENICE_STAKE_VVV_FALLBACK = 800000n;
+var VENICE_STAKING_ACTION_FALLBACK = 600000n;
+var VENICE_MINT_DIEM_FALLBACK = 1200000n;
+var erc20AllowanceAbi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function totalSupply() view returns (uint256)"
+]);
+var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var stakingAbi = parseAbi([
+  "function stake(uint256 amount)",
+  "function initiateUnstake(uint256 amount)",
+  "function unstake()",
+  "function mintDiem(uint256 sVVVAmountToLock, uint256 minDiemAmountOut)",
+  "function burnDiem(uint256 diemAmountToBurn)"
+]);
+var diemStakingAbi2 = parseAbi([
+  "function stake(uint256 amount)",
+  "function initiateUnstake(uint256 amount)",
+  "function unstake()"
+]);
+function assertVeniceBase(chainId) {
+  if (!isVeniceBaseChain(chainId)) {
+    throw new Error(`Venice protocol is only supported on Base (chain id ${VENICE_BASE_CHAIN_ID}).`);
+  }
+}
+function basePublicClient2(rpcUrl) {
+  const ch = defineChain({
+    id: VENICE_BASE_CHAIN_ID,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl.trim()] } }
+  });
+  return createPublicClient({ chain: ch, transport: http(rpcUrl.trim()) });
+}
+async function appendErc20ApproveIfNeeded(args) {
+  const client = basePublicClient2(args.rpcUrl);
+  const allowance = await client.readContract({
+    address: args.token,
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [args.owner, args.spender]
+  });
+  if (allowance >= args.amountWei) return;
+  if (allowance > 0n) {
+    args.steps.push({
+      kind: "approve",
+      to: args.token,
+      data: encodeFunctionData({ abi: erc20ApproveAbi, functionName: "approve", args: [args.spender, 0n] }),
+      value: 0n
+    });
+  }
+  args.steps.push({
+    kind: "approve",
+    to: args.token,
+    data: encodeFunctionData({
+      abi: erc20ApproveAbi,
+      functionName: "approve",
+      args: [args.spender, args.amountWei]
+    }),
+    value: 0n
+  });
+}
+async function buildVeniceBatch(args) {
+  assertVeniceBase(args.chainId);
+  const executor = getAddress(args.executorAddress);
+  const evmSteps = args.steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: s.kind === "approve" ? ERC20_APPROVE_FALLBACK : args.actionFallbackGas
+  }));
+  const firstDataNo0x = evmSteps[0].data.startsWith("0x") ? evmSteps[0].data.slice(2) : evmSteps[0].data;
+  const gasLimitConfig = args.useCustomGas && args.chainDetail?.gasLimit != null ? Number(args.chainDetail.gasLimit) : void 0;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: args.purposeText,
+      chainId: VENICE_BASE_CHAIN_ID,
+      rpcUrl: args.rpcUrl.trim(),
+      executorAddress: executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix: args.purposeSuffix,
+    firstMsgRawNo0x: firstDataNo0x,
+    destinationAddress: args.steps[0].to,
+    resolveGasLimit: ({ index, estimatedGas }) => {
+      const s = args.steps[index];
+      if (s.kind === "action" && index > 0) {
+        const gas = args.actionFallbackGas;
+        return args.useCustomGas ? gasLimitFromEstimateAndChainConfig(gas, gasLimitConfig) : gas;
+      }
+      return estimatedGas;
+    },
+    buildBatchMeta: ({ index, gasLimit }) => args.makeBatchMeta({ index, step: args.steps[index], gasLimit: BigInt(gasLimit) })
+  });
+}
+async function parseHumanAmount(args) {
+  const client = basePublicClient2(args.rpcUrl);
+  let dec = VENICE_TOKEN_DECIMALS;
+  try {
+    dec = Number(
+      await client.readContract({ address: args.token, abi: erc20AllowanceAbi, functionName: "decimals" })
+    );
+  } catch {
+  }
+  const amountWei = parseUnits(args.amountHuman.trim(), dec);
+  if (amountWei === 0n) throw new Error("Amount is zero after converting with token decimals.");
+  return amountWei;
+}
+async function buildEvmMultisignBodyVeniceStakeVvv(args) {
+  assertVeniceBase(args.chainId);
+  const vvv = getAddress(VVV_BASE);
+  const staking = getAddress(VENICE_STAKING_BASE);
+  const executor = getAddress(args.executorAddress);
+  const amountWei = await parseHumanAmount({ rpcUrl: args.rpcUrl, token: vvv, amountHuman: args.amountHuman });
+  const steps = [];
+  await appendErc20ApproveIfNeeded({ steps, rpcUrl: args.rpcUrl, token: vvv, spender: staking, owner: executor, amountWei });
+  steps.push({
+    kind: "action",
+    to: staking,
+    data: encodeFunctionData({ abi: stakingAbi, functionName: "stake", args: [amountWei] }),
+    value: 0n
+  });
+  const n = steps.length;
+  return buildVeniceBatch({
+    ...args,
+    executorAddress: executor,
+    steps,
+    actionFallbackGas: VENICE_STAKE_VVV_FALLBACK,
+    purposeSuffix: n === 1 ? "Venice: stake VVV \u2192 sVVV on Base (allowance already set)." : `Venice: ${n}-tx batch \u2014 approve VVV, then stake on Base.`,
+    makeBatchMeta: ({ step }) => ({
+      signatureText: JSON.stringify({
+        kind: "Venice",
+        step: step.kind === "approve" ? "approve_vvv" : "stake_vvv",
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "venice_stake_vvv", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceInitiateUnstakeSvvv(args) {
+  assertVeniceBase(args.chainId);
+  const staking = getAddress(VENICE_STAKING_BASE);
+  const amountWei = await parseHumanAmount({
+    rpcUrl: args.rpcUrl,
+    token: staking,
+    amountHuman: args.amountHuman
+  });
+  const steps = [
+    {
+      kind: "action",
+      to: staking,
+      data: encodeFunctionData({ abi: stakingAbi, functionName: "initiateUnstake", args: [amountWei] }),
+      value: 0n
+    }
+  ];
+  return buildVeniceBatch({
+    ...args,
+    steps,
+    actionFallbackGas: VENICE_STAKING_ACTION_FALLBACK,
+    purposeSuffix: "Venice: initiate sVVV unstake on Base (7-day cooldown before claim).",
+    makeBatchMeta: () => ({
+      signatureText: JSON.stringify({ kind: "Venice", step: "initiate_unstake_svvv", amountHuman: args.amountHuman }),
+      evm: { type: "venice_initiate_unstake_svvv", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceCompleteUnstakeSvvv(args) {
+  assertVeniceBase(args.chainId);
+  const staking = getAddress(VENICE_STAKING_BASE);
+  const steps = [
+    {
+      kind: "action",
+      to: staking,
+      data: encodeFunctionData({ abi: stakingAbi, functionName: "unstake", args: [] }),
+      value: 0n
+    }
+  ];
+  return buildVeniceBatch({
+    ...args,
+    steps,
+    actionFallbackGas: VENICE_STAKING_ACTION_FALLBACK,
+    purposeSuffix: "Venice: claim VVV after sVVV unstake cooldown on Base.",
+    makeBatchMeta: () => ({
+      signatureText: JSON.stringify({ kind: "Venice", step: "complete_unstake_svvv" }),
+      evm: { type: "venice_complete_unstake_svvv", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceMintDiem(args) {
+  assertVeniceBase(args.chainId);
+  const staking = getAddress(VENICE_STAKING_BASE);
+  const lockWei = await parseHumanAmount({
+    rpcUrl: args.rpcUrl,
+    token: staking,
+    amountHuman: args.svvvLockAmountHuman
+  });
+  const client = basePublicClient2(args.rpcUrl);
+  const diemTotalSupply = await client.readContract({
+    address: getAddress(DIEM_BASE),
+    abi: erc20AllowanceAbi,
+    functionName: "totalSupply"
+  });
+  const expectedDiem = previewDiemMintedFromSvvcLock({ svvvLockWei: lockWei, diemTotalSupplyWei: diemTotalSupply });
+  const minDiem = applyMinOutSlippage(expectedDiem, args.slippageBps ?? 50);
+  const steps = [
+    {
+      kind: "action",
+      to: staking,
+      data: encodeFunctionData({
+        abi: stakingAbi,
+        functionName: "mintDiem",
+        args: [lockWei, minDiem]
+      }),
+      value: 0n
+    }
+  ];
+  return buildVeniceBatch({
+    ...args,
+    steps,
+    actionFallbackGas: VENICE_MINT_DIEM_FALLBACK,
+    purposeSuffix: "Venice: lock sVVV and mint DIEM on Base.",
+    makeBatchMeta: () => ({
+      signatureText: JSON.stringify({
+        kind: "Venice",
+        step: "mint_diem",
+        svvvLockAmountHuman: args.svvvLockAmountHuman,
+        minDiemOutWei: minDiem.toString()
+      }),
+      evm: { type: "venice_mint_diem", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceBurnDiem(args) {
+  assertVeniceBase(args.chainId);
+  const staking = getAddress(VENICE_STAKING_BASE);
+  const diem = getAddress(DIEM_BASE);
+  const executor = getAddress(args.executorAddress);
+  const amountWei = await parseHumanAmount({ rpcUrl: args.rpcUrl, token: diem, amountHuman: args.amountHuman });
+  const steps = [];
+  await appendErc20ApproveIfNeeded({ steps, rpcUrl: args.rpcUrl, token: diem, spender: staking, owner: executor, amountWei });
+  steps.push({
+    kind: "action",
+    to: staking,
+    data: encodeFunctionData({ abi: stakingAbi, functionName: "burnDiem", args: [amountWei] }),
+    value: 0n
+  });
+  const n = steps.length;
+  return buildVeniceBatch({
+    ...args,
+    executorAddress: executor,
+    steps,
+    actionFallbackGas: VENICE_MINT_DIEM_FALLBACK,
+    purposeSuffix: n === 1 ? "Venice: burn DIEM to unlock sVVV on Base (allowance already set)." : `Venice: ${n}-tx batch \u2014 approve DIEM, then burn to unlock sVVV.`,
+    makeBatchMeta: ({ step }) => ({
+      signatureText: JSON.stringify({
+        kind: "Venice",
+        step: step.kind === "approve" ? "approve_diem_burn" : "burn_diem",
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "venice_burn_diem", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceStakeDiem(args) {
+  assertVeniceBase(args.chainId);
+  const diem = getAddress(DIEM_BASE);
+  const executor = getAddress(args.executorAddress);
+  const amountWei = await parseHumanAmount({ rpcUrl: args.rpcUrl, token: diem, amountHuman: args.amountHuman });
+  const steps = [];
+  await appendErc20ApproveIfNeeded({ steps, rpcUrl: args.rpcUrl, token: diem, spender: diem, owner: executor, amountWei });
+  steps.push({
+    kind: "action",
+    to: diem,
+    data: encodeFunctionData({ abi: diemStakingAbi2, functionName: "stake", args: [amountWei] }),
+    value: 0n
+  });
+  const n = steps.length;
+  return buildVeniceBatch({
+    ...args,
+    executorAddress: executor,
+    steps,
+    actionFallbackGas: VENICE_STAKE_VVV_FALLBACK,
+    purposeSuffix: n === 1 ? "Venice: stake DIEM for API credits on Base (allowance already set)." : `Venice: ${n}-tx batch \u2014 approve DIEM, then stake for API credits.`,
+    makeBatchMeta: ({ step }) => ({
+      signatureText: JSON.stringify({
+        kind: "Venice",
+        step: step.kind === "approve" ? "approve_diem_stake" : "stake_diem",
+        amountHuman: args.amountHuman
+      }),
+      evm: { type: "venice_stake_diem", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceInitiateUnstakeDiem(args) {
+  assertVeniceBase(args.chainId);
+  const diem = getAddress(DIEM_BASE);
+  const amountWei = await parseHumanAmount({ rpcUrl: args.rpcUrl, token: diem, amountHuman: args.amountHuman });
+  const steps = [
+    {
+      kind: "action",
+      to: diem,
+      data: encodeFunctionData({ abi: diemStakingAbi2, functionName: "initiateUnstake", args: [amountWei] }),
+      value: 0n
+    }
+  ];
+  return buildVeniceBatch({
+    ...args,
+    steps,
+    actionFallbackGas: VENICE_STAKING_ACTION_FALLBACK,
+    purposeSuffix: "Venice: initiate DIEM unstake on Base (1-day cooldown).",
+    makeBatchMeta: () => ({
+      signatureText: JSON.stringify({ kind: "Venice", step: "initiate_unstake_diem", amountHuman: args.amountHuman }),
+      evm: { type: "venice_initiate_unstake_diem", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+async function buildEvmMultisignBodyVeniceCompleteUnstakeDiem(args) {
+  assertVeniceBase(args.chainId);
+  const diem = getAddress(DIEM_BASE);
+  const steps = [
+    {
+      kind: "action",
+      to: diem,
+      data: encodeFunctionData({ abi: diemStakingAbi2, functionName: "unstake", args: [] }),
+      value: 0n
+    }
+  ];
+  return buildVeniceBatch({
+    ...args,
+    steps,
+    actionFallbackGas: VENICE_STAKING_ACTION_FALLBACK,
+    purposeSuffix: "Venice: claim DIEM after unstake cooldown on Base.",
+    makeBatchMeta: () => ({
+      signatureText: JSON.stringify({ kind: "Venice", step: "complete_unstake_diem" }),
+      evm: { type: "venice_complete_unstake_diem", version: 1, chainId: String(VENICE_BASE_CHAIN_ID) }
+    })
+  });
+}
+
+// src/protocols/evm/venice/veniceApi.ts
+var VENICE_MODELS_URL = "https://api.venice.ai/api/v1/models";
+async function fetchVeniceModels(args) {
+  const type = (args?.type ?? "all").trim() || "all";
+  const url = `${VENICE_MODELS_URL}?type=${encodeURIComponent(type)}`;
+  const headers = { Accept: "application/json" };
+  const key = args?.apiKey?.trim();
+  if (key) headers.Authorization = `Bearer ${key}`;
+  const res = await fetch(url, { headers, signal: AbortSignal.timeout(3e4) });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`Venice models API ${res.status}: ${text.slice(0, 200)}`);
+  }
+  const json = await res.json();
+  const raw = Array.isArray(json.data) ? json.data : Array.isArray(json.models) ? json.models : [];
+  const models = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object") continue;
+    const o = item;
+    const id = String(o.id ?? o.model ?? o.name ?? "").trim();
+    if (!id) continue;
+    const spec = o.model_spec ?? o.spec;
+    models.push({
+      id,
+      type: String(o.type ?? spec?.type ?? "").trim() || void 0,
+      offline: Boolean(o.offline ?? spec?.offline),
+      beta: Boolean(o.beta ?? spec?.beta)
+    });
+  }
+  return { models };
+}
+async function veniceListModelsSummary(args) {
+  const { models } = await fetchVeniceModels(args);
+  return {
+    type: args?.type ?? "all",
+    count: models.length,
+    models
+  };
+}
+
+// src/protocols/evm/venice/mcpReads.ts
+async function veniceReadStakingStateSummary(args) {
+  const chainId = args.chainId ?? VENICE_BASE_CHAIN_ID;
+  if (chainId !== VENICE_BASE_CHAIN_ID) {
+    throw new Error(`Venice staking reads require Base chain id ${VENICE_BASE_CHAIN_ID}.`);
+  }
+  const wallet = getAddress(args.executorAddress);
+  const state = await readVeniceWalletStakingState({ rpcUrl: args.rpcUrl, wallet });
+  return formatVeniceStakingStateSummary(state);
+}
+async function veniceReadMintDiemPreviewSummary(args) {
+  const ch = defineChain({
+    id: VENICE_BASE_CHAIN_ID,
+    name: "Base",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl.trim()] } }
+  });
+  const client = createPublicClient({ chain: ch, transport: http(args.rpcUrl.trim()) });
+  const lockWei = parseUnits(args.svvvLockAmountHuman.trim(), VENICE_TOKEN_DECIMALS);
+  const diemTotalSupply = await client.readContract({
+    address: getAddress(DIEM_BASE),
+    abi: parseAbi(["function totalSupply() view returns (uint256)"]),
+    functionName: "totalSupply"
+  });
+  const mintRate = computeMintRateSvvcPerDiem(diemTotalSupply);
+  const expectedDiemWei = previewDiemMintedFromSvvcLock({ svvvLockWei: lockWei, diemTotalSupplyWei: diemTotalSupply });
+  return {
+    svvvLockAmountHuman: args.svvvLockAmountHuman,
+    svvvLockWei: lockWei.toString(),
+    mintRateSvvcPerDiem: mintRate,
+    expectedDiemWei: expectedDiemWei.toString(),
+    diemTotalSupplyWei: diemTotalSupply.toString(),
+    stakingContract: getAddress(VENICE_STAKING_BASE)
+  };
+}
+
+// src/protocols/evm/venice/index.ts
+var veniceProtocolModule = {
+  id: VENICE_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    return isVeniceBaseChain(n);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "venice.stake-vvv",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Stake VVV \u2192 sVVV on Base",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { amountHuman: { type: "string", required: true, description: "VVV amount" } }
+    },
+    {
+      id: "venice.initiate-unstake-svvv",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Start sVVV unstake (7-day cooldown)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { amountHuman: { type: "string", required: true, description: "sVVV amount" } }
+    },
+    {
+      id: "venice.complete-unstake-svvv",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim VVV after sVVV unstake cooldown",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "venice.mint-diem",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Lock sVVV and mint DIEM",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        svvvLockAmountHuman: { type: "string", required: true, description: "sVVV to lock" },
+        slippageBps: { type: "number", required: false, description: "Min DIEM slippage bps (default 50)" }
+      }
+    },
+    {
+      id: "venice.burn-diem",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Burn DIEM to unlock locked sVVV",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { amountHuman: { type: "string", required: true, description: "DIEM to burn" } }
+    },
+    {
+      id: "venice.stake-diem",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Stake DIEM for Venice API credits ($1/day per DIEM)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { amountHuman: { type: "string", required: true, description: "DIEM amount" } }
+    },
+    {
+      id: "venice.initiate-unstake-diem",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Start DIEM unstake (1-day cooldown)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { amountHuman: { type: "string", required: true, description: "Staked DIEM amount" } }
+    },
+    {
+      id: "venice.complete-unstake-diem",
+      protocolId: VENICE_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim DIEM after unstake cooldown",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(veniceProtocolModule);
+var VENICE_BASE_TOKENS = {
+  chainId: VENICE_BASE_CHAIN_ID,
+  vvv: VVV_BASE,
+  diem: DIEM_BASE
+};
+
+export { DIEM_BASE, DIEM_TARGET_SUPPLY_HUMAN, VENICE_BASE_CHAIN_ID, VENICE_BASE_TOKENS, VENICE_DIEM_CALCULATOR, VENICE_DOCS_VVV_DIEM, VENICE_PROTOCOL_ID, VENICE_STAKING_BASE, VENICE_TOKEN_DASHBOARD, VENICE_TOKEN_DECIMALS, VVV_BASE, applyMinOutSlippage, buildEvmMultisignBodyVeniceBurnDiem, buildEvmMultisignBodyVeniceCompleteUnstakeDiem, buildEvmMultisignBodyVeniceCompleteUnstakeSvvv, buildEvmMultisignBodyVeniceInitiateUnstakeDiem, buildEvmMultisignBodyVeniceInitiateUnstakeSvvv, buildEvmMultisignBodyVeniceMintDiem, buildEvmMultisignBodyVeniceStakeDiem, buildEvmMultisignBodyVeniceStakeVvv, computeMintRateSvvcPerDiem, fetchVeniceModels, formatVeniceStakingStateSummary, isVeniceBaseChain, isVeniceDiemOnBase, isVeniceTokenOnBase, isVeniceVvvOnBase, previewDiemMintedFromSvvcLock, readVeniceDiemStakedInfo, readVeniceWalletStakingState, veniceListModelsSummary, veniceProtocolModule, veniceReadMintDiemPreviewSummary, veniceReadStakingStateSummary };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map