@forevermoney/sdk 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -52,6 +52,7 @@ __export(index_exports, {
   buildWithdrawVaultPlan: () => buildWithdrawVaultPlan,
   createForeverMoneyClient: () => createForeverMoneyClient,
   destinationChainId: () => destinationChainId,
+  estimateRoundedStake: () => estimateRoundedStake,
   evmChainFromBridgeDirection: () => evmChainFromBridgeDirection,
   evmToMirrorSS58: () => evmToMirrorSS58,
   feeWithBuffer: () => feeWithBuffer,
@@ -73,6 +74,8 @@ __export(index_exports, {
   partnerFeeTaoTopUp: () => partnerFeeTaoTopUp,
   sourceChainId: () => sourceChainId,
   ss58ToPublicKey: () => ss58ToPublicKey,
+  stakedMinimumOutput: () => stakedMinimumOutput,
+  strandedStakeSource: () => strandedStakeSource,
   toEip1193Transaction: () => toEip1193Transaction,
   toEthersTransaction: () => toEthersTransaction,
   toViemTransaction: () => toViemTransaction,
@@ -80,80 +83,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/addresses.ts
-var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
-var import_viem = require("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 (!(0, import_viem.isAddress)(candidate) || candidate === import_viem.zeroAddress) {
-    throw new ForeverMoneyError(
-      "INVALID_ADDRESS",
-      "Expected a non-zero EVM address."
-    );
-  }
-  return (0, import_viem.getAddress)(candidate);
-}
-function evmToMirrorSS58(evmAddress) {
-  return (0, import_substrate_bindings.AccountId)(BITTENSOR_SS58_PREFIX).dec(
-    (0, import_substrate_bindings.Blake2256)(
-      (0, import_viem.concat)([
-        (0, import_viem.stringToBytes)("evm:"),
-        (0, import_viem.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 = (0, import_substrate_bindings.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 (0, import_substrate_bindings.AccountId)(BITTENSOR_SS58_PREFIX).dec(decodeBittensorAddress(value));
-}
-function isBittensorSS58(value) {
-  try {
-    decodeBittensorAddress(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function ss58ToPublicKey(value) {
-  return (0, import_viem.bytesToHex)(decodeBittensorAddress(value));
-}
-
-// src/core/amounts.ts
-var import_viem3 = require("viem");
-
 // src/chains/deployment.ts
-var import_viem2 = require("viem");
+var import_viem = require("viem");
 var BASE_CHAIN_ID = 8453;
 var ROBINHOOD_CHAIN_ID = 4663;
 var SUBTENSOR_CHAIN_ID = 964;
@@ -172,34 +103,34 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: BASE_CHAIN_ID,
     ccipSelector: BASE_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: (0, import_viem2.getAddress)("0x1da2415229b614C787e145D1D7346eb496319C52"),
+      gateway: (0, import_viem.getAddress)("0x1da2415229b614C787e145D1D7346eb496319C52"),
       // Retired gateways, oldest first; kept only to track transfers sent
       // through them.
       legacyGateways: [
-        (0, import_viem2.getAddress)("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C")
+        (0, import_viem.getAddress)("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C")
       ],
-      wrappedTao: (0, import_viem2.getAddress)(
+      wrappedTao: (0, import_viem.getAddress)(
         "0xf3081494b87e8d5fb7960f066e931d1d0e6e3d67"
       ),
-      wrappedSn80: (0, import_viem2.getAddress)(
+      wrappedSn80: (0, import_viem.getAddress)(
         "0x6f63d869011f95274498023b4abfc00b30c34378"
       ),
-      ccipRouter: (0, import_viem2.getAddress)(
+      ccipRouter: (0, import_viem.getAddress)(
         "0x881e3A65B4d4a04dD529061dd0071cf975F58bCD"
       ),
-      ccipOffRampFromSubtensor: (0, import_viem2.getAddress)(
+      ccipOffRampFromSubtensor: (0, import_viem.getAddress)(
         "0xf09AFe78d3c7d359b334d7cB88995751F7eC5E13"
       ),
-      vaultFactory: (0, import_viem2.getAddress)(
+      vaultFactory: (0, import_viem.getAddress)(
         "0x9b7F3c7aa335D8BF9f91741E541820466735F868"
       ),
-      vaultManagerImplementation: (0, import_viem2.getAddress)(
+      vaultManagerImplementation: (0, import_viem.getAddress)(
         "0x235Ad8654fe3a1619a9892eBCaD9361F416168da"
       ),
-      batchLiquidityManagerQuery: (0, import_viem2.getAddress)(
+      batchLiquidityManagerQuery: (0, import_viem.getAddress)(
         "0xd117176C5E6809b68500995F59589A8c081565A5"
       ),
-      weth: (0, import_viem2.getAddress)("0x4200000000000000000000000000000000000006")
+      weth: (0, import_viem.getAddress)("0x4200000000000000000000000000000000000006")
     }),
     deploymentBlock: 50098800
   }),
@@ -209,17 +140,17 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: ROBINHOOD_CHAIN_ID,
     ccipSelector: ROBINHOOD_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: (0, import_viem2.getAddress)("0xf27fdA637131E25B2A1b4865ED9597d881980c7E"),
+      gateway: (0, import_viem.getAddress)("0xf27fdA637131E25B2A1b4865ED9597d881980c7E"),
       legacyGateways: [
-        (0, import_viem2.getAddress)("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8")
+        (0, import_viem.getAddress)("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8")
       ],
-      wrappedTao: (0, import_viem2.getAddress)(
+      wrappedTao: (0, import_viem.getAddress)(
         "0xf3081494B87e8D5fb7960f066E931D1D0e6E3d67"
       ),
-      ccipRouter: (0, import_viem2.getAddress)(
+      ccipRouter: (0, import_viem.getAddress)(
         "0x06fC836cf9839B1cd891C440A0a45242DA6Ae1c9"
       ),
-      ccipOffRampFromSubtensor: (0, import_viem2.getAddress)(
+      ccipOffRampFromSubtensor: (0, import_viem.getAddress)(
         "0xcDca5D374e46A6DDDab50bD2D9acB8c796eC35C3"
       )
     })
@@ -229,32 +160,32 @@ var foreverMoneyDeployment = Object.freeze({
     ccipSelector: SUBTENSOR_CCIP_SELECTOR,
     contracts: Object.freeze({
       // V5.1 AlphaGateway: multi-validator staked input (tao-bridge 485c898).
-      gateway: (0, import_viem2.getAddress)("0xd5Fa238aa4177f6c1341491969d9cBeec94EEd69"),
+      gateway: (0, import_viem.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: [
-        (0, import_viem2.getAddress)("0x998f20Fea90bF7792774dECc7f994716442B1705"),
-        (0, import_viem2.getAddress)("0xcd0C6d98D0A126B1c113d15b4c28F38321437787")
+        (0, import_viem.getAddress)("0x998f20Fea90bF7792774dECc7f994716442B1705"),
+        (0, import_viem.getAddress)("0xcd0C6d98D0A126B1c113d15b4c28F38321437787")
       ],
-      alphaVault: (0, import_viem2.getAddress)(
+      alphaVault: (0, import_viem.getAddress)(
         "0x11837459896D96F821a8D88eC93a3C8D152033D4"
       ),
-      wrappedTao: (0, import_viem2.getAddress)(
+      wrappedTao: (0, import_viem.getAddress)(
         "0xC5b6C1632d34901239396F5E1BDe54B342900256"
       ),
-      wrappedSn80: (0, import_viem2.getAddress)(
+      wrappedSn80: (0, import_viem.getAddress)(
         "0xfD628dE75EF96f0A5C59659159C6cA81E0DC2222"
       ),
-      ccipRouter: (0, import_viem2.getAddress)(
+      ccipRouter: (0, import_viem.getAddress)(
         "0xD941fBEcD2b971d0F54b4C34286C95faB52B60B8"
       ),
-      ccipOffRampFromBase: (0, import_viem2.getAddress)(
+      ccipOffRampFromBase: (0, import_viem.getAddress)(
         "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
       ),
-      ccipOffRampFromRobinhood: (0, import_viem2.getAddress)(
+      ccipOffRampFromRobinhood: (0, import_viem.getAddress)(
         "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
       ),
-      stakingPrecompile: (0, import_viem2.getAddress)(
+      stakingPrecompile: (0, import_viem.getAddress)(
         "0x0000000000000000000000000000000000000805"
       )
     })
@@ -264,6 +195,21 @@ function getForeverMoneyEvmDeployment(chain = "base") {
   return foreverMoneyDeployment[chain];
 }
 
+// src/core/amounts.ts
+var import_viem2 = require("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;
@@ -284,7 +230,7 @@ function parseTaoAmount(value) {
   }
   let amount;
   try {
-    amount = (0, import_viem3.parseUnits)(value, 18);
+    amount = (0, import_viem2.parseUnits)(value, 18);
   } catch {
     throw new ForeverMoneyError(
       "AMOUNT_NOT_WHOLE_RAO",
@@ -313,7 +259,7 @@ function assertWholeRao(amountWei) {
       "The amount cannot be negative."
     );
   }
-  if (amountWei > import_viem3.maxUint256) {
+  if (amountWei > import_viem2.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The amount exceeds uint256."
@@ -339,7 +285,7 @@ function formatTaoAmount(amountWei) {
       "A TAO amount cannot be negative."
     );
   }
-  if (amountWei > import_viem3.maxUint256) {
+  if (amountWei > import_viem2.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The TAO amount exceeds uint256."
@@ -351,7 +297,7 @@ function formatTaoAmount(amountWei) {
       "TAO amounts must resolve to a whole RAO."
     );
   }
-  const formatted = (0, import_viem3.formatUnits)(amountWei, 18);
+  const formatted = (0, import_viem2.formatUnits)(amountWei, 18);
   return formatted.includes(".") ? formatted : `${formatted}.0`;
 }
 function mulDivCeil(value, numerator, denominator) {
@@ -375,7 +321,7 @@ function feeWithBuffer(fee) {
     BASIS_POINTS + NETWORK_FEE_BUFFER_BPS,
     BASIS_POINTS
   );
-  if (buffered > import_viem3.maxUint256) {
+  if (buffered > import_viem2.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The buffered network fee exceeds uint256."
@@ -401,7 +347,7 @@ function gasLimitWithBuffer(gasLimit) {
     BASIS_POINTS + GAS_LIMIT_BUFFER_BPS,
     BASIS_POINTS
   );
-  if (buffered > import_viem3.maxUint256) {
+  if (buffered > import_viem2.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The buffered gas limit exceeds uint256."
@@ -410,6 +356,277 @@ function gasLimitWithBuffer(gasLimit) {
   return buffered;
 }
 
+// src/core/validation.ts
+var import_viem3 = require("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 > import_viem3.maxUint256) {
+    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 > import_viem3.maxUint256) {
+    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 (!(0, import_viem3.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 ? import_viem3.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
+var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
+var import_viem4 = require("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 (!(0, import_viem4.isAddress)(candidate) || candidate === import_viem4.zeroAddress) {
+    throw new ForeverMoneyError(
+      "INVALID_ADDRESS",
+      "Expected a non-zero EVM address."
+    );
+  }
+  return (0, import_viem4.getAddress)(candidate);
+}
+function evmToMirrorSS58(evmAddress) {
+  return (0, import_substrate_bindings.AccountId)(BITTENSOR_SS58_PREFIX).dec(
+    (0, import_substrate_bindings.Blake2256)(
+      (0, import_viem4.concat)([
+        (0, import_viem4.stringToBytes)("evm:"),
+        (0, import_viem4.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 = (0, import_substrate_bindings.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 (0, import_substrate_bindings.AccountId)(BITTENSOR_SS58_PREFIX).dec(decodeBittensorAddress(value));
+}
+function isBittensorSS58(value) {
+  try {
+    decodeBittensorAddress(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ss58ToPublicKey(value) {
+  return (0, import_viem4.bytesToHex)(decodeBittensorAddress(value));
+}
+
 // src/abis/index.ts
 var ERC20_ABI = Object.freeze([
   "function allowance(address owner,address spender) view returns (uint256)",
@@ -504,7 +721,7 @@ var foreverMoneyAbis = Object.freeze({
 var import_viem6 = require("viem");
 
 // src/core/plans.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 function createTransactionPlan(plan) {
   const steps = plan.steps.map(
     (step2) => Object.freeze({
@@ -521,93 +738,10 @@ function createTransactionPlan(plan) {
   };
   return Object.freeze({
     ...versionedPlan,
-    hash: (0, import_viem4.keccak256)((0, import_viem4.stringToBytes)(JSON.stringify(versionedPlan)))
+    hash: (0, import_viem5.keccak256)((0, import_viem5.stringToBytes)(JSON.stringify(versionedPlan)))
   });
 }
 
-// src/core/validation.ts
-var import_viem5 = require("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 > import_viem5.maxUint256) {
-    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 > import_viem5.maxUint256) {
-    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 (!(0, import_viem5.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 ? import_viem5.zeroHash : normalizeBytes32(value, label);
-}
-
 // src/bridge/plans.ts
 var erc20Abi = (0, import_viem6.parseAbi)(ERC20_ABI);
 var spokeAbi = (0, import_viem6.parseAbi)(SPOKE_GATEWAY_ABI);
@@ -721,6 +855,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(
@@ -999,6 +1144,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);
@@ -1063,7 +1209,7 @@ function buildSubtensorToEvmPlan(input) {
         recipient,
         taoAmount,
         stakedAlphaRao,
-        input.amountWei,
+        minAmountOutWei,
         partnerFee,
         pulls
       ),
@@ -1155,7 +1301,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);
@@ -1163,6 +1309,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(
@@ -1216,7 +1363,7 @@ async function prepareSubtensorToEvm(provider, input) {
         recipient,
         taoAmount,
         stakedAlphaRao,
-        input.amountWei,
+        minAmountOutWei,
         partnerFee,
         stakePullsFor(input, stakedAlphaRao)
       ),
@@ -1236,6 +1383,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" });
 }