@forevermoney/sdk 0.5.1 → 0.5.3

package/dist/index.js

@@ -1,89 +1,5 @@
-// src/core/addresses.ts
-import {
-  AccountId,
-  Blake2256,
-  getSs58AddressInfo
-} from "@polkadot-api/substrate-bindings";
-import {
-  bytesToHex,
-  concat,
-  getAddress,
-  hexToBytes,
-  isAddress,
-  stringToBytes,
-  zeroAddress
-} from "viem";
-
-// src/core/errors.ts
-var ForeverMoneyError = class extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "ForeverMoneyError";
-    this.code = code;
-    this.details = details === void 0 ? void 0 : Object.freeze({ ...details });
-  }
-};
-
-// src/core/addresses.ts
-var BITTENSOR_SS58_PREFIX = 42;
-function normalizeEvmAddress(value) {
-  const candidate = typeof value === "string" && /^0x[0-9A-F]{40}$/.test(value) ? value.toLowerCase() : value;
-  if (!isAddress(candidate) || candidate === zeroAddress) {
-    throw new ForeverMoneyError(
-      "INVALID_ADDRESS",
-      "Expected a non-zero EVM address."
-    );
-  }
-  return getAddress(candidate);
-}
-function evmToMirrorSS58(evmAddress) {
-  return AccountId(BITTENSOR_SS58_PREFIX).dec(
-    Blake2256(
-      concat([
-        stringToBytes("evm:"),
-        hexToBytes(normalizeEvmAddress(evmAddress))
-      ])
-    )
-  );
-}
-function decodeBittensorAddress(value) {
-  try {
-    if (typeof value !== "string" || !value || value.startsWith("0x"))
-      throw new Error("Raw hex is not SS58.");
-    const info = getSs58AddressInfo(value);
-    if (!info.isValid || info.ss58Format !== BITTENSOR_SS58_PREFIX || info.publicKey.length !== 32)
-      throw new Error("Invalid Bittensor address.");
-    const publicKey = info.publicKey;
-    return publicKey;
-  } catch {
-    throw new ForeverMoneyError(
-      "INVALID_SS58",
-      "Expected a Bittensor SS58 address with prefix 42."
-    );
-  }
-}
-function normalizeSS58(value) {
-  return AccountId(BITTENSOR_SS58_PREFIX).dec(decodeBittensorAddress(value));
-}
-function isBittensorSS58(value) {
-  try {
-    decodeBittensorAddress(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function ss58ToPublicKey(value) {
-  return bytesToHex(decodeBittensorAddress(value));
-}
-
-// src/core/amounts.ts
-import { maxUint256, formatUnits, parseUnits } from "viem";
-
 // src/chains/deployment.ts
-import { getAddress as getAddress2 } from "viem";
+import { getAddress } from "viem";
 var BASE_CHAIN_ID = 8453;
 var ROBINHOOD_CHAIN_ID = 4663;
 var SUBTENSOR_CHAIN_ID = 964;
@@ -102,34 +18,34 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: BASE_CHAIN_ID,
     ccipSelector: BASE_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: getAddress2("0x1da2415229b614C787e145D1D7346eb496319C52"),
+      gateway: getAddress("0x1da2415229b614C787e145D1D7346eb496319C52"),
       // Retired gateways, oldest first; kept only to track transfers sent
       // through them.
       legacyGateways: [
-        getAddress2("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C")
+        getAddress("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C")
       ],
-      wrappedTao: getAddress2(
+      wrappedTao: getAddress(
         "0xf3081494b87e8d5fb7960f066e931d1d0e6e3d67"
       ),
-      wrappedSn80: getAddress2(
+      wrappedSn80: getAddress(
         "0x6f63d869011f95274498023b4abfc00b30c34378"
       ),
-      ccipRouter: getAddress2(
+      ccipRouter: getAddress(
         "0x881e3A65B4d4a04dD529061dd0071cf975F58bCD"
       ),
-      ccipOffRampFromSubtensor: getAddress2(
+      ccipOffRampFromSubtensor: getAddress(
         "0xf09AFe78d3c7d359b334d7cB88995751F7eC5E13"
       ),
-      vaultFactory: getAddress2(
+      vaultFactory: getAddress(
         "0x9b7F3c7aa335D8BF9f91741E541820466735F868"
       ),
-      vaultManagerImplementation: getAddress2(
+      vaultManagerImplementation: getAddress(
         "0x235Ad8654fe3a1619a9892eBCaD9361F416168da"
       ),
-      batchLiquidityManagerQuery: getAddress2(
+      batchLiquidityManagerQuery: getAddress(
         "0xd117176C5E6809b68500995F59589A8c081565A5"
       ),
-      weth: getAddress2("0x4200000000000000000000000000000000000006")
+      weth: getAddress("0x4200000000000000000000000000000000000006")
     }),
     deploymentBlock: 50098800
   }),
@@ -139,17 +55,17 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: ROBINHOOD_CHAIN_ID,
     ccipSelector: ROBINHOOD_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: getAddress2("0xf27fdA637131E25B2A1b4865ED9597d881980c7E"),
+      gateway: getAddress("0xf27fdA637131E25B2A1b4865ED9597d881980c7E"),
       legacyGateways: [
-        getAddress2("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8")
+        getAddress("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8")
       ],
-      wrappedTao: getAddress2(
+      wrappedTao: getAddress(
         "0xf3081494B87e8D5fb7960f066E931D1D0e6E3d67"
       ),
-      ccipRouter: getAddress2(
+      ccipRouter: getAddress(
         "0x06fC836cf9839B1cd891C440A0a45242DA6Ae1c9"
       ),
-      ccipOffRampFromSubtensor: getAddress2(
+      ccipOffRampFromSubtensor: getAddress(
         "0xcDca5D374e46A6DDDab50bD2D9acB8c796eC35C3"
       )
     })
@@ -159,32 +75,32 @@ var foreverMoneyDeployment = Object.freeze({
     ccipSelector: SUBTENSOR_CCIP_SELECTOR,
     contracts: Object.freeze({
       // V5.1 AlphaGateway: multi-validator staked input (tao-bridge 485c898).
-      gateway: getAddress2("0xd5Fa238aa4177f6c1341491969d9cBeec94EEd69"),
+      gateway: getAddress("0xd5Fa238aa4177f6c1341491969d9cBeec94EEd69"),
       // V4 and V5 hubs. The spokes still deliver to the V5 hub (their hub
       // pointer is immutable), so it stays here for delivery tracking.
       legacyGateways: [
-        getAddress2("0x998f20Fea90bF7792774dECc7f994716442B1705"),
-        getAddress2("0xcd0C6d98D0A126B1c113d15b4c28F38321437787")
+        getAddress("0x998f20Fea90bF7792774dECc7f994716442B1705"),
+        getAddress("0xcd0C6d98D0A126B1c113d15b4c28F38321437787")
       ],
-      alphaVault: getAddress2(
+      alphaVault: getAddress(
         "0x11837459896D96F821a8D88eC93a3C8D152033D4"
       ),
-      wrappedTao: getAddress2(
+      wrappedTao: getAddress(
         "0xC5b6C1632d34901239396F5E1BDe54B342900256"
       ),
-      wrappedSn80: getAddress2(
+      wrappedSn80: getAddress(
         "0xfD628dE75EF96f0A5C59659159C6cA81E0DC2222"
       ),
-      ccipRouter: getAddress2(
+      ccipRouter: getAddress(
         "0xD941fBEcD2b971d0F54b4C34286C95faB52B60B8"
       ),
-      ccipOffRampFromBase: getAddress2(
+      ccipOffRampFromBase: getAddress(
         "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
       ),
-      ccipOffRampFromRobinhood: getAddress2(
+      ccipOffRampFromRobinhood: getAddress(
         "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
       ),
-      stakingPrecompile: getAddress2(
+      stakingPrecompile: getAddress(
         "0x0000000000000000000000000000000000000805"
       )
     })
@@ -194,6 +110,21 @@ function getForeverMoneyEvmDeployment(chain = "base") {
   return foreverMoneyDeployment[chain];
 }
 
+// src/core/amounts.ts
+import { maxUint256, formatUnits, parseUnits } from "viem";
+
+// src/core/errors.ts
+var ForeverMoneyError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "ForeverMoneyError";
+    this.code = code;
+    this.details = details === void 0 ? void 0 : Object.freeze({ ...details });
+  }
+};
+
 // src/core/amounts.ts
 var BASIS_POINTS = 10000n;
 var NETWORK_FEE_BUFFER_BPS = 200n;
@@ -340,6 +271,289 @@ function gasLimitWithBuffer(gasLimit) {
   return buffered;
 }
 
+// src/core/validation.ts
+import { maxUint256 as maxUint2562, zeroHash, isHex } from "viem";
+function assertBigInt(amount, label) {
+  if (typeof amount !== "bigint") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be a bigint.`
+    );
+  }
+}
+function assertPositiveAmount(amount, label) {
+  assertBigInt(amount, label);
+  if (amount === 0n) {
+    throw new ForeverMoneyError(
+      "AMOUNT_ZERO",
+      `${label} must be greater than zero.`
+    );
+  }
+  if (amount < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} cannot be negative.`
+    );
+  }
+  if (amount > maxUint2562) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} exceeds uint256.`
+    );
+  }
+}
+function assertNonNegativeAmount(amount, label) {
+  assertBigInt(amount, label);
+  if (amount < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} cannot be negative.`
+    );
+  }
+  if (amount > maxUint2562) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} exceeds uint256.`
+    );
+  }
+}
+function assertBoolean(value, label) {
+  if (typeof value !== "boolean") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be a boolean.`
+    );
+  }
+}
+function assertArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be an array.`
+    );
+  }
+}
+function assertRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be an object.`
+    );
+  }
+}
+function normalizeBytes32(value, label) {
+  if (!isHex(value, { strict: true }) || value.length !== 66) {
+    throw new ForeverMoneyError(
+      "INVALID_BYTES32",
+      `${label} must be a 32-byte hex value.`
+    );
+  }
+  return value.toLowerCase();
+}
+function normalizeOptionalBytes32(value, label) {
+  return value === void 0 ? zeroHash : normalizeBytes32(value, label);
+}
+
+// src/bridge/stake-rounding.ts
+function invalid(message) {
+  throw new ForeverMoneyError("INVALID_TRANSACTION_PLAN", message);
+}
+function stakedMinimumOutput(amountWei, sourceCount = 1) {
+  assertWholeRao(amountWei);
+  if (!Number.isInteger(sourceCount) || sourceCount < 1 || sourceCount > 16)
+    invalid("Source count must be between 1 and 16.");
+  const rao = amountWei / EVM_WEI_PER_RAO;
+  const dust = 2n * BigInt(sourceCount) + 2n;
+  return (rao > dust ? rao - dust : rao) * EVM_WEI_PER_RAO;
+}
+function strandedStakeSource(error) {
+  const queue = [error];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length && seen.size < 20) {
+    const entry = queue.shift();
+    if (typeof entry === "string" && /^0x5408a598[0-9a-f]{128}$/i.test(entry))
+      return `0x${entry.slice(10, 74)}`.toLowerCase();
+    if (entry && typeof entry === "object" && !seen.has(entry)) {
+      seen.add(entry);
+      for (const key of [
+        "data",
+        "error",
+        "info",
+        "cause",
+        "details",
+        "rpcData"
+      ]) {
+        const nested = entry[key];
+        if (nested != null) queue.push(nested);
+      }
+    }
+  }
+  return null;
+}
+async function estimateRoundedStake({
+  amountWei,
+  minAmountOutWei,
+  pulls,
+  positions,
+  minStakeRao = 0n,
+  adjustRounding = true,
+  partnerFeeBps = 0,
+  quoteAndEstimate,
+  isActive = () => true
+}) {
+  assertWholeRao(amountWei);
+  assertPositiveAmount(minAmountOutWei, "Minimum output");
+  if (minAmountOutWei > amountWei)
+    invalid("Minimum output cannot exceed input.");
+  assertBoolean(adjustRounding, "adjustRounding");
+  assertNonNegativeAmount(minStakeRao, "Minimum remaining stake");
+  if (!Number.isInteger(partnerFeeBps) || partnerFeeBps < 0 || partnerFeeBps > 1e4)
+    invalid("Invalid partner fee basis points.");
+  if (!Array.isArray(pulls) || pulls.length < 1 || pulls.length > 16)
+    invalid("Provide between 1 and 16 stake pulls.");
+  const keys = /* @__PURE__ */ new Set();
+  const originalPulls = pulls.map((pull) => {
+    const hotkey = normalizeBytes32(pull.hotkey, "Validator").toLowerCase();
+    if (keys.has(hotkey)) invalid("Duplicate stake source.");
+    keys.add(hotkey);
+    assertPositiveAmount(pull.amountRao, "Stake pull");
+    return { hotkey, amountRao: pull.amountRao };
+  });
+  if (originalPulls.reduce((sum, pull) => sum + pull.amountRao, 0n) * EVM_WEI_PER_RAO !== amountWei)
+    invalid("Stake pulls must sum to the input amount.");
+  const balances = /* @__PURE__ */ new Map();
+  if (!Array.isArray(positions)) invalid("Stake positions must be an array.");
+  for (const position of positions) {
+    const key = normalizeBytes32(position.hotkey, "Validator").toLowerCase();
+    if (balances.has(key)) invalid("Duplicate stake position.");
+    assertNonNegativeAmount(position.stakeRao, "Stake balance");
+    balances.set(key, position.stakeRao);
+  }
+  const fits = (candidatePulls2) => {
+    const total = candidatePulls2.reduce(
+      (sum, pull) => sum + pull.amountRao,
+      0n
+    );
+    const cut = total * BigInt(partnerFeeBps) / 10000n;
+    const shares = candidatePulls2.map(
+      (pull, index) => index ? cut * pull.amountRao / total : 0n
+    );
+    shares[0] = cut - shares.reduce((sum, share) => sum + share, 0n);
+    return candidatePulls2.every((pull, index) => {
+      const balance = balances.get(pull.hotkey);
+      if (balance == null) return false;
+      const remainder = balance - pull.amountRao - shares[index];
+      return remainder === 0n || remainder > 0n && remainder >= minStakeRao;
+    });
+  };
+  if (!fits(originalPulls))
+    invalid(
+      "Stake positions cannot cover the pulls, partner fee, and minimum remainder."
+    );
+  let candidate = amountWei;
+  let candidatePulls = originalPulls;
+  for (let attempt = 0; ; attempt++) {
+    if (!isActive()) throw new Error("Stake quote cancelled.");
+    try {
+      const result = await quoteAndEstimate(
+        candidate,
+        candidatePulls,
+        minAmountOutWei
+      );
+      if (!isActive()) throw new Error("Stake quote cancelled.");
+      return Object.freeze({
+        ...result,
+        amountWei: candidate,
+        pulls: Object.freeze(
+          candidatePulls.map((pull) => Object.freeze({ ...pull }))
+        ),
+        minAmountOutWei
+      });
+    } catch (error) {
+      const hotkey = strandedStakeSource(error);
+      if (!isActive() || !adjustRounding || !hotkey || attempt >= 8 || candidate - EVM_WEI_PER_RAO < minAmountOutWei)
+        throw error;
+      const index = candidatePulls.findIndex(
+        (pull) => pull.hotkey === hotkey
+      );
+      if (index < 0 || candidatePulls[index].amountRao <= 1n) throw error;
+      const nextPulls = candidatePulls.map(
+        (pull, i) => i === index ? { ...pull, amountRao: pull.amountRao - 1n } : pull
+      );
+      if (!fits(nextPulls)) throw error;
+      candidatePulls = nextPulls;
+      candidate -= EVM_WEI_PER_RAO;
+    }
+  }
+}
+
+// src/core/addresses.ts
+import {
+  AccountId,
+  Blake2256,
+  getSs58AddressInfo
+} from "@polkadot-api/substrate-bindings";
+import {
+  bytesToHex,
+  concat,
+  getAddress as getAddress2,
+  hexToBytes,
+  isAddress,
+  stringToBytes,
+  zeroAddress
+} from "viem";
+var BITTENSOR_SS58_PREFIX = 42;
+function normalizeEvmAddress(value) {
+  const candidate = typeof value === "string" && /^0x[0-9A-F]{40}$/.test(value) ? value.toLowerCase() : value;
+  if (!isAddress(candidate) || candidate === zeroAddress) {
+    throw new ForeverMoneyError(
+      "INVALID_ADDRESS",
+      "Expected a non-zero EVM address."
+    );
+  }
+  return getAddress2(candidate);
+}
+function evmToMirrorSS58(evmAddress) {
+  return AccountId(BITTENSOR_SS58_PREFIX).dec(
+    Blake2256(
+      concat([
+        stringToBytes("evm:"),
+        hexToBytes(normalizeEvmAddress(evmAddress))
+      ])
+    )
+  );
+}
+function decodeBittensorAddress(value) {
+  try {
+    if (typeof value !== "string" || !value || value.startsWith("0x"))
+      throw new Error("Raw hex is not SS58.");
+    const info = getSs58AddressInfo(value);
+    if (!info.isValid || info.ss58Format !== BITTENSOR_SS58_PREFIX || info.publicKey.length !== 32)
+      throw new Error("Invalid Bittensor address.");
+    const publicKey = info.publicKey;
+    return publicKey;
+  } catch {
+    throw new ForeverMoneyError(
+      "INVALID_SS58",
+      "Expected a Bittensor SS58 address with prefix 42."
+    );
+  }
+}
+function normalizeSS58(value) {
+  return AccountId(BITTENSOR_SS58_PREFIX).dec(decodeBittensorAddress(value));
+}
+function isBittensorSS58(value) {
+  try {
+    decodeBittensorAddress(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ss58ToPublicKey(value) {
+  return bytesToHex(decodeBittensorAddress(value));
+}
+
 // src/abis/index.ts
 var ERC20_ABI = Object.freeze([
   "function allowance(address owner,address spender) view returns (uint256)",
@@ -358,7 +572,9 @@ var SPOKE_GATEWAY_ABI = Object.freeze([
   "function maxIntegratorFeeBps() view returns (uint16)",
   "function bridgeFeeBps() view returns (uint16)",
   "function quoteBridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) view returns (uint256 fee)",
+  "function quoteBridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit,uint256 gasLimit) view returns (uint256 fee)",
   "function bridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) payable returns (bytes32 messageId)",
+  "function bridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit,uint256 gasLimit) payable returns (bytes32 messageId)",
   "function quoteBridgeToFinneyWithFee(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit,uint256 gasLimit,(address recipient,uint16 bps) integrator) view returns (uint256 fee,uint256 cut,uint256 amountCrossing)",
   "function bridgeToFinneyWithFee(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit,uint256 gasLimit,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
   "event BridgedToFinney(address indexed token,address indexed sender,bytes32 indexed ss58,uint256 amount,bytes32 messageId)"
@@ -376,7 +592,6 @@ var ALPHA_GATEWAY_ABI = Object.freeze([
   "function bridgeOutWithFee(uint64 destSelector,address token,address recipient,uint256 taoAmount,uint256 stakedAlphaRao,uint256 minTokenOut,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
   "function bridgeOutFromValidators(uint64 destSelector,address token,address recipient,uint256 taoAmount,(bytes32 validator,uint256 alphaRao)[] sources,uint256 minTokenOut) payable returns (bytes32 messageId)",
   "function bridgeOutFromValidatorsWithFee(uint64 destSelector,address token,address recipient,uint256 taoAmount,(bytes32 validator,uint256 alphaRao)[] sources,uint256 minTokenOut,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
-  "function minStakeRequired() view returns (uint256)",
   "function MAX_STAKE_SOURCES() view returns (uint256)",
   "function GATEWAY_COLDKEY() view returns (bytes32)",
   "function claimLiquid(address token,uint256 minTaoOut,address to)",
@@ -455,89 +670,6 @@ function createTransactionPlan(plan) {
   });
 }
 
-// src/core/validation.ts
-import { maxUint256 as maxUint2562, zeroHash, isHex } from "viem";
-function assertBigInt(amount, label) {
-  if (typeof amount !== "bigint") {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} must be a bigint.`
-    );
-  }
-}
-function assertPositiveAmount(amount, label) {
-  assertBigInt(amount, label);
-  if (amount === 0n) {
-    throw new ForeverMoneyError(
-      "AMOUNT_ZERO",
-      `${label} must be greater than zero.`
-    );
-  }
-  if (amount < 0n) {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} cannot be negative.`
-    );
-  }
-  if (amount > maxUint2562) {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} exceeds uint256.`
-    );
-  }
-}
-function assertNonNegativeAmount(amount, label) {
-  assertBigInt(amount, label);
-  if (amount < 0n) {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} cannot be negative.`
-    );
-  }
-  if (amount > maxUint2562) {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} exceeds uint256.`
-    );
-  }
-}
-function assertBoolean(value, label) {
-  if (typeof value !== "boolean") {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} must be a boolean.`
-    );
-  }
-}
-function assertArray(value, label) {
-  if (!Array.isArray(value)) {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} must be an array.`
-    );
-  }
-}
-function assertRecord(value, label) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new ForeverMoneyError(
-      "INVALID_TRANSACTION_PLAN",
-      `${label} must be an object.`
-    );
-  }
-}
-function normalizeBytes32(value, label) {
-  if (!isHex(value, { strict: true }) || value.length !== 66) {
-    throw new ForeverMoneyError(
-      "INVALID_BYTES32",
-      `${label} must be a 32-byte hex value.`
-    );
-  }
-  return value.toLowerCase();
-}
-function normalizeOptionalBytes32(value, label) {
-  return value === void 0 ? zeroHash : normalizeBytes32(value, label);
-}
-
 // src/bridge/plans.ts
 var erc20Abi = parseAbi(ERC20_ABI);
 var spokeAbi = parseAbi(SPOKE_GATEWAY_ABI);
@@ -546,6 +678,18 @@ var stakingAbi = parseAbi(STAKING_ABI);
 var MIN_LIQUID_EVM_TO_SUBTENSOR_WEI = 10000000000000000n;
 var MIN_LIQUID_BASE_TO_SUBTENSOR_WEI = MIN_LIQUID_EVM_TO_SUBTENSOR_WEI;
 var MIN_LIQUID_SUBTENSOR_TO_EVM_WEI = 2000000n * EVM_WEI_PER_RAO;
+var EVM_TO_SUBTENSOR_DESTINATION_GAS_LIMIT = 3500000n;
+function resolveDestinationGasLimit(value) {
+  const gasLimit = value ?? EVM_TO_SUBTENSOR_DESTINATION_GAS_LIMIT;
+  if (typeof gasLimit !== "bigint" || gasLimit <= 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "Destination gas limit must be a positive bigint.",
+      { destinationGasLimit: String(gasLimit) }
+    );
+  }
+  return gasLimit;
+}
 var MAX_PARTNER_FEE_BPS = 1e4;
 var MAX_STAKE_PULLS = 16;
 var NO_PARTNER_FEE = {
@@ -722,15 +866,15 @@ function partnerFeeSummary(charged, unit, fee) {
   if (fee.bps === 0) return "";
   return ` Partner fee: ${charged} wei of ${unit} (${fee.bps} bps) on top, paid to ${fee.recipient}.`;
 }
-function encodeSpokeBridge(token, amountWei, exit, fee) {
+function encodeSpokeBridge(token, amountWei, exit, destinationGasLimit, fee) {
   return fee.bps === 0 ? encodeFunctionData({
     abi: spokeAbi,
     functionName: "bridgeToFinney",
-    args: [token, amountWei, exit]
+    args: [token, amountWei, exit, destinationGasLimit]
   }) : encodeFunctionData({
     abi: spokeAbi,
     functionName: "bridgeToFinneyWithFee",
-    args: [token, amountWei, exit, 0n, fee]
+    args: [token, amountWei, exit, destinationGasLimit, fee]
   });
 }
 function resolveStakePulls(pulls, amountRao) {
@@ -817,7 +961,7 @@ function encodeHubBridge(destSelector, token, recipient, taoAmount, stakedAlphaR
     args: [...args, fee]
   });
 }
-async function quoteSpokeWithFee(provider, gateway, token, amountWei, exit, fee) {
+async function quoteSpokeWithFee(provider, gateway, token, amountWei, exit, destinationGasLimit, fee) {
   const maxBps = await provider.readContract({
     address: gateway,
     abi: spokeAbi,
@@ -828,7 +972,7 @@ async function quoteSpokeWithFee(provider, gateway, token, amountWei, exit, fee)
     address: gateway,
     abi: spokeAbi,
     functionName: "quoteBridgeToFinneyWithFee",
-    args: [token, amountWei, exit, 0n, fee]
+    args: [token, amountWei, exit, destinationGasLimit, fee]
   });
   return networkFee;
 }
@@ -874,6 +1018,9 @@ function buildEvmToSubtensorPlan(input) {
   assertBaseToSubtensorAmount(input.amountWei, input.delivery);
   assertNonNegativeAmount(input.allowanceWei, "Token allowance");
   assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
+  const destinationGasLimit = resolveDestinationGasLimit(
+    input.destinationGasLimit
+  );
   const destination = normalizeSS58(input.destination);
   const exit = {
     ss58: ss58ToPublicKey(destination),
@@ -917,6 +1064,7 @@ function buildEvmToSubtensorPlan(input) {
         asset.evmToken,
         input.amountWei,
         exit,
+        destinationGasLimit,
         partnerFee
       ),
       value,
@@ -1032,6 +1180,9 @@ async function prepareEvmToSubtensor(provider, input) {
   assertDelivery(input.delivery);
   assertAssetMode(input.asset, input.delivery);
   assertBaseToSubtensorAmount(input.amountWei, input.delivery);
+  const destinationGasLimit = resolveDestinationGasLimit(
+    input.destinationGasLimit
+  );
   const destination = normalizeSS58(input.destination);
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
   const exit = {
@@ -1056,13 +1207,19 @@ async function prepareEvmToSubtensor(provider, input) {
       address: evm.contracts.gateway,
       abi: spokeAbi,
       functionName: "quoteBridgeToFinney",
-      args: [asset.evmToken, input.amountWei, exit]
+      args: [
+        asset.evmToken,
+        input.amountWei,
+        exit,
+        destinationGasLimit
+      ]
     }) : quoteSpokeWithFee(
       provider,
       evm.contracts.gateway,
       asset.evmToken,
       input.amountWei,
       exit,
+      destinationGasLimit,
       partnerFee
     )
   ]);
@@ -1072,6 +1229,7 @@ async function prepareEvmToSubtensor(provider, input) {
       asset.evmToken,
       input.amountWei,
       exit,
+      destinationGasLimit,
       partnerFee
     );
     estimatedBridgeGas = await provider.estimateGas({
@@ -1097,7 +1255,7 @@ async function prepareEvmToSubtensor(provider, input) {
 function prepareBaseToSubtensor(provider, input) {
   return prepareEvmToSubtensor(provider, { ...input, evmChain: "base" });
 }
-async function prepareSubtensorToEvm(provider, input) {
+async function prepareSubtensorToEvmExact(provider, input) {
   const sender = normalizeEvmAddress(input.sender);
   const recipient = normalizeEvmAddress(input.recipient);
   const asset = bridgeAsset(input.evmChain, input.asset);
@@ -1179,6 +1337,53 @@ async function prepareSubtensorToEvm(provider, input) {
     plan
   });
 }
+async function prepareSubtensorToEvm(provider, input) {
+  const options = input.stakeRounding;
+  if (options != null && options !== false && typeof options.enabled !== "boolean") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "stakeRounding.enabled must be a boolean."
+    );
+  }
+  if (!options || !options.enabled)
+    return prepareSubtensorToEvmExact(provider, input);
+  if (input.source !== "staked" || !input.stakePulls?.length) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "Stake rounding requires a staked source with named stakePulls."
+    );
+  }
+  const minimum = minimumSubtensorOutput(input);
+  const result = await estimateRoundedStake({
+    amountWei: input.amountWei,
+    minAmountOutWei: minimum,
+    pulls: input.stakePulls,
+    positions: options.positions,
+    minStakeRao: options.minStakeRao ?? 0n,
+    partnerFeeBps: input.partnerFee?.bps ?? 0,
+    quoteAndEstimate: async (amountWei, stakePulls, minAmountOutWei) => ({
+      prepared: await prepareSubtensorToEvmExact(provider, {
+        ...input,
+        amountWei,
+        stakePulls,
+        minAmountOutWei,
+        stakeRounding: false
+      })
+    })
+  });
+  return Object.freeze({
+    ...result.prepared,
+    stakeRounding: Object.freeze({
+      requestedAmountWei: input.amountWei,
+      amountWei: result.amountWei,
+      minAmountOutWei: result.minAmountOutWei,
+      pulls: result.pulls,
+      simulationComplete: !result.prepared.plan.steps.some(
+        (step2) => step2.kind === "approval"
+      )
+    })
+  });
+}
 function prepareSubtensorToBase(provider, input) {
   return prepareSubtensorToEvm(provider, { ...input, evmChain: "base" });
 }
@@ -2240,6 +2445,7 @@ export {
   BASE_CCIP_SELECTOR,
   BASE_CHAIN_ID,
   BASIS_POINTS,
+  EVM_TO_SUBTENSOR_DESTINATION_GAS_LIMIT,
   EVM_WEI_PER_RAO,
   FOREVERMONEY_DEPLOYMENT_VERSION,
   ForeverMoneyError,
@@ -2269,6 +2475,7 @@ export {
   buildWithdrawVaultPlan,
   createForeverMoneyClient,
   destinationChainId,
+  estimateRoundedStake,
   evmChainFromBridgeDirection,
   evmToMirrorSS58,
   feeWithBuffer,
@@ -2290,6 +2497,8 @@ export {
   partnerFeeTaoTopUp,
   sourceChainId,
   ss58ToPublicKey,
+  stakedMinimumOutput,
+  strandedStakeSource,
   toEip1193Transaction,
   toEthersTransaction,
   toViemTransaction,