@continuumdao/ctm-mpc-defi 0.2.0 → 0.2.2

package/dist/protocols/evm/sky/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var viem = require('viem');
+var continuumNodeSdk = require('@continuumdao/continuum-node-sdk');
 
 // src/core/registry.ts
 var modules = [];
@@ -25,266 +26,291 @@ var SKY_LOCKSTAKE_DEFAULT_FARM_REF = 1;
 var SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR = 0.65;
 var SKY_TOKEN_DECIMALS = 18;
 var USDS_DECIMALS = 18;
-async function fetchChainFeeParams(rpcUrl, chainId) {
-  const url = rpcUrl.trim();
-  if (!url) return { isEip1559: false };
-  const chainIdNum = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
-  if (Number.isNaN(chainIdNum)) return { isEip1559: false };
-  const chain = viem.defineChain({
-    id: chainIdNum,
-    name: "Discovery",
-    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
-    rpcUrls: { default: { http: [url] } }
-  });
-  const publicClient = viem.createPublicClient({
-    chain,
-    transport: viem.http(url)
-  });
-  const getGasPriceGwei = async () => {
-    const gasPriceWei = await publicClient.getGasPrice();
-    return parseFloat(viem.formatUnits(gasPriceWei, 9));
-  };
-  try {
-    const block = await publicClient.getBlock({ blockTag: "latest" });
-    const baseFeePerGas = block?.baseFeePerGas;
-    if (baseFeePerGas == null || baseFeePerGas === void 0) {
-      const gasPriceGwei2 = await getGasPriceGwei();
-      return { isEip1559: false, gasPriceGwei: gasPriceGwei2 };
-    }
-    const baseFeeGwei = parseFloat(viem.formatUnits(baseFeePerGas, 9));
-    let priorityFeeGwei;
-    try {
-      const priorityWei = await publicClient.estimateMaxPriorityFeePerGas();
-      priorityFeeGwei = parseFloat(viem.formatUnits(priorityWei, 9));
-    } catch {
-    }
-    const gasPriceGwei = await getGasPriceGwei();
-    return {
-      isEip1559: true,
-      baseFeeGwei,
-      priorityFeeGwei,
-      gasPriceGwei
-    };
-  } catch {
-    try {
-      const gasPriceWei = await publicClient.getGasPrice();
-      const gasPriceGwei = parseFloat(viem.formatUnits(gasPriceWei, 9));
-      return { isEip1559: false, gasPriceGwei };
-    } catch {
-      return { isEip1559: false };
-    }
-  }
+
+// 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;
 }
-function finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, floor, baseWei) {
-  let maxP = maxPriorityFeePerGas;
-  let maxF = maxFeePerGas;
-  if (baseWei > 0n && maxF < baseWei + maxP) {
-    maxF = baseWei + maxP + viem.parseGwei("0.001");
+
+// 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");
   }
-  if (maxF < maxP) {
-    maxF = baseWei > 0n ? baseWei + maxP + viem.parseGwei("0.001") : maxP * 2n;
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = continuumNodeSdk.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);
+  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;
   }
-  return { maxFeePerGas: maxF, maxPriorityFeePerGas: maxP };
-}
-function alignEip1559FeesWithLatestBase(maxFeePerGas, maxPriorityFeePerGas, latestBlockBaseFeeWei) {
-  return finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, null, latestBlockBaseFeeWei);
-}
-
-// src/chains/evm/txParams.ts
-function gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit) {
-  if (chainGasLimit == null || !Number.isFinite(chainGasLimit) || chainGasLimit <= 0) {
-    return estimatedGas;
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
   }
-  const cfg = BigInt(Math.floor(chainGasLimit));
-  return cfg > estimatedGas ? cfg : estimatedGas;
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
 }
