@continuumdao/ctm-mpc-defi 0.1.4 → 0.2.0

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

@@ -0,0 +1,1229 @@
+import { parseAbi, parseGwei, serializeTransaction, keccak256, defineChain, createPublicClient, http, getAddress, parseUnits, encodeFunctionData, decodeFunctionData, formatUnits } from 'viem';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// src/protocols/evm/sky/mainnet.ts
+var SKY_ETHEREUM_MAINNET = "0x56072C95FAA701256059aa122697B133aDEd9279";
+var SKY_ETHEREUM_MAINNET_CHAIN_ID = 1;
+var USDS_ETHEREUM_MAINNET = "0xdC035D45d973E3EC169d2276DDab16f1e407384F";
+var SUSDS_VAULT_ERC4626_MAINNET = "0xa3931d71877C0E7a3148CB7Eb4463524FEc27fbD";
+var SKY_LOCKSTAKE_ENGINE_MAINNET = "0xCe01C90dE7FD1bcFa39e237FE6D8D9F569e8A6a3";
+var SKY_LS_SKY_ERC20_MAINNET = "0xf9A9cfD3229E985B91F99Bc866d42938044FFa1C";
+var SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET = "0xB44C2Fb4181D7Cb06bdFf34A46FdFe4a259B40Fc";
+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 = defineChain({
+    id: chainIdNum,
+    name: "Discovery",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [url] } }
+  });
+  const publicClient = createPublicClient({
+    chain,
+    transport: http(url)
+  });
+  const getGasPriceGwei = async () => {
+    const gasPriceWei = await publicClient.getGasPrice();
+    return parseFloat(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(formatUnits(baseFeePerGas, 9));
+    let priorityFeeGwei;
+    try {
+      const priorityWei = await publicClient.estimateMaxPriorityFeePerGas();
+      priorityFeeGwei = parseFloat(formatUnits(priorityWei, 9));
+    } catch {
+    }
+    const gasPriceGwei = await getGasPriceGwei();
+    return {
+      isEip1559: true,
+      baseFeeGwei,
+      priorityFeeGwei,
+      gasPriceGwei
+    };
+  } catch {
+    try {
+      const gasPriceWei = await publicClient.getGasPrice();
+      const gasPriceGwei = parseFloat(formatUnits(gasPriceWei, 9));
+      return { isEip1559: false, gasPriceGwei };
+    } catch {
+      return { isEip1559: false };
+    }
+  }
+}
+function finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, floor, baseWei) {
+  let maxP = maxPriorityFeePerGas;
+  let maxF = maxFeePerGas;
+  if (baseWei > 0n && maxF < baseWei + maxP) {
+    maxF = baseWei + maxP + parseGwei("0.001");
+  }
+  if (maxF < maxP) {
+    maxF = baseWei > 0n ? baseWei + maxP + parseGwei("0.001") : maxP * 2n;
+  }
+  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;
+  }
+  const cfg = BigInt(Math.floor(chainGasLimit));
+  return cfg > estimatedGas ? cfg : estimatedGas;
+}
+
+// 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();
+  }
+  return null;
+}
+
+// src/protocols/evm/sky/lockstakeMultisign.ts
+var SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS = 5000000n;
+var erc20AllowanceAbi = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var erc20ApproveAbi = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var engineAbi = 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 = 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];
+    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;
+    }
+    const gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    if (legacy) {
+      let gasPriceWei = await args.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 = parseGwei(gweiToDecimalString(Number(args.chainDetail.gasPrice)));
+        if (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      const ser = serializeTransaction({
+        type: "legacy",
+        to: s.to,
+        data: s.data,
+        value: s.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId: args.chainId
+      });
+      const h = keccak256(ser);
+      messageHashes.push(h.startsWith("0x") ? h.slice(2) : h);
+      messageRawBatch.push(ser);
+      proposalTxParamsBatch.push({
+        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;
+      }
+    } 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 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 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
+      ));
+      const ser = serializeTransaction({
+        type: "eip1559",
+        to: s.to,
+        data: s.data,
+        value: s.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId: args.chainId
+      });
+      const h = keccak256(ser);
+      messageHashes.push(h.startsWith("0x") ? h.slice(2) : h);
+      messageRawBatch.push(ser);
+      proposalTxParamsBatch.push({
+        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;
+      }
+    }
+  }
+  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 = JSON.stringify(extraPayload);
+  const firstSigText = batchMeta[0].signatureText;
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: firstDataNo0x,
+    messageHashes,
+    messageRawBatch,
+    destinationChainID: args.destinationChainID,
+    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) };
+}
+async function buildSkyLockstakeStakePositionBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const sky = getAddress(SKY_ETHEREUM_MAINNET);
+  const engine = getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const farm = getAddress(args.farm ?? SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET);
+  const ref = Number(args.farmRef ?? SKY_LOCKSTAKE_DEFAULT_FARM_REF);
+  if (!Number.isFinite(ref) || ref < 0 || ref > 65535) throw new Error("Invalid farm ref.");
+  const dec = await publicClient.readContract({
+    address: sky,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const amountWei = parseUnits(args.amountHuman, Number(dec));
+  if (amountWei === 0n) throw new Error("Amount is zero.");
+  const urnCount = await publicClient.readContract({
+    address: engine,
+    abi: engineAbi,
+    functionName: "ownerUrnsCount",
+    args: [executor]
+  });
+  let effectiveExistingUrnIndex = args.existingUrnIndex;
+  if (effectiveExistingUrnIndex === void 0 && urnCount > 0n) {
+    effectiveExistingUrnIndex = 0n;
+  }
+  const isAddCollateral = effectiveExistingUrnIndex !== void 0;
+  const index = isAddCollateral ? effectiveExistingUrnIndex : urnCount;
+  let addCollateralUrn = null;
+  if (isAddCollateral) {
+    if (index < 0n || index >= urnCount) {
+      throw new Error("Sky LockStake: urn index out of range for this key (use Staking tab if you have no position yet).");
+    }
+    const urnAddr = await publicClient.readContract({
+      address: engine,
+      abi: engineAbi,
+      functionName: "ownerUrns",
+      args: [executor, index]
+    });
+    if (!urnAddr || getAddress(urnAddr) === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Sky LockStake: that urn does not exist on-chain.");
+    }
+    addCollateralUrn = getAddress(urnAddr);
+  }
+  const lsSky = getAddress(SKY_LS_SKY_ERC20_MAINNET);
+  const farmStatus = await publicClient.readContract({
+    address: engine,
+    abi: engineAbi,
+    functionName: "farms",
+    args: [farm]
+  });
+  if (Number(farmStatus) !== 1) {
+    throw new Error(
+      `Sky LockStake: farm ${farm} is not ACTIVE in the engine (on-chain status ${farmStatus}). Choose another farm or wait for governance.`
+    );
+  }
+  let farmStakeToken;
+  try {
+    farmStakeToken = getAddress(
+      await publicClient.readContract({
+        address: farm,
+        abi: stakingRewardsFarmReadAbi,
+        functionName: "stakingToken"
+      })
+    );
+  } catch {
+    throw new Error(`Sky LockStake: could not read stakingToken() from farm ${farm}.`);
+  }
+  const farmAcceptsLsSky = farmStakeToken.toLowerCase() === lsSky.toLowerCase();
+  const skipSelectFarm = !farmAcceptsLsSky;
+  const openCall = encodeFunctionData({
+    abi: engineAbi,
+    functionName: "open",
+    args: [index]
+  });
+  const selectFarmCall = encodeFunctionData({
+    abi: engineAbi,
+    functionName: "selectFarm",
+    args: [executor, index, farm, ref]
+  });
+  const lockSkyCall = encodeFunctionData({
+    abi: engineAbi,
+    functionName: "lockSky",
+    args: [executor, index, amountWei, ref]
+  });
+  let innerCalls;
+  let innerLabels;
+  if (!isAddCollateral) {
+    innerCalls = skipSelectFarm ? [openCall, lockSkyCall] : [openCall, selectFarmCall, lockSkyCall];
+    innerLabels = skipSelectFarm ? ["open(index)", "lockSky"] : ["open(index)", "selectFarm", "lockSky"];
+  } else {
+    const currentFarm = await publicClient.readContract({
+      address: engine,
+      abi: engineAbi,
+      functionName: "urnFarms",
+      args: [addCollateralUrn]
+    });
+    const targetFarm = getAddress(farm);
+    const currentNorm = getAddress(currentFarm);
+    const sameFarmAsTarget = currentNorm.toLowerCase() === targetFarm.toLowerCase();
+    if (skipSelectFarm || sameFarmAsTarget) {
+      innerCalls = [lockSkyCall];
+      innerLabels = ["lockSky"];
+    } else {
+      innerCalls = [selectFarmCall, lockSkyCall];
+      innerLabels = ["selectFarm", "lockSky"];
+    }
+  }
+  const last = innerCalls[innerCalls.length - 1];
+  const lockDecoded = decodeFunctionData({ abi: engineAbi, data: last });
+  if (lockDecoded.functionName !== "lockSky" || lockDecoded.args[2] !== amountWei || lockDecoded.args[3] !== ref) {
+    throw new Error("Sky LockStake: internal multicall encoding mismatch (lockSky tail); consult support.");
+  }
+  for (let i = 0; i < innerCalls.length - 1; i++) {
+    const d = decodeFunctionData({ abi: engineAbi, data: innerCalls[i] });
+    if (d.functionName === "open" && d.args[0] !== index) {
+      throw new Error("Sky LockStake: internal multicall encoding mismatch (open index); consult support.");
+    }
+    if (d.functionName === "selectFarm") {
+      if (d.args[3] !== ref || d.args[2] !== getAddress(farm) || d.args[1] !== index || d.args[0] !== executor) {
+        throw new Error("Sky LockStake: internal multicall encoding mismatch (selectFarm); consult support.");
+      }
+    }
+  }
+  const multicallData = encodeFunctionData({
+    abi: engineAbi,
+    functionName: "multicall",
+    args: [innerCalls]
+  });
+  const steps = [];
+  const currentAllowance = await publicClient.readContract({
+    address: sky,
+    abi: erc20AllowanceAbi,
+    functionName: "allowance",
+    args: [executor, engine]
+  });
+  if (currentAllowance < amountWei) {
+    if (currentAllowance > 0n) {
+      steps.push({
+        to: sky,
+        data: encodeFunctionData({
+          abi: erc20ApproveAbi,
+          functionName: "approve",
+          args: [engine, 0n]
+        }),
+        value: 0n,
+        meta: {
+          destinationAddress: sky,
+          signatureText: JSON.stringify({
+            kind: "Sky",
+            name: "ERC20.approve",
+            function: "approve(address,uint256)",
+            spender: engine,
+            note: "Reset SKY allowance before new approval."
+          }),
+          evm: { type: "sky_lockstake_erc20_approve", version: 1, chainId: "1" },
+          sky: { step: "approve_sky_reset", engine }
+        }
+      });
+    }
+    steps.push({
+      to: sky,
+      data: encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [engine, amountWei]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: sky,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "ERC20.approve",
+          function: "approve(address,uint256)",
+          spender: engine,
+          amountWei: amountWei.toString(),
+          amountHuman: args.amountHuman,
+          decimals: Number(dec)
+        }),
+        evm: { type: "sky_lockstake_erc20_approve", version: 1, chainId: "1" },
+        sky: { step: "approve_sky", engine }
+      }
+    });
+  }
+  steps.push({
+    to: engine,
+    data: multicallData,
+    value: 0n,
+    meta: {
+      destinationAddress: engine,
+      signatureText: JSON.stringify({
+        kind: "Sky",
+        name: "LockstakeEngine.multicall",
+        inner: innerLabels,
+        index: index.toString(),
+        farm,
+        ref,
+        amountWei: amountWei.toString(),
+        amountHuman: args.amountHuman,
+        borrowOnlySkippedRewardsFarm: skipSelectFarm,
+        farmStakingToken: farmStakeToken,
+        expectedEngineFarmStakingToken: lsSky,
+        addCollateralToExistingUrn: isAddCollateral
+      }),
+      evm: { type: "sky_lockstake_engine_multicall_stake", version: 1, chainId: "1" },
+      sky: {
+        step: isAddCollateral ? innerLabels.join("_") : skipSelectFarm ? "open_lockSky_borrow_only" : "open_selectFarm_lockSky",
+        engine,
+        farm,
+        skipSelectFarm,
+        addCollateral: isAddCollateral
+      }
+    }
+  });
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const borrowNote = skipSelectFarm ? "No rewards farm in this batch: default farm stakingToken does not match lsSKY, so we only open + lockSky (SKY collateral) for borrow (you can select a compatible farm later from the protocol UI when one is ACTIVE)." : "";
+    if (isAddCollateral) {
+      const core = steps.length > 1 ? `Sky LockStake: ${steps.length}-tx batch \u2014 approve SKY, then multicall ${innerLabels.join(" + ")} on urn index ${index.toString()}.` : `Sky LockStake: multicall ${innerLabels.join(" + ")} on urn index ${index.toString()} (allowance already set).`;
+      return (t ? `${t}
+
+` : "") + core;
+    }
+    const suffixCore = skipSelectFarm ? steps.length > 1 ? `Sky LockStake: ${steps.length}-tx batch \u2014 approve SKY, then multicall open + lockSky (${borrowNote})` : `Sky LockStake: multicall open + lockSky (${borrowNote})` : steps.length > 1 ? `Sky LockStake: ${steps.length}-tx batch \u2014 approve SKY, then open + farm + lockSky on Ethereum.` : `Sky LockStake: multicall open + farm + lockSky on Ethereum (allowance already set).`;
+    return (t ? `${t}
+
+` : "") + suffixCore;
+  })();
+  return appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+}
+async function buildSkyLockstakeDrawBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const engine = getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const usds = getAddress(USDS_ETHEREUM_MAINNET);
+  const dec = await publicClient.readContract({
+    address: usds,
+    abi: erc20AllowanceAbi,
+    functionName: "decimals"
+  });
+  const wad = parseUnits(args.amountHuman, Number(dec));
+  if (wad === 0n) throw new Error("Borrow amount is zero.");
+  const to = getAddress(args.to ?? executor);
+  const data = encodeFunctionData({
+    abi: engineAbi,
+    functionName: "draw",
+    args: [executor, args.urnIndex, to, wad]
+  });
+  const steps = [
+    {
+      to: engine,
+      data,
+      value: 0n,
+      meta: {
+        destinationAddress: engine,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "LockstakeEngine.draw",
+          function: "draw(address owner,uint256 index,address to,uint256 wad)",
+          urnIndex: args.urnIndex.toString(),
+          to,
+          amountWei: wad.toString(),
+          amountHuman: args.amountHuman
+        }),
+        evm: { type: "sky_lockstake_draw", version: 1, chainId: "1" },
+        sky: { step: "draw", engine }
+      }
+    }
+  ];
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const suffix = "Sky LockStake: borrow USDS against staked SKY (draw).";
+    return (t ? `${t}
+
+` : "") + suffix;
+  })();
+  return appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+}
+async function buildSkyLockstakeGetRewardBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const engine = getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const farm = getAddress(args.farmAddress);
+  const zero = "0x0000000000000000000000000000000000000000";
+  if (farm.toLowerCase() === zero.toLowerCase()) {
+    throw new Error(
+      "Sky LockStake: this urn has no rewards farm selected \u2014 stake SKY with a farm first, then rewards accrue there."
+    );
+  }
+  let rewardToken;
+  try {
+    rewardToken = getAddress(
+      await publicClient.readContract({
+        address: farm,
+        abi: stakingRewardsFarmReadAbi,
+        functionName: "rewardsToken"
+      })
+    );
+  } catch {
+    throw new Error(`Sky LockStake: could not read rewardsToken() from farm ${farm}.`);
+  }
+  const to = getAddress(args.rewardRecipient ?? executor);
+  const data = encodeFunctionData({
+    abi: engineAbi,
+    functionName: "getReward",
+    args: [executor, args.urnIndex, farm, to]
+  });
+  const steps = [
+    {
+      to: engine,
+      data,
+      value: 0n,
+      meta: {
+        destinationAddress: engine,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "LockstakeEngine.getReward",
+          function: "getReward(address owner,uint256 index,address farm,address to)",
+          urnIndex: args.urnIndex.toString(),
+          farm,
+          rewardRecipient: to,
+          farmRewardsToken: rewardToken
+        }),
+        evm: { type: "sky_lockstake_get_reward", version: 1, chainId: "1" },
+        sky: { step: "get_reward", engine, farm, rewardToken }
+      }
+    }
+  ];
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const suffix = "Sky LockStake: claim staking rewards from the selected farm (getReward \u2192 ERC-20 sent to rewardRecipient).";
+    return (t ? `${t}
+
+` : "") + suffix;
+  })();
+  const built = await appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+  return { ...built, rewardToken };
+}
+async function buildSkyLockstakeWipeBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const engine = getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const usds = getAddress(USDS_ETHEREUM_MAINNET);
+  const steps = [];
+  if (!args.wipeAll) {
+    const ah = (args.amountHuman ?? "").trim();
+    if (!ah) throw new Error("Repay amount required.");
+    const dec = await publicClient.readContract({
+      address: usds,
+      abi: erc20AllowanceAbi,
+      functionName: "decimals"
+    });
+    const repayWei = parseUnits(ah, Number(dec));
+    if (repayWei === 0n) throw new Error("Repay amount is zero.");
+    const currentAllowance = await publicClient.readContract({
+      address: usds,
+      abi: erc20AllowanceAbi,
+      functionName: "allowance",
+      args: [executor, engine]
+    });
+    if (currentAllowance < repayWei) {
+      if (currentAllowance > 0n) {
+        steps.push({
+          to: usds,
+          data: encodeFunctionData({
+            abi: erc20ApproveAbi,
+            functionName: "approve",
+            args: [engine, 0n]
+          }),
+          value: 0n,
+          meta: {
+            destinationAddress: usds,
+            signatureText: JSON.stringify({
+              kind: "Sky",
+              name: "ERC20.approve USDS reset",
+              spender: engine
+            }),
+            evm: { type: "sky_lockstake_usds_approve", version: 1, chainId: "1" },
+            sky: { step: "approve_usds_reset", engine }
+          }
+        });
+      }
+      steps.push({
+        to: usds,
+        data: encodeFunctionData({
+          abi: erc20ApproveAbi,
+          functionName: "approve",
+          args: [engine, repayWei]
+        }),
+        value: 0n,
+        meta: {
+          destinationAddress: usds,
+          signatureText: JSON.stringify({
+            kind: "Sky",
+            name: "ERC20.approve USDS",
+            spender: engine,
+            amountWei: repayWei.toString()
+          }),
+          evm: { type: "sky_lockstake_usds_approve", version: 1, chainId: "1" },
+          sky: { step: "approve_usds", engine }
+        }
+      });
+    }
+    steps.push({
+      to: engine,
+      data: encodeFunctionData({
+        abi: engineAbi,
+        functionName: "wipe",
+        args: [executor, args.urnIndex, repayWei]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: engine,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "LockstakeEngine.wipe",
+          urnIndex: args.urnIndex.toString(),
+          amountWei: repayWei.toString()
+        }),
+        evm: { type: "sky_lockstake_wipe", version: 1, chainId: "1" },
+        sky: { step: "wipe", engine }
+      }
+    });
+  } else {
+    const maxApproval = 2n ** 256n - 1n;
+    steps.push({
+      to: usds,
+      data: encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [engine, maxApproval]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: usds,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "ERC20.approve USDS (max)",
+          spender: engine,
+          note: "Allows wipeAll to pull the exact burn amount computed on-chain."
+        }),
+        evm: { type: "sky_lockstake_usds_approve", version: 1, chainId: "1" },
+        sky: { step: "approve_usds_max", engine }
+      }
+    });
+    steps.push({
+      to: engine,
+      data: encodeFunctionData({
+        abi: engineAbi,
+        functionName: "wipeAll",
+        args: [executor, args.urnIndex]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: engine,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "LockstakeEngine.wipeAll",
+          urnIndex: args.urnIndex.toString()
+        }),
+        evm: { type: "sky_lockstake_wipe_all", version: 1, chainId: "1" },
+        sky: { step: "wipeAll", engine }
+      }
+    });
+  }
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const suffix = args.wipeAll ? `Sky LockStake: repay all USDS debt (wipeAll).` : `Sky LockStake: repay USDS (wipe).`;
+    return (t ? `${t}
+
+` : "") + suffix;
+  })();
+  return appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+}
+async function buildSkyLockstakeCloseBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky LockStake is only supported on Ethereum mainnet (chain id 1).");
+  if (args.inkWei === 0n) throw new Error("Nothing to free.");
+  const rpc = args.rpcUrl.trim();
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const engine = getAddress(SKY_LOCKSTAKE_ENGINE_MAINNET);
+  const usds = getAddress(USDS_ETHEREUM_MAINNET);
+  const toSky = getAddress(args.skyRecipient ?? executor);
+  const maxApproval = 2n ** 256n - 1n;
+  const steps = [
+    {
+      to: usds,
+      data: encodeFunctionData({
+        abi: erc20ApproveAbi,
+        functionName: "approve",
+        args: [engine, maxApproval]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: usds,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "ERC20.approve USDS (max)",
+          spender: engine,
+          note: "Close position: wipeAll then free SKY."
+        }),
+        evm: { type: "sky_lockstake_usds_approve", version: 1, chainId: "1" },
+        sky: { step: "approve_usds_max", engine }
+      }
+    },
+    {
+      to: engine,
+      data: encodeFunctionData({
+        abi: engineAbi,
+        functionName: "wipeAll",
+        args: [executor, args.urnIndex]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: engine,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "LockstakeEngine.wipeAll",
+          urnIndex: args.urnIndex.toString()
+        }),
+        evm: { type: "sky_lockstake_wipe_all", version: 1, chainId: "1" },
+        sky: { step: "wipeAll", engine }
+      }
+    },
+    {
+      to: engine,
+      data: encodeFunctionData({
+        abi: engineAbi,
+        functionName: "freeSky",
+        args: [executor, args.urnIndex, toSky, args.inkWei]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: engine,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "LockstakeEngine.freeSky",
+          urnIndex: args.urnIndex.toString(),
+          to: toSky,
+          inkWei: args.inkWei.toString(),
+          note: "Exit fee may reduce SKY received."
+        }),
+        evm: { type: "sky_lockstake_free_sky", version: 1, chainId: "1" },
+        sky: { step: "freeSky", engine }
+      }
+    }
+  ];
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const suffix = "Sky LockStake: close position \u2014 wipeAll debt, free SKY collateral.";
+    return (t ? `${t}
+
+` : "") + suffix;
+  })();
+  return appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+}
+var SKY_FRAGILE_ETH_ESTIMATE_GAS_BATCH_EVMS = /* @__PURE__ */ new Set([
+  "sky_lockstake_engine_multicall_stake",
+  "sky_lockstake_wipe",
+  "sky_lockstake_wipe_all",
+  "sky_susds_deposit"
+]);
+function parseSkyExtraJsonObject(detail) {
+  if (!detail) return null;
+  const raw = detail.ExtraJSON ?? detail.extraJSON;
+  if (raw == null) return null;
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      const p = JSON.parse(raw);
+      if (p && typeof p === "object" && !Array.isArray(p)) return p;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function parseOptionalSkyGasLimitString(raw) {
+  if (raw == null) return null;
+  const s = String(raw).trim();
+  if (!s) return null;
+  try {
+    if (/^0x[0-9a-fA-F]+$/.test(s)) return BigInt(s);
+    return BigInt(s);
+  } catch {
+    return null;
+  }
+}
+function isSkyLockstakeIsolationEstimateGasFragileBatchStep(detail, batchIndex) {
+  if (batchIndex < 0) return false;
+  const ex = parseSkyExtraJsonObject(detail);
+  const bm = ex?.batchMeta;
+  if (!Array.isArray(bm) || !bm[batchIndex] || typeof bm[batchIndex] !== "object" || Array.isArray(bm[batchIndex])) {
+    return false;
+  }
+  const evm = bm[batchIndex].evm;
+  return SKY_FRAGILE_ETH_ESTIMATE_GAS_BATCH_EVMS.has(String(evm?.type ?? ""));
+}
+function resolveSkyLockstakeBatchStepGasFromSignRequest(detail, batchIndex) {
+  if (!detail || batchIndex < 0) return null;
+  const propBatch = detail.proposal_tx_params ?? detail.proposalTxParams ?? detail.ProposalTxParams;
+  if (!Array.isArray(propBatch) || propBatch.length <= batchIndex) return null;
+  const row = propBatch[batchIndex];
+  if (!row || typeof row !== "object" || Array.isArray(row)) return null;
+  return parseOptionalSkyGasLimitString(row.gasLimit);
+}
+var erc20AllowanceAbi2 = parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)"
+]);
+var erc20ApproveAbi2 = parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+var susdsVaultAbi = parseAbi([
+  "function asset() view returns (address)",
+  "function decimals() view returns (uint8)",
+  "function deposit(uint256 assets, address receiver) returns (uint256 shares)",
+  "function redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)"
+]);
+async function buildSkySusdsRedeemToUsdsBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky sUSDS redeem is only supported on Ethereum mainnet (chain id 1).");
+  const rpc = args.rpcUrl.trim();
+  const vault = getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  const usdsCanonical = getAddress(USDS_ETHEREUM_MAINNET);
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const receiver = getAddress(args.receiver ?? executor);
+  const underlying = await publicClient.readContract({
+    address: vault,
+    abi: susdsVaultAbi,
+    functionName: "asset"
+  });
+  if (getAddress(underlying).toLowerCase() !== usdsCanonical.toLowerCase()) {
+    throw new Error("sUSDS vault underlying does not match canonical USDS on Ethereum.");
+  }
+  const dec = await publicClient.readContract({
+    address: vault,
+    abi: susdsVaultAbi,
+    functionName: "decimals"
+  });
+  const sharesWei = parseUnits(args.sharesHuman, Number(dec));
+  if (sharesWei === 0n) throw new Error("Redeem amount is zero.");
+  const data = encodeFunctionData({
+    abi: susdsVaultAbi,
+    functionName: "redeem",
+    args: [sharesWei, receiver, executor]
+  });
+  const steps = [
+    {
+      to: vault,
+      data,
+      value: 0n,
+      meta: {
+        destinationAddress: vault,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "sUSDS (ERC-4626).redeem",
+          function: "redeem(uint256 shares, address receiver, address owner)",
+          sharesWei: sharesWei.toString(),
+          sharesHuman: args.sharesHuman,
+          receiver,
+          owner: executor,
+          vault,
+          underlying: usdsCanonical
+        }),
+        evm: { type: "sky_susds_redeem", version: 1, chainId: "1" },
+        sky: { step: "susds_redeem", vault }
+      }
+    }
+  ];
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const suffix = "Sky sUSDS: redeem Savings USDS shares to USDS via ERC-4626 redeem (1 tx).";
+    return (t ? `${t}
+
+` : "") + suffix;
+  })();
+  return appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+}
+async function buildSkySusdsDepositFromUsdsBatch(args) {
+  if (args.chainId !== 1) throw new Error("Sky sUSDS deposit is only supported on Ethereum mainnet (chain id 1).");
+  const rpc = args.rpcUrl.trim();
+  const vault = getAddress(SUSDS_VAULT_ERC4626_MAINNET);
+  const usdsCanonical = getAddress(USDS_ETHEREUM_MAINNET);
+  const ch = defineChain({
+    id: 1,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpc] } }
+  });
+  const publicClient = createPublicClient({ chain: ch, transport: http(rpc) });
+  const executor = getAddress(args.executorAddress);
+  const underlying = await publicClient.readContract({
+    address: vault,
+    abi: susdsVaultAbi,
+    functionName: "asset"
+  });
+  if (getAddress(underlying).toLowerCase() !== usdsCanonical.toLowerCase()) {
+    throw new Error("sUSDS vault underlying does not match canonical USDS on Ethereum.");
+  }
+  const dec = await publicClient.readContract({
+    address: usdsCanonical,
+    abi: erc20AllowanceAbi2,
+    functionName: "decimals"
+  });
+  const assetsWei = parseUnits(args.assetsHuman.trim(), Number(dec));
+  if (assetsWei === 0n) throw new Error("Deposit amount is zero.");
+  const steps = [];
+  const currentAllowance = await publicClient.readContract({
+    address: usdsCanonical,
+    abi: erc20AllowanceAbi2,
+    functionName: "allowance",
+    args: [executor, vault]
+  });
+  if (currentAllowance < assetsWei) {
+    if (currentAllowance > 0n) {
+      steps.push({
+        to: usdsCanonical,
+        data: encodeFunctionData({
+          abi: erc20ApproveAbi2,
+          functionName: "approve",
+          args: [vault, 0n]
+        }),
+        value: 0n,
+        meta: {
+          destinationAddress: usdsCanonical,
+          signatureText: JSON.stringify({
+            kind: "Sky",
+            name: "ERC20.approve USDS reset",
+            spender: vault
+          }),
+          evm: { type: "sky_susds_usds_approve", version: 1, chainId: "1" },
+          sky: { step: "approve_usds_reset_susds_vault", vault }
+        }
+      });
+    }
+    steps.push({
+      to: usdsCanonical,
+      data: encodeFunctionData({
+        abi: erc20ApproveAbi2,
+        functionName: "approve",
+        args: [vault, assetsWei]
+      }),
+      value: 0n,
+      meta: {
+        destinationAddress: usdsCanonical,
+        signatureText: JSON.stringify({
+          kind: "Sky",
+          name: "ERC20.approve USDS",
+          spender: vault,
+          amountWei: assetsWei.toString()
+        }),
+        evm: { type: "sky_susds_usds_approve", version: 1, chainId: "1" },
+        sky: { step: "approve_usds_susds_vault", vault }
+      }
+    });
+  }
+  const depositData = encodeFunctionData({
+    abi: susdsVaultAbi,
+    functionName: "deposit",
+    args: [assetsWei, executor]
+  });
+  steps.push({
+    to: vault,
+    data: depositData,
+    value: 0n,
+    meta: {
+      destinationAddress: vault,
+      signatureText: JSON.stringify({
+        kind: "Sky",
+        name: "sUSDS (ERC-4626).deposit",
+        function: "deposit(uint256 assets, address receiver)",
+        assetsWei: assetsWei.toString(),
+        assetsHuman: args.assetsHuman.trim(),
+        receiver: executor,
+        vault,
+        underlying: usdsCanonical
+      }),
+      evm: { type: "sky_susds_deposit", version: 1, chainId: "1" },
+      sky: { step: "susds_deposit", vault }
+    }
+  });
+  const purposePrefix = (() => {
+    const t = args.purposeText.trim();
+    const suffix = "Sky sUSDS: deposit USDS into Savings vault (ERC-4626 deposit \u2192 mint shares).";
+    return (t ? `${t}
+
+` : "") + suffix;
+  })();
+  return appendSerializedSkyBatch({
+    steps,
+    publicClient,
+    executor,
+    chainId: 1,
+    rpcUrl: rpc,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposePrefix,
+    keyGen: args.keyGen,
+    destinationChainID: "1"
+  });
+}
+
+// src/protocols/evm/sky/index.ts
+var SKY_PROTOCOL_ID = "sky";
+var skyProtocolModule = {
+  id: SKY_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return Number(ctx.chainId) === SKY_ETHEREUM_MAINNET_CHAIN_ID;
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "erc20";
+  },
+  actions: [
+    { id: "sky.lockstake-stake", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Open Lockstake position", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.lockstake-draw", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Borrow USDS from Lockstake", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.lockstake-wipe", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Repay Lockstake debt", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.lockstake-close", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Close Lockstake position", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.susds-deposit", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Deposit USDS into sUSDS vault", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "sky.susds-redeem", protocolId: SKY_PROTOCOL_ID, chainCategory: "evm", description: "Redeem sUSDS to USDS", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(skyProtocolModule);
+
+export { SKY_ETHEREUM_MAINNET, SKY_ETHEREUM_MAINNET_CHAIN_ID, SKY_LOCKSTAKE_DEFAULT_FARM_MAINNET, SKY_LOCKSTAKE_DEFAULT_FARM_REF, SKY_LOCKSTAKE_ENGINE_MAINNET, SKY_LOCKSTAKE_MULTICALL_FALLBACK_GAS, SKY_LOCKSTAKE_UI_COLLATERAL_FACTOR, SKY_LS_SKY_ERC20_MAINNET, SKY_PROTOCOL_ID, SKY_TOKEN_DECIMALS, SUSDS_VAULT_ERC4626_MAINNET, USDS_DECIMALS, USDS_ETHEREUM_MAINNET, appendSerializedSkyBatch, buildSkyLockstakeCloseBatch, buildSkyLockstakeDrawBatch, buildSkyLockstakeGetRewardBatch, buildSkyLockstakeStakePositionBatch, buildSkyLockstakeWipeBatch, buildSkySusdsDepositFromUsdsBatch, buildSkySusdsRedeemToUsdsBatch, isSkyLockstakeIsolationEstimateGasFragileBatchStep, resolveSkyLockstakeBatchStepGasFromSignRequest, skyProtocolModule };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map