@forevermoney/sdk 0.5.0 → 0.5.2

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)",
@@ -455,89 +669,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);
@@ -651,6 +782,17 @@ function stakePullsFor(input, amountRao) {
   }
   return resolveStakePulls(input.stakePulls, amountRao);
 }
+function minimumSubtensorOutput(input) {
+  const minimum = input.minAmountOutWei ?? input.amountWei;
+  assertNonNegativeAmount(minimum, "Minimum output");
+  if (minimum === 0n || minimum > input.amountWei) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "Minimum output must be positive and no greater than the input amount."
+    );
+  }
+  return minimum;
+}
 function assertDelivery(value) {
   if (value !== "liquid" && value !== "staked") {
     throw new ForeverMoneyError(
@@ -929,6 +1071,7 @@ function buildSubtensorToEvmPlan(input) {
   assertAssetMode(input.asset, input.source);
   const netuid = sourceNetuid(input);
   assertSubtensorToEvmAmount(input.amountWei, input.source);
+  const minAmountOutWei = minimumSubtensorOutput(input);
   assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
@@ -993,7 +1136,7 @@ function buildSubtensorToEvmPlan(input) {
         recipient,
         taoAmount,
         stakedAlphaRao,
-        input.amountWei,
+        minAmountOutWei,
         partnerFee,
         pulls
       ),
@@ -1085,7 +1228,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);
@@ -1093,6 +1236,7 @@ async function prepareSubtensorToEvm(provider, input) {
   assertAssetMode(input.asset, input.source);
   const netuid = sourceNetuid(input);
   assertSubtensorToEvmAmount(input.amountWei, input.source);
+  const minAmountOutWei = minimumSubtensorOutput(input);
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
   const partnerFee = resolvePartnerFee(
@@ -1146,7 +1290,7 @@ async function prepareSubtensorToEvm(provider, input) {
         recipient,
         taoAmount,
         stakedAlphaRao,
-        input.amountWei,
+        minAmountOutWei,
         partnerFee,
         stakePullsFor(input, stakedAlphaRao)
       ),
@@ -1166,6 +1310,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" });
 }
@@ -2256,6 +2447,7 @@ export {
   buildWithdrawVaultPlan,
   createForeverMoneyClient,
   destinationChainId,
+  estimateRoundedStake,
   evmChainFromBridgeDirection,
   evmToMirrorSS58,
   feeWithBuffer,
@@ -2277,6 +2469,8 @@ export {
   partnerFeeTaoTopUp,
   sourceChainId,
   ss58ToPublicKey,
+  stakedMinimumOutput,
+  strandedStakeSource,
   toEip1193Transaction,
   toEthersTransaction,
   toViemTransaction,