-
-// src/core/keygen.ts
-function firstClientIdFromKeyGen(data) {
-  const map = data?.ClientKeys;
-  if (!map || typeof map !== "object") return null;
-  for (const v of Object.values(map)) {
-    if (typeof v === "string" && v.trim()) return v.trim();
+function routerSwapGasLimitFromEstimate(estimatedGas, chainGasLimit) {
+  if (chainGasLimit != null && Number.isFinite(chainGasLimit) && chainGasLimit > 0) {
+    return continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, chainGasLimit);
   }
-  return null;
+  return (estimatedGas * 12n + 9n) / 10n;
 }
 
-// src/protocols/evm/sky/lockstakeMultisign.ts
-var SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS = 5000000n;
-var erc20AllowanceAbi = viem.parseAbi([
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "function decimals() view returns (uint8)"
-]);
-var erc20ApproveAbi = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
-var engineAbi = viem.parseAbi([
-  "function multicall(bytes[] data) returns (bytes[])",
-  "function open(uint256 index) returns (address)",
-  "function selectFarm(address owner, uint256 index, address farm, uint16 ref)",
-  /** Canonical SKY collateral (pulls ERC-20 `sky()`, then `mkrSky.skyToMkr`). Legacy `lock` pulls MKR only. */
-  "function lockSky(address owner, uint256 index, uint256 skyWad, uint16 ref)",
-  "function draw(address owner, uint256 index, address to, uint256 wad)",
-  "function wipe(address owner, uint256 index, uint256 wad)",
-  "function wipeAll(address owner, uint256 index) returns (uint256 wad)",
-  /** Returns withdrawn SKY; legacy `free` returns MKR after fee-burn. */
-  "function freeSky(address owner, uint256 index, address to, uint256 skyWad) returns (uint256 skyFreed)",
-  "function getReward(address owner, uint256 index, address farm, address to) returns (uint256)",
-  "function ownerUrnsCount(address usr) view returns (uint256)",
-  "function ownerUrns(address owner, uint256 index) view returns (address urn)",
-  "function urnFarms(address urn) view returns (address farm)",
-  "function farms(address farm) view returns (uint8)"
-]);
-var stakingRewardsFarmReadAbi = viem.parseAbi([
-  "function stakingToken() view returns (address)",
-  "function rewardsToken() view returns (address)"
-]);
-function gweiToDecimalString(n) {
-  if (!Number.isFinite(n)) return "0";
-  if (n === 0) return "0";
-  const s = String(n);
-  if (s.indexOf("e") !== -1 || s.indexOf("E") !== -1) return n.toFixed(9).replace(/\.?0+$/, "") || "0";
-  return s;
-}
-async function appendSerializedSkyBatch(args) {
-  const ph = (args.keyGen.pubkeyhex ?? "").trim();
-  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
-  const keyList = args.keyGen.keylist ?? [];
-  const clientId = firstClientIdFromKeyGen(args.keyGen);
-  const feeParams = await fetchChainFeeParams(args.rpcUrl, args.chainId);
-  const legacy = Boolean(args.chainDetail?.legacy) || !feeParams.isEip1559;
-  const latestBaseFeeWei = !legacy ? (await args.publicClient.getBlock({ blockTag: "latest" })).baseFeePerGas ?? 0n : 0n;
-  const useCustomGas = args.useCustomGas;
-  const gasLimitConfig = useCustomGas && args.chainDetail?.gasLimit != null ? Number(args.chainDetail.gasLimit) : void 0;
-  const gasFeeMultiplier = useCustomGas && args.chainDetail?.gasMultiplier != null ? Number(args.chainDetail.gasMultiplier) : void 0;
-  const baseNonce = await args.publicClient.getTransactionCount({ address: args.executor, blockTag: "pending" });
-  const messageHashes = [];
-  const messageRawBatch = [];
-  const proposalTxParamsBatch = [];
-  let firstTxFeePayload = {};
-  let firstDataNo0x = "";
-  for (let i = 0; i < args.steps.length; i++) {
-    const s = args.steps[i];
+// 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 = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpcUrl) });
+  const feeParams = await continuumNodeSdk.fetchChainFeeParams(rpcUrl, chainId);
+  const legacy = Boolean(chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await 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 = viem.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;
-    try {
-      estimatedGas = await args.publicClient.estimateGas({
-        to: s.to,
-        data: s.data,
-        value: s.value,
-        account: args.executor
-      });
-    } catch {
-      estimatedGas = SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS;
+    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 ? continuumNodeSdk.gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
     }
-    const gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    let proposalTxParams;
+    let feeSnapshot;
+    let serialized;
     if (legacy) {
-      let gasPriceWei = await args.publicClient.getGasPrice();
+      let gasPriceWei = await publicClient.getGasPrice();
       if (useCustomGas && gasFeeMultiplier != null && gasFeeMultiplier > 0) {
         gasPriceWei = gasPriceWei * BigInt(100 + gasFeeMultiplier) / 100n;
       }
-      if (useCustomGas && args.chainDetail?.gasPrice != null && args.chainDetail.gasPrice > 0) {
-        const configured = viem.parseGwei(gweiToDecimalString(Number(args.chainDetail.gasPrice)));
+      if (useCustomGas && chainDetail?.gasPrice != null && chainDetail.gasPrice > 0) {
+        const configured = viem.parseGwei(continuumNodeSdk.gweiToDecimalString(Number(chainDetail.gasPrice)));
         if (configured > gasPriceWei) gasPriceWei = configured;
       }
-      const ser = viem.serializeTransaction({
+      serialized = viem.serializeTransaction({
         type: "legacy",
-        to: s.to,
-        data: s.data,
-        value: s.value,
+        to: step.to,
+        data: step.data,
+        value: step.value,
         gas: gasLimitI,
         gasPrice: gasPriceWei,
         nonce: currentNonce,
-        chainId: args.chainId
+        chainId
       });
-      const h = viem.keccak256(ser);
-      messageHashes.push(h.startsWith("0x") ? h.slice(2) : h);
-      messageRawBatch.push(ser);
-      proposalTxParamsBatch.push({
+      proposalTxParams = {
         nonce: currentNonce,
         gasLimit: gasLimitI.toString(),
         txType: "legacy",
         gasPrice: gasPriceWei.toString()
-      });
-      if (i === 0) {
-        firstTxFeePayload = { txNonce: currentNonce, txGasLimit: gasLimitI.toString(), txGasPrice: gasPriceWei.toString() };
-        firstDataNo0x = s.data.startsWith("0x") ? s.data.slice(2) : s.data;
-      }
+      };
+      feeSnapshot = continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams);
     } else {
       const fetchedBase = feeParams.baseFeeGwei ?? 0;
       const fetchedPriority = feeParams.priorityFeeGwei ?? 0;
-      const configuredBase = useCustomGas && args.chainDetail?.baseFee != null ? Number(args.chainDetail.baseFee) : 0;
-      const configuredPriority = useCustomGas && args.chainDetail?.priorityFee != null ? Number(args.chainDetail.priorityFee) : 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 && args.chainDetail?.baseFeeMultiplier != null ? Math.max(100, Number(args.chainDetail.baseFeeMultiplier)) : 100;
+      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 ? viem.parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
-      let maxFeePerGas = viem.parseGwei(gweiToDecimalString(maxFeePerGasGwei));
+      let maxPriorityFeePerGas = effectivePriorityFeeGwei > 0 ? viem.parseGwei(continuumNodeSdk.gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.parseGwei(continuumNodeSdk.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 } = continuumNodeSdk.alignEip1559FeesWithLatestBase(
         maxFeePerGas,
         maxPriorityFeePerGas,
         latestBaseFeeWei
       ));
-      const ser = viem.serializeTransaction({
+      serialized = viem.serializeTransaction({
         type: "eip1559",
-        to: s.to,
-        data: s.data,
-        value: s.value,
+        to: step.to,
+        data: step.data,
+        value: step.value,
         gas: gasLimitI,
         maxFeePerGas,
         maxPriorityFeePerGas,
         nonce: currentNonce,
-        chainId: args.chainId
+        chainId
       });
-      const h = viem.keccak256(ser);
-      messageHashes.push(h.startsWith("0x") ? h.slice(2) : h);
-      messageRawBatch.push(ser);
-      proposalTxParamsBatch.push({
+      proposalTxParams = {
         nonce: currentNonce,
         gasLimit: gasLimitI.toString(),
         txType: "eip1559",
         maxFeePerGas: maxFeePerGas.toString(),
         maxPriorityFeePerGas: maxPriorityFeePerGas.toString()
-      });
-      if (i === 0) {
-        firstTxFeePayload = {
-          txNonce: currentNonce,
-          txGasLimit: gasLimitI.toString(),
-          txMaxFeePerGas: maxFeePerGas.toString(),
-          txMaxPriorityFeePerGas: maxPriorityFeePerGas.toString()
-        };
-        firstDataNo0x = s.data.startsWith("0x") ? s.data.slice(2) : s.data;
-      }
+      };
+      feeSnapshot = i === 0 ? continuumNodeSdk.proposalTxParamsToFeeSnapshot(proposalTxParams) : {};
+    }
+    const h = viem.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 batchMeta = args.steps.map((s) => s.meta);
-  const extraPayload = { batchMeta };
-  if (useCustomGas && args.customGasChainDetails && Object.keys(args.customGasChainDetails).length > 0) {
-    extraPayload.customGasChainDetails = args.customGasChainDetails;
+  const extraJSON = {};
+  if (useCustomGas && customGasChainDetails && Object.keys(customGasChainDetails).length > 0) {
+    extraJSON.customGasChainDetails = customGasChainDetails;
   }
-  const extraJSON = JSON.stringify(extraPayload);
-  const firstSigText = batchMeta[0].signatureText;
-  const bodyForSign = {
-    keyList,
-    pubKey: ph,
-    msgHash: messageHashes[0],
-    msgRaw: firstDataNo0x,
-    messageHashes,
-    messageRawBatch,
-    destinationChainID: args.destinationChainID,
+  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
+  });
+  const pv = args.payableValueWei;
+  if (pv != null && pv > 0n) {
+    result.bodyForSign.value = pv.toString();
+  }
+  return result;
+}
+
+// src/protocols/evm/sky/lockstakeMultisign.ts
+var SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS = 5000000n;
+var erc20AllowanceAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var erc20ApproveAbi = viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var engineAbi = viem.parseAbi([
+  "function multicall(bytes[] data) returns (bytes[])",
+  "function open(uint256 index) returns (address)",
+  "function selectFarm(address owner, uint256 index, address farm, uint16 ref)",
+  /** Canonical SKY collateral (pulls ERC-20 `sky()`, then `mkrSky.skyToMkr`). Legacy `lock` pulls MKR only. */
+  "function lockSky(address owner, uint256 index, uint256 skyWad, uint16 ref)",
+  "function draw(address owner, uint256 index, address to, uint256 wad)",
+  "function wipe(address owner, uint256 index, uint256 wad)",
+  "function wipeAll(address owner, uint256 index) returns (uint256 wad)",
+  /** Returns withdrawn SKY; legacy `free` returns MKR after fee-burn. */
+  "function freeSky(address owner, uint256 index, address to, uint256 skyWad) returns (uint256 skyFreed)",
+  "function getReward(address owner, uint256 index, address farm, address to) returns (uint256)",
+  "function ownerUrnsCount(address usr) view returns (uint256)",
+  "function ownerUrns(address owner, uint256 index) view returns (address urn)",
+  "function urnFarms(address urn) view returns (address farm)",
+  "function farms(address farm) view returns (uint8)"
+]);
+var stakingRewardsFarmReadAbi = viem.parseAbi([
+  "function stakingToken() view returns (address)",
+  "function rewardsToken() view returns (address)"
+]);
+async function appendSerializedSkyBatch(args) {
+  const evmSteps = args.steps.map((s) => ({
+    to: s.to,
+    data: s.data,
+    value: s.value,
+    fallbackGas: SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS
+  }));
+  const firstDataNo0x = evmSteps[0].data.startsWith("0x") ? evmSteps[0].data.slice(2) : evmSteps[0].data;
+  return buildEvmMultisignBatch({
+    context: {
+      chainCategory: "evm",
+      keyGen: args.keyGen,
+      purposeText: "",
+      chainId: args.chainId,
+      rpcUrl: args.rpcUrl,
+      executorAddress: args.executor,
+      chainDetail: args.chainDetail,
+      useCustomGas: args.useCustomGas,
+      customGasChainDetails: args.customGasChainDetails
+    },
+    steps: evmSteps,
+    purposeSuffix: args.purposePrefix,
+    firstMsgRawNo0x: firstDataNo0x,
     destinationAddress: args.steps[0].to,
-    extraJSON,
-    signatureText: firstSigText,
-    purpose: args.purposePrefix,
-    ...firstTxFeePayload,
-    proposalTxParams: proposalTxParamsBatch
-  };
-  if (clientId) bodyForSign.clientId = clientId;
-  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+    buildBatchMeta: ({ index }) => args.steps[index].meta
+  });
 }
 async function buildSkyLockstakeStakePositionBatch(args) {
   if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
@@ -523,7 +549,6 @@ async function buildSkyLockstakeStakePositionBatch(args) {
   })();
   return appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -531,9 +556,7 @@ async function buildSkyLockstakeStakePositionBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
-  });
+    keyGen: args.keyGen});
 }
 async function buildSkyLockstakeDrawBatch(args) {
   if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
@@ -591,7 +614,6 @@ async function buildSkyLockstakeDrawBatch(args) {
   })();
   return appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -599,9 +621,7 @@ async function buildSkyLockstakeDrawBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
-  });
+    keyGen: args.keyGen});
 }
 async function buildSkyLockstakeGetRewardBatch(args) {
   if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
@@ -670,7 +690,6 @@ async function buildSkyLockstakeGetRewardBatch(args) {
   })();
   const built = await appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -678,9 +697,7 @@ async function buildSkyLockstakeGetRewardBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
