@continuumdao/ctm-mpc-defi 0.1.4 → 0.2.0

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

@@ -0,0 +1,834 @@
+'use strict';
+
+var viem = require('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);
+  }
+}
+var LIDO_STETH_CONTRACT_MAINNET = viem.getAddress(
+  "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
+);
+var LIDO_WSTETH_CONTRACT_MAINNET = viem.getAddress(
+  "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa"
+);
+var LIDO_WITHDRAWAL_QUEUE_MAINNET = viem.getAddress("0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1");
+var LIDO_ETHEREUM_MAINNET_CHAIN_ID = 1;
+var LIDO_SUBMIT_REFERRAL_MAINNET = viem.zeroAddress;
+function isEthereumMainnetChainId(chainIdStr) {
+  return String(chainIdStr ?? "").trim() === String(LIDO_ETHEREUM_MAINNET_CHAIN_ID);
+}
+
+// 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/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;
+}
+async function fetchChainFeeParams(rpcUrl, chainId) {
+  const url = rpcUrl.trim();
+  if (!url) return { isEip1559: false };
+  const chainIdNum = 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 };
+    }
+  }
+}
+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");
+  }
+  if (maxF < maxP) {
+    maxF = baseWei > 0n ? baseWei + maxP + viem.parseGwei("0.001") : maxP * 2n;
+  }
+  return { maxFeePerGas: maxF, maxPriorityFeePerGas: maxP };
+}
+function alignEip1559FeesWithLatestBase(maxFeePerGas, maxPriorityFeePerGas, latestBlockBaseFeeWei) {
+  return finalizeEip1559Fees(maxFeePerGas, maxPriorityFeePerGas, null, latestBlockBaseFeeWei);
+}
+
+// src/protocols/evm/lido/multisign.ts
+var LIDO_SUBMIT_FALLBACK_GAS_UNITS = 450000n;
+var LIDO_APPROVE_FALLBACK = 110000n;
+var LIDO_REQUEST_WITHDRAWALS_FALLBACK_GAS_UNITS = 1350000n;
+var LIDO_CLAIM_WITHDRAWAL_FALLBACK_GAS_UNITS = 900000n;
+var LIDO_WSTETH_WRAP_FALLBACK_GAS_UNITS = 520000n;
+var LIDO_WSTETH_UNWRAP_FALLBACK_GAS_UNITS = 600000n;
+var MIN_LIDO_EXECUTE_GAS = 260000n;
+var erc20Abi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function approve(address spender, uint256 amount) returns (bool)"
+]);
+var lidoAbi = viem.parseAbi([
+  "function submit(address referral) payable returns (uint256)",
+  "function getSharesByPooledEth(uint256 ethAmount) view returns (uint256)"
+]);
+var wqAbi = viem.parseAbi([
+  "function MIN_STETH_WITHDRAWAL_AMOUNT() view returns (uint256)",
+  "function MAX_STETH_WITHDRAWAL_AMOUNT() view returns (uint256)",
+  "function requestWithdrawals(uint256[] amounts, address owner) returns (uint256[] requestIds)",
+  "function claimWithdrawal(uint256 requestId)"
+]);
+var wstethAbi = viem.parseAbi([
+  "function wrap(uint256 stETHAmount) returns (uint256)",
+  "function unwrap(uint256 wstETHAmount) returns (uint256)"
+]);
+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;
+}
+function parseExtraJsonObject(detail) {
+  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 parseOptionalGasLimitString(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;
+  }
+}
+var LIDO_EVM_TYPES = /* @__PURE__ */ new Set([
+  "lido_submit",
+  "lido_steth_approve",
+  "lido_request_withdrawals",
+  "lido_claim_withdrawal",
+  "lido_wsteth_wrap",
+  "lido_wsteth_unwrap"
+]);
+function lidoRequestWithdrawalsBatchIndices(detail) {
+  const ex = parseExtraJsonObject(detail);
+  if (!ex) return [];
+  const bm = ex.batchMeta;
+  if (!Array.isArray(bm)) return [];
+  const out = [];
+  bm.forEach((entry, idx) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return;
+    const evm = entry.evm;
+    if (!evm || typeof evm !== "object" || Array.isArray(evm)) return;
+    const t = String(evm.type ?? "").trim();
+    if (t === "lido_request_withdrawals") out.push(idx);
+  });
+  return out;
+}
+function isLidoBatchStepEvmSignRequest(detail, batchIndex) {
+  const ex = parseExtraJsonObject(detail);
+  if (!ex) return false;
+  const idx = batchIndex >= 0 ? batchIndex : 0;
+  const bm = ex.batchMeta;
+  if (Array.isArray(bm) && bm[idx] && typeof bm[idx] === "object" && !Array.isArray(bm[idx])) {
+    const evm0 = bm[idx].evm;
+    if (evm0 && typeof evm0 === "object" && !Array.isArray(evm0)) {
+      const t = String(evm0.type ?? "");
+      if (LIDO_EVM_TYPES.has(t)) return true;
+    }
+  }
+  return false;
+}
+function resolveLidoBatchStepGasFromSignRequest(detail, batchIndex) {
+  if (!detail) return null;
+  const idx = batchIndex >= 0 ? batchIndex : 0;
+  const propBatch = detail.proposal_tx_params ?? detail.proposalTxParams ?? detail.ProposalTxParams;
+  if (Array.isArray(propBatch) && propBatch.length > idx) {
+    const row = propBatch[idx];
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      const r = row;
+      const gl = parseOptionalGasLimitString(
+        r.gas_limit ?? r.gasLimit ?? r.GasLimit
+      );
+      if (gl != null && gl > 0n) return gl;
+    }
+  }
+  const ex = parseExtraJsonObject(detail);
+  const bm = ex?.batchMeta;
+  if (Array.isArray(bm) && bm[idx] && typeof bm[idx] === "object" && !Array.isArray(bm[idx])) {
+    const l = bm[idx].lido;
+    const gs = l?.gasSubmit ?? l?.gasApprove ?? l?.gasRequestWithdrawals ?? l?.gasClaimWithdrawal ?? l?.gasWstethWrap ?? l?.gasWstethUnwrap;
+    const base = parseOptionalGasLimitString(gs?.baseGasUnits);
+    if (base != null && base > 0n) return base;
+  }
+  return null;
+}
+async function finalizeLidoMultipart(steps, 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 ch = viem.defineChain({
+    id: LIDO_ETHEREUM_MAINNET_CHAIN_ID,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl.trim()] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl.trim()) });
+  const feeParams = await fetchChainFeeParams(args.rpcUrl.trim(), LIDO_ETHEREUM_MAINNET_CHAIN_ID);
+  const legacy = Boolean(args.chainDetail?.legacy) || !feeParams.isEip1559;
+  const latestBaseFeeWei = !legacy ? (await 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 executor = viem.getAddress(args.executorAddress);
+  const baseNonce = await publicClient.getTransactionCount({ address: executor, blockTag: "pending" });
+  const messageHashes = [];
+  const messageRawBatch = [];
+  const proposalTxParamsBatch = [];
+  let firstTxFeePayload = {};
+  let firstDataNo0x = "";
+  const batchMeta = [];
+  for (let i = 0; i < steps.length; i++) {
+    const s = steps[i];
+    const v = viem.getAddress(s.to);
+    const data = s.data;
+    const currentNonce = baseNonce + i;
+    let estimatedGas;
+    try {
+      estimatedGas = await publicClient.estimateGas({
+        to: v,
+        data,
+        value: s.value,
+        account: executor
+      });
+    } catch {
+      estimatedGas = s.fallbackGas;
+    }
+    const gasLimitI = useCustomGas ? gasLimitFromEstimateAndChainConfig(estimatedGas, gasLimitConfig) : estimatedGas;
+    if (legacy) {
+      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 (configured > gasPriceWei) gasPriceWei = configured;
+      }
+      const ser = viem.serializeTransaction({
+        type: "legacy",
+        to: v,
+        data,
+        value: s.value,
+        gas: gasLimitI,
+        gasPrice: gasPriceWei,
+        nonce: currentNonce,
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      });
+      const h = viem.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 = data.startsWith("0x") ? data.slice(2) : 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 ? viem.parseGwei(gweiToDecimalString(effectivePriorityFeeGwei)) : viem.parseGwei("1");
+      let maxFeePerGas = viem.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 = viem.serializeTransaction({
+        type: "eip1559",
+        to: v,
+        data,
+        value: s.value,
+        gas: gasLimitI,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce: currentNonce,
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      });
+      const h = viem.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 = data.startsWith("0x") ? data.slice(2) : data;
+      }
+    }
+    batchMeta.push(s.buildBatchMeta({ gasLimit: gasLimitI }));
+  }
+  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 firstValue = steps[0].value;
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: firstDataNo0x,
+    messageHashes,
+    messageRawBatch,
+    destinationChainID: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID),
+    destinationAddress: steps[0].to,
+    extraJSON,
+    signatureText: firstSigText,
+    purpose: (() => {
+      const t = args.purposeText.trim();
+      const suffix = args.purposeSuffix.trim();
+      return (t ? `${t}
+
+` : "") + suffix;
+    })(),
+    ...firstTxFeePayload,
+    proposalTxParams: proposalTxParamsBatch
+  };
+  if (firstValue > 0n) {
+    bodyForSign.value = firstValue.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+async function buildEvmMultisignBodyLidoSubmit(args) {
+  if (args.chainId !== LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+    throw new Error("Lido stake is supported on Ethereum mainnet (chain id 1) only.");
+  }
+  const lido = LIDO_STETH_CONTRACT_MAINNET;
+  const amt = viem.parseUnits(args.ethAmountHuman, 18);
+  if (amt === 0n) throw new Error("ETH amount must be greater than zero.");
+  const referral = viem.getAddress(LIDO_SUBMIT_REFERRAL_MAINNET);
+  const data = viem.encodeFunctionData({
+    abi: lidoAbi,
+    functionName: "submit",
+    args: [referral]
+  });
+  const step = {
+    to: lido,
+    data,
+    value: amt,
+    fallbackGas: LIDO_SUBMIT_FALLBACK_GAS_UNITS,
+    buildBatchMeta: ({ gasLimit }) => ({
+      destinationAddress: lido,
+      signatureText: JSON.stringify({
+        kind: "Lido",
+        name: "Lido.submit",
+        referral,
+        valueWei: amt.toString(),
+        ethAmountHuman: args.ethAmountHuman,
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      }),
+      evm: { type: "lido_submit", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+      lido: { step: "submit", ethAmountHuman: args.ethAmountHuman, gasSubmit: { baseGasUnits: gasLimit.toString() } }
+    })
+  };
+  const purposeSuffix = `Lido: stake ${args.ethAmountHuman} ETH \u2192 stETH (submit) on Ethereum.`;
+  return finalizeLidoMultipart([step], {
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposeText: args.purposeText,
+    purposeSuffix,
+    executorAddress: args.executorAddress
+  });
+}
+async function buildEvmMultisignBodyLidoRequestWithdrawals(args) {
+  if (args.chainId !== LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+    throw new Error("Lido withdrawals are supported on Ethereum mainnet (chain id 1) only.");
+  }
+  const steth = LIDO_STETH_CONTRACT_MAINNET;
+  const wq = LIDO_WITHDRAWAL_QUEUE_MAINNET;
+  const ch = viem.defineChain({
+    id: LIDO_ETHEREUM_MAINNET_CHAIN_ID,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl.trim()] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl.trim()) });
+  const amountWei = viem.parseUnits(args.stEthAmountHuman, 18);
+  if (amountWei === 0n) throw new Error("stETH amount must be greater than zero.");
+  const minW = await publicClient.readContract({
+    address: wq,
+    abi: wqAbi,
+    functionName: "MIN_STETH_WITHDRAWAL_AMOUNT"
+  });
+  const maxW = await publicClient.readContract({
+    address: wq,
+    abi: wqAbi,
+    functionName: "MAX_STETH_WITHDRAWAL_AMOUNT"
+  });
+  if (amountWei < minW) {
+    throw new Error(
+      `Withdrawal amount is below the queue minimum (${minW.toString()} wei of stETH; check decimals / protocol constants).`
+    );
+  }
+  if (amountWei > maxW) {
+    throw new Error(
+      `This flow sends a single request; amount exceeds the queue maximum (${maxW.toString()} wei). Split across multiple requests.`
+    );
+  }
+  const executor = viem.getAddress(args.executorAddress);
+  const ownerAddr = viem.getAddress(args.owner);
+  const steps = [];
+  let approvalNeeded = false;
+  const allowance = await publicClient.readContract({
+    address: steth,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [executor, wq]
+  });
+  if (allowance < amountWei) {
+    approvalNeeded = true;
+    if (allowance > 0n) {
+      const dataReset = viem.encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [wq, 0n]
+      });
+      steps.push({
+        to: steth,
+        data: dataReset,
+        value: 0n,
+        fallbackGas: LIDO_APPROVE_FALLBACK,
+        buildBatchMeta: ({ gasLimit }) => ({
+          destinationAddress: steth,
+          signatureText: JSON.stringify({
+            kind: "Lido",
+            name: "stETH.approve (reset allowance before new amount)",
+            spender: wq,
+            chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+          }),
+          evm: { type: "lido_steth_approve", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+          lido: { step: "approve_reset", gasApprove: { baseGasUnits: gasLimit.toString() } }
+        })
+      });
+    }
+    const dataApprove = viem.encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [wq, amountWei]
+    });
+    steps.push({
+      to: steth,
+      data: dataApprove,
+      value: 0n,
+      fallbackGas: LIDO_APPROVE_FALLBACK,
+      buildBatchMeta: ({ gasLimit }) => ({
+        destinationAddress: steth,
+        signatureText: JSON.stringify({
+          kind: "Lido",
+          name: "stETH.approve",
+          spender: wq,
+          amountWei: amountWei.toString(),
+          chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+        }),
+        evm: { type: "lido_steth_approve", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+        lido: {
+          step: "approve_exact",
+          stEthAmountHuman: args.stEthAmountHuman,
+          gasApprove: { baseGasUnits: gasLimit.toString() }
+        }
+      })
+    });
+  }
+  const dataReq = viem.encodeFunctionData({
+    abi: wqAbi,
+    functionName: "requestWithdrawals",
+    args: [[amountWei], ownerAddr]
+  });
+  steps.push({
+    to: wq,
+    data: dataReq,
+    value: 0n,
+    fallbackGas: LIDO_REQUEST_WITHDRAWALS_FALLBACK_GAS_UNITS,
+    buildBatchMeta: ({ gasLimit }) => ({
+      destinationAddress: wq,
+      signatureText: JSON.stringify({
+        kind: "Lido",
+        name: "WithdrawalQueue.requestWithdrawals",
+        amountsWei: [amountWei.toString()],
+        owner: ownerAddr,
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      }),
+      evm: { type: "lido_request_withdrawals", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+      lido: {
+        step: "requestWithdrawals",
+        stEthAmountHuman: args.stEthAmountHuman,
+        owner: ownerAddr,
+        approvalNeeded,
+        gasRequestWithdrawals: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+  const purposeSuffix = `Lido: withdrawal queue \u2014 approve (if needed) + requestWithdrawals (${args.stEthAmountHuman} stETH) on Ethereum (claim ETH in a follow-up tx when finalized).`;
+  return finalizeLidoMultipart(steps, {
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposeText: args.purposeText,
+    purposeSuffix,
+    executorAddress: executor
+  });
+}
+async function buildEvmMultisignBodyLidoClaimWithdrawal(args) {
+  if (args.chainId !== LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+    throw new Error("Lido withdrawals are supported on Ethereum mainnet (chain id 1) only.");
+  }
+  if (args.requestId <= 0n) throw new Error("Withdrawal request id must be greater than zero.");
+  const wq = LIDO_WITHDRAWAL_QUEUE_MAINNET;
+  const data = viem.encodeFunctionData({
+    abi: wqAbi,
+    functionName: "claimWithdrawal",
+    args: [args.requestId]
+  });
+  const step = {
+    to: wq,
+    data,
+    value: 0n,
+    fallbackGas: LIDO_CLAIM_WITHDRAWAL_FALLBACK_GAS_UNITS,
+    buildBatchMeta: ({ gasLimit }) => ({
+      destinationAddress: wq,
+      signatureText: JSON.stringify({
+        kind: "Lido",
+        name: "WithdrawalQueue.claimWithdrawal",
+        requestId: args.requestId.toString(),
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      }),
+      evm: { type: "lido_claim_withdrawal", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+      lido: {
+        step: "claimWithdrawal",
+        requestId: args.requestId.toString(),
+        gasClaimWithdrawal: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  };
+  const purposeSuffix = `Lido: claim ETH for finalized withdrawal request #${args.requestId.toString()} on Ethereum (separate tx from requesting).`;
+  return finalizeLidoMultipart([step], {
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposeText: args.purposeText,
+    purposeSuffix,
+    executorAddress: args.executorAddress
+  });
+}
+async function buildEvmMultisignBodyLidoWrapStEth(args) {
+  if (args.chainId !== LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+    throw new Error("Lido wrap is supported on Ethereum mainnet (chain id 1) only.");
+  }
+  const steth = LIDO_STETH_CONTRACT_MAINNET;
+  const wsteth = LIDO_WSTETH_CONTRACT_MAINNET;
+  const ch = viem.defineChain({
+    id: LIDO_ETHEREUM_MAINNET_CHAIN_ID,
+    name: "Ethereum",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [args.rpcUrl.trim()] } }
+  });
+  const publicClient = viem.createPublicClient({ chain: ch, transport: viem.http(args.rpcUrl.trim()) });
+  const amountWei = viem.parseUnits(args.stEthAmountHuman, 18);
+  if (amountWei === 0n) throw new Error("stETH amount must be greater than zero.");
+  const executor = viem.getAddress(args.executorAddress);
+  const steps = [];
+  let approvalNeeded = false;
+  const allowance = await publicClient.readContract({
+    address: steth,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [executor, wsteth]
+  });
+  if (allowance < amountWei) {
+    approvalNeeded = true;
+    if (allowance > 0n) {
+      const dataReset = viem.encodeFunctionData({
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [wsteth, 0n]
+      });
+      steps.push({
+        to: steth,
+        data: dataReset,
+        value: 0n,
+        fallbackGas: LIDO_APPROVE_FALLBACK,
+        buildBatchMeta: ({ gasLimit }) => ({
+          destinationAddress: steth,
+          signatureText: JSON.stringify({
+            kind: "Lido",
+            name: "stETH.approve (reset for wstETH wrap)",
+            spender: wsteth,
+            chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+          }),
+          evm: { type: "lido_steth_approve", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+          lido: { step: "approve_wrap_reset", spender: "wstETH", gasApprove: { baseGasUnits: gasLimit.toString() } }
+        })
+      });
+    }
+    const dataApprove = viem.encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [wsteth, amountWei]
+    });
+    steps.push({
+      to: steth,
+      data: dataApprove,
+      value: 0n,
+      fallbackGas: LIDO_APPROVE_FALLBACK,
+      buildBatchMeta: ({ gasLimit }) => ({
+        destinationAddress: steth,
+        signatureText: JSON.stringify({
+          kind: "Lido",
+          name: "stETH.approve",
+          spender: wsteth,
+          amountWei: amountWei.toString(),
+          chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+        }),
+        evm: { type: "lido_steth_approve", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+        lido: {
+          step: "approve_wrap_exact",
+          stEthAmountHuman: args.stEthAmountHuman,
+          gasApprove: { baseGasUnits: gasLimit.toString() }
+        }
+      })
+    });
+  }
+  const dataWrap = viem.encodeFunctionData({
+    abi: wstethAbi,
+    functionName: "wrap",
+    args: [amountWei]
+  });
+  steps.push({
+    to: wsteth,
+    data: dataWrap,
+    value: 0n,
+    fallbackGas: LIDO_WSTETH_WRAP_FALLBACK_GAS_UNITS,
+    buildBatchMeta: ({ gasLimit }) => ({
+      destinationAddress: wsteth,
+      signatureText: JSON.stringify({
+        kind: "Lido",
+        name: "WstETH.wrap",
+        stEthAmountWei: amountWei.toString(),
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      }),
+      evm: { type: "lido_wsteth_wrap", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+      lido: {
+        step: "wrap",
+        stEthAmountHuman: args.stEthAmountHuman,
+        approvalNeeded,
+        gasWstethWrap: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  });
+  const purposeSuffix = `Lido: approve (if needed) + wrap (${args.stEthAmountHuman} stETH \u2192 wstETH) on Ethereum.`;
+  return finalizeLidoMultipart(steps, {
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposeText: args.purposeText,
+    purposeSuffix,
+    executorAddress: executor
+  });
+}
+async function buildEvmMultisignBodyLidoUnwrapWstEth(args) {
+  if (args.chainId !== LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+    throw new Error("Lido unwrap is supported on Ethereum mainnet (chain id 1) only.");
+  }
+  const wsteth = LIDO_WSTETH_CONTRACT_MAINNET;
+  const amt = viem.parseUnits(args.wstEthAmountHuman, 18);
+  if (amt === 0n) throw new Error("wstETH amount must be greater than zero.");
+  const data = viem.encodeFunctionData({
+    abi: wstethAbi,
+    functionName: "unwrap",
+    args: [amt]
+  });
+  const step = {
+    to: wsteth,
+    data,
+    value: 0n,
+    fallbackGas: LIDO_WSTETH_UNWRAP_FALLBACK_GAS_UNITS,
+    buildBatchMeta: ({ gasLimit }) => ({
+      destinationAddress: wsteth,
+      signatureText: JSON.stringify({
+        kind: "Lido",
+        name: "WstETH.unwrap",
+        wstEthAmountWei: amt.toString(),
+        chainId: LIDO_ETHEREUM_MAINNET_CHAIN_ID
+      }),
+      evm: { type: "lido_wsteth_unwrap", version: 1, chainId: String(LIDO_ETHEREUM_MAINNET_CHAIN_ID) },
+      lido: {
+        step: "unwrap",
+        wstEthAmountHuman: args.wstEthAmountHuman,
+        gasWstethUnwrap: { baseGasUnits: gasLimit.toString() }
+      }
+    })
+  };
+  const purposeSuffix = `Lido: unwrap (${args.wstEthAmountHuman} wstETH \u2192 stETH) on Ethereum.`;
+  return finalizeLidoMultipart([step], {
+    keyGen: args.keyGen,
+    rpcUrl: args.rpcUrl,
+    chainDetail: args.chainDetail,
+    useCustomGas: args.useCustomGas,
+    customGasChainDetails: args.customGasChainDetails,
+    purposeText: args.purposeText,
+    purposeSuffix,
+    executorAddress: args.executorAddress
+  });
+}
+function isLidoEvmSignRequestForEstimateWorkaround(detail, batchIndex) {
+  return isLidoBatchStepEvmSignRequest(detail, batchIndex ?? 0);
+}
+
+// src/protocols/evm/lido/index.ts
+var LIDO_PROTOCOL_ID = "lido";
+var lidoProtocolModule = {
+  id: LIDO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return Number(ctx.chainId) === LIDO_ETHEREUM_MAINNET_CHAIN_ID;
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    { id: "lido.submit", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Stake ETH via Lido submit()", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { valueWei: { type: "string", required: true, description: "ETH to stake (wei string)" } } },
+    { id: "lido.request-withdrawals", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Queue stETH withdrawal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "lido.claim-withdrawal", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Claim finalized withdrawal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "lido.wrap-steth", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Wrap stETH to wstETH", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "lido.unwrap-wsteth", protocolId: LIDO_PROTOCOL_ID, chainCategory: "evm", description: "Unwrap wstETH to stETH", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
+  ]
+};
+registerProtocolModule(lidoProtocolModule);
+
+exports.LIDO_CLAIM_WITHDRAWAL_FALLBACK_GAS_UNITS = LIDO_CLAIM_WITHDRAWAL_FALLBACK_GAS_UNITS;
+exports.LIDO_ETHEREUM_MAINNET_CHAIN_ID = LIDO_ETHEREUM_MAINNET_CHAIN_ID;
+exports.LIDO_EVM_TYPES = LIDO_EVM_TYPES;
+exports.LIDO_PROTOCOL_ID = LIDO_PROTOCOL_ID;
+exports.LIDO_REQUEST_WITHDRAWALS_FALLBACK_GAS_UNITS = LIDO_REQUEST_WITHDRAWALS_FALLBACK_GAS_UNITS;
+exports.LIDO_STETH_CONTRACT_MAINNET = LIDO_STETH_CONTRACT_MAINNET;
+exports.LIDO_SUBMIT_FALLBACK_GAS_UNITS = LIDO_SUBMIT_FALLBACK_GAS_UNITS;
+exports.LIDO_SUBMIT_REFERRAL_MAINNET = LIDO_SUBMIT_REFERRAL_MAINNET;
+exports.LIDO_WITHDRAWAL_QUEUE_MAINNET = LIDO_WITHDRAWAL_QUEUE_MAINNET;
+exports.LIDO_WSTETH_CONTRACT_MAINNET = LIDO_WSTETH_CONTRACT_MAINNET;
+exports.LIDO_WSTETH_UNWRAP_FALLBACK_GAS_UNITS = LIDO_WSTETH_UNWRAP_FALLBACK_GAS_UNITS;
+exports.LIDO_WSTETH_WRAP_FALLBACK_GAS_UNITS = LIDO_WSTETH_WRAP_FALLBACK_GAS_UNITS;
+exports.MIN_LIDO_EXECUTE_GAS = MIN_LIDO_EXECUTE_GAS;
+exports.buildEvmMultisignBodyLidoClaimWithdrawal = buildEvmMultisignBodyLidoClaimWithdrawal;
+exports.buildEvmMultisignBodyLidoRequestWithdrawals = buildEvmMultisignBodyLidoRequestWithdrawals;
+exports.buildEvmMultisignBodyLidoSubmit = buildEvmMultisignBodyLidoSubmit;
+exports.buildEvmMultisignBodyLidoUnwrapWstEth = buildEvmMultisignBodyLidoUnwrapWstEth;
+exports.buildEvmMultisignBodyLidoWrapStEth = buildEvmMultisignBodyLidoWrapStEth;
+exports.isEthereumMainnetChainId = isEthereumMainnetChainId;
+exports.isLidoBatchStepEvmSignRequest = isLidoBatchStepEvmSignRequest;
+exports.isLidoEvmSignRequestForEstimateWorkaround = isLidoEvmSignRequestForEstimateWorkaround;
+exports.lidoProtocolModule = lidoProtocolModule;
+exports.lidoRequestWithdrawalsBatchIndices = lidoRequestWithdrawalsBatchIndices;
+exports.resolveLidoBatchStepGasFromSignRequest = resolveLidoBatchStepGasFromSignRequest;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map