-  });
+    keyGen: args.keyGen});
   return { ...built, rewardToken };
 }
 async function buildSkyLockstakeWipeBatch(args) {
@@ -827,7 +844,6 @@ async function buildSkyLockstakeWipeBatch(args) {
   })();
   return appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -835,9 +851,7 @@ async function buildSkyLockstakeWipeBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
-  });
+    keyGen: args.keyGen});
 }
 async function buildSkyLockstakeCloseBatch(args) {
   if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
@@ -849,7 +863,7 @@ async function buildSkyLockstakeCloseBatch(args) {
     nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
     rpcUrls: { default: { http: [rpc] } }
   });
-  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
+  viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
   const executor = viem.getAddress(args.executorAddress);
   const engine = viem.getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
   const usds = viem.getAddress(USDS_ETHEREUM_MAINNET);
@@ -927,7 +941,6 @@ async function buildSkyLockstakeCloseBatch(args) {
   })();
   return appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -935,9 +948,7 @@ async function buildSkyLockstakeCloseBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
-  });
+    keyGen: args.keyGen});
 }
 var SKY_FRAGILE_ETH_ESTIMATE_GAS_BATCH_EVMS = /* @__PURE__ */ new Set([
   "sky_lockstake_engine_multicall_stake",
@@ -1066,7 +1077,6 @@ async function buildSkySusdsRedeemToUsdsBatch(args) {
   })();
   return appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -1074,9 +1084,7 @@ async function buildSkySusdsRedeemToUsdsBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
-  });
+    keyGen: args.keyGen});
 }
 async function buildSkySusdsDepositFromUsdsBatch(args) {
   if (args.chainId !== 1) throw new Error("Sky sUSDS deposit is only supported on Ethereum mainnet (chain id 1).");
@@ -1190,7 +1198,6 @@ async function buildSkySusdsDepositFromUsdsBatch(args) {
   })();
   return appendSerializedSkyBatch({
     steps,
-    publicClient,
     executor,
     chainId: 1,
     rpcUrl: rpc,
@@ -1198,9 +1205,215 @@ async function buildSkySusdsDepositFromUsdsBatch(args) {
     useCustomGas: args.useCustomGas,
     customGasChainDetails: args.customGasChainDetails,
     purposePrefix,
-    keyGen: args.keyGen,
-    destinationChainID: "1"
+    keyGen: args.keyGen});
+}
+var RAY = 10n ** 27n;
+var engineAbi2 = viem.parseAbi([
+  "function ownerUrnsCount(address usr) view returns (uint256)",
+  "function ownerUrns(address owner, uint256 index) view returns (address urn)",
+  "function urnFarms(address urn) view returns (address farm)",
+  "function ilk() view returns (bytes32)",
+  "function vat() view returns (address)"
+]);
+var vatAbi = viem.parseAbi([
+  "function urns(bytes32 ilk, address urn) view returns (uint256 ink, uint256 art)",
+  "function ilks(bytes32 ilk) view returns (uint256 Art, uint256 rate, uint256 spot, uint256 line, uint256 dust)"
+]);
+function skyClient(rpcUrl) {
+  const rpc = rpcUrl.trim();
+  const ch = viem.defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  return viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
+}
+function skyUsdsDebtWeiFromUrnArt(art, rate) {
+  if (art === 0n || rate === 0n) return 0n;
+  return (art * rate + RAY - 1n) / RAY;
+}
+async function loadSkyLockstakePositions(args) {
+  const client = skyClient(args.rpcUrl);
+  const engine = viem.getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const ilk = await client.readContract({
+    address: engine,
+    abi: engineAbi2,
+    functionName: "ilk"
+  });
+  const vat = await client.readContract({
+    address: engine,
+    abi: engineAbi2,
+    functionName: "vat"
+  });
+  const count = await client.readContract({
+    address: engine,
+    abi: engineAbi2,
+    functionName: "ownerUrnsCount",
+    args: [args.owner]
+  });
+  const n = Number(count);
+  if (!Number.isFinite(n) || n <= 0) return [];
+  const ilkInfo = await client.readContract({
+    address: vat,
+    abi: vatAbi,
+    functionName: "ilks",
+    args: [ilk]
+  });
+  const rate = ilkInfo[1];
+  const rows = [];
+  for (let index = 0; index < n; index++) {
+    const urn = await client.readContract({
+      address: engine,
+      abi: engineAbi2,
+      functionName: "ownerUrns",
+      args: [args.owner, BigInt(index)]
+    });
+    if (!urn || urn === "0x0000000000000000000000000000000000000000") continue;
+    const u = await client.readContract({
+      address: vat,
+      abi: vatAbi,
+      functionName: "urns",
+      args: [ilk, urn]
+    });
+    const inkWei = u[0];
+    const art = u[1];
+    const debtUsdsWei = skyUsdsDebtWeiFromUrnArt(art, rate);
+    const farm = await client.readContract({
+      address: engine,
+      abi: engineAbi2,
+      functionName: "urnFarms",
+      args: [urn]
+    });
+    const skyHuman = Number(viem.formatUnits(inkWei, SKY_TOKEN_DECIMALS));
+    const debtHuman = Number(viem.formatUnits(debtUsdsWei, USDS_DECIMALS));
+    let borrowLimitUsdApprox = null;
+    if (args.skyUsd != null && Number.isFinite(args.skyUsd) && args.skyUsd > 0) {
+      const collateralUsd = skyHuman * args.skyUsd;
+      const maxDebtUsd = collateralUsd * SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR;
+      borrowLimitUsdApprox = Math.max(0, maxDebtUsd - debtHuman);
+    }
+    rows.push({
+      index,
+      urn,
+      inkWei,
+      art,
+      debtUsdsWei,
+      farm,
+      skyLocked: viem.formatUnits(inkWei, SKY_TOKEN_DECIMALS),
+      debtUsds: viem.formatUnits(debtUsdsWei, USDS_DECIMALS),
+      borrowLimitUsdApprox,
+      skyPriceUsd: args.skyUsd
+    });
+  }
+  return rows;
+}
+var farmRewardsTokenAbi = viem.parseAbi(["function rewardsToken() view returns (address)"]);
+async function readSkyLockstakeFarmRewardsToken(args) {
+  const client = skyClient(args.rpcUrl);
+  const farm = viem.getAddress(args.farm);
+  const zero = "0x0000000000000000000000000000000000000000";
+  if (farm.toLowerCase() === zero.toLowerCase()) {
+    throw new Error("Farm address is zero.");
+  }
+  const tok = await client.readContract({
+    address: farm,
+    abi: farmRewardsTokenAbi,
+    functionName: "rewardsToken"
+  });
+  return viem.getAddress(tok);
+}
+var vaultAbi = viem.parseAbi([
+  "function balanceOf(address account) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function previewRedeem(uint256 shares) view returns (uint256 assets)"
+]);
+async function readSusdsVaultShareBalanceWei(args) {
+  const rpc = args.rpcUrl.trim();
+  const ch = viem.defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const client = viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
+  const vault = viem.getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  return client.readContract({
+    address: vault,
+    abi: vaultAbi,
+    functionName: "balanceOf",
+    args: [args.owner]
+  });
+}
+async function readSusdsVaultDecimals(args) {
+  const rpc = args.rpcUrl.trim();
+  const ch = viem.defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const client = viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
+  const vault = viem.getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  const d = await client.readContract({
+    address: vault,
+    abi: vaultAbi,
+    functionName: "decimals"
+  });
+  return Number(d);
+}
+async function readSusdsPreviewRedeemAssetsWei(args) {
+  if (args.sharesWei <= 0n) return 0n;
+  const rpc = args.rpcUrl.trim();
+  const ch = viem.defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
   });
+  const client = viem.createPublicClient({ chain: ch, transport: viem.http(rpc) });
+  const vault = viem.getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  return client.readContract({
+    address: vault,
+    abi: vaultAbi,
+    functionName: "previewRedeem",
+    args: [args.sharesWei]
+  });
+}
+function formatSusdsSharesHuman(sharesWei, decimals) {
+  return viem.formatUnits(sharesWei, decimals);
+}
+
+// src/core/defiProxy.ts
+var coingeckoProxyUrl;
+function getCoingeckoProxyUrl() {
+  return coingeckoProxyUrl;
+}
+
+// src/protocols/evm/sky/usdPrice.ts
+async function fetchSkyUsdFromCoinGecko() {
+  try {
+    const addr = viem.getAddress(SKY_ETHEREUM_MAINNET).toLowerCase();
+    const url = "https://api.coingecko.com/api/v3/simple/token_price/ethereum?contract_addresses=" + encodeURIComponent(addr) + "&vs_currencies=usd";
+    const proxy = getCoingeckoProxyUrl();
+    const res = proxy ? await fetch(proxy, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ platform: "ethereum", contractAddress: addr })
+    }) : await fetch(url, { cache: "no-store" });
+    if (!res.ok) return null;
+    const raw = await res.json();
+    const row = raw[addr];
+    const n = row?.usd;
+    return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/protocols/evm/sky/loadLockstakeSupportedChainIds.ts
+function loadSkyLockstakeSupportedChainIds() {
+  return /* @__PURE__ */ new Set([1]);
 }
 
 // src/protocols/evm/sky/index.ts
@@ -1247,8 +1460,17 @@ exports.buildSkyLockstakeStakePositionBatch = buildSkyLockstakeStakePositionBatc
 exports.buildSkyLockstakeWipeBatch = buildSkyLockstakeWipeBatch;
 exports.buildSkySusdsDepositFromUsdsBatch = buildSkySusdsDepositFromUsdsBatch;
 exports.buildSkySusdsRedeemToUsdsBatch = buildSkySusdsRedeemToUsdsBatch;
+exports.fetchSkyUsdFromCoinGecko = fetchSkyUsdFromCoinGecko;
+exports.formatSusdsSharesHuman = formatSusdsSharesHuman;
 exports.isSkyLockstakeIsolationEstimateGasFragileBatchStep = isSkyLockstakeIsolationEstimateGasFragileBatchStep;
+exports.loadSkyLockstakePositions = loadSkyLockstakePositions;
+exports.loadSkyLockstakeSupportedChainIds = loadSkyLockstakeSupportedChainIds;
+exports.readSkyLockstakeFarmRewardsToken = readSkyLockstakeFarmRewardsToken;
+exports.readSusdsPreviewRedeemAssetsWei = readSusdsPreviewRedeemAssetsWei;
+exports.readSusdsVaultDecimals = readSusdsVaultDecimals;
+exports.readSusdsVaultShareBalanceWei = readSusdsVaultShareBalanceWei;
 exports.resolveSkyLockstakeBatchStepGasFromSignRequest = resolveSkyLockstakeBatchStepGasFromSignRequest;
 exports.skyProtocolModule = skyProtocolModule;
+exports.skyUsdsDebtWeiFromUrnArt = skyUsdsDebtWeiFromUrnArt;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map