@forevermoney/sdk 0.1.0 → 0.4.0

package/dist/index.cjs

@@ -27,12 +27,15 @@ __export(index_exports, {
   FOREVERMONEY_DEPLOYMENT_VERSION: () => FOREVERMONEY_DEPLOYMENT_VERSION,
   ForeverMoneyError: () => ForeverMoneyError,
   GAS_LIMIT_BUFFER_BPS: () => GAS_LIMIT_BUFFER_BPS,
+  MAX_PARTNER_FEE_BPS: () => MAX_PARTNER_FEE_BPS,
   MIN_LIQUID_BASE_TO_SUBTENSOR_WEI: () => MIN_LIQUID_BASE_TO_SUBTENSOR_WEI,
   MIN_LIQUID_EVM_TO_SUBTENSOR_WEI: () => MIN_LIQUID_EVM_TO_SUBTENSOR_WEI,
+  MIN_LIQUID_SUBTENSOR_TO_EVM_WEI: () => MIN_LIQUID_SUBTENSOR_TO_EVM_WEI,
   NETWORK_FEE_BUFFER_BPS: () => NETWORK_FEE_BUFFER_BPS,
   RAO_PER_TAO: () => RAO_PER_TAO,
   ROBINHOOD_CCIP_SELECTOR: () => ROBINHOOD_CCIP_SELECTOR,
   ROBINHOOD_CHAIN_ID: () => ROBINHOOD_CHAIN_ID,
+  SN80_NETUID: () => SN80_NETUID,
   SUBTENSOR_CCIP_SELECTOR: () => SUBTENSOR_CCIP_SELECTOR,
   SUBTENSOR_CHAIN_ID: () => SUBTENSOR_CHAIN_ID,
   assertWholeRao: () => assertWholeRao,
@@ -65,18 +68,20 @@ __export(index_exports, {
   normalizeEvmAddress: () => normalizeEvmAddress,
   normalizeSS58: () => normalizeSS58,
   parseTaoAmount: () => parseTaoAmount,
+  partnerFeeCut: () => partnerFeeCut,
+  partnerFeeTaoTopUp: () => partnerFeeTaoTopUp,
   sourceChainId: () => sourceChainId,
   ss58ToPublicKey: () => ss58ToPublicKey,
   toEip1193Transaction: () => toEip1193Transaction,
   toEthersTransaction: () => toEthersTransaction,
+  toViemTransaction: () => toViemTransaction,
   vaultManagerFromCreationReceipt: () => vaultManagerFromCreationReceipt
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/core/addresses.ts
-var import_util = require("@polkadot/util");
-var import_util_crypto = require("@polkadot/util-crypto");
-var import_ethers = require("ethers");
+var import_substrate_bindings = require("@polkadot-api/substrate-bindings");
+var import_viem = require("viem");
 
 // src/core/errors.ts
 var ForeverMoneyError = class extends Error {
@@ -93,22 +98,33 @@ var ForeverMoneyError = class extends Error {
 // src/core/addresses.ts
 var BITTENSOR_SS58_PREFIX = 42;
 function normalizeEvmAddress(value) {
-  if (!(0, import_ethers.isAddress)(value) || value === import_ethers.ZeroAddress) {
+  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_ethers.getAddress)(value);
+  return (0, import_viem.getAddress)(candidate);
 }
 function evmToMirrorSS58(evmAddress) {
-  return (0, import_util_crypto.evmToAddress)(normalizeEvmAddress(evmAddress), BITTENSOR_SS58_PREFIX);
+  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 (!value || (0, import_util.isHex)(value)) throw new Error("Raw hex is not SS58.");
-    const publicKey = (0, import_util_crypto.decodeAddress)(value, false, BITTENSOR_SS58_PREFIX);
-    if (publicKey.length !== 32) throw new Error("Invalid key length.");
+    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(
@@ -118,7 +134,7 @@ function decodeBittensorAddress(value) {
   }
 }
 function normalizeSS58(value) {
-  return (0, import_util_crypto.encodeAddress)(decodeBittensorAddress(value), BITTENSOR_SS58_PREFIX);
+  return (0, import_substrate_bindings.AccountId)(BITTENSOR_SS58_PREFIX).dec(decodeBittensorAddress(value));
 }
 function isBittensorSS58(value) {
   try {
@@ -129,14 +145,14 @@ function isBittensorSS58(value) {
   }
 }
 function ss58ToPublicKey(value) {
-  return (0, import_util.u8aToHex)(decodeBittensorAddress(value));
+  return (0, import_viem.bytesToHex)(decodeBittensorAddress(value));
 }
 
 // src/core/amounts.ts
-var import_ethers3 = require("ethers");
+var import_viem3 = require("viem");
 
 // src/chains/deployment.ts
-var import_ethers2 = require("ethers");
+var import_viem2 = require("viem");
 var BASE_CHAIN_ID = 8453;
 var ROBINHOOD_CHAIN_ID = 4663;
 var SUBTENSOR_CHAIN_ID = 964;
@@ -145,7 +161,8 @@ var ROBINHOOD_CCIP_SELECTOR = 6180753054346818345n;
 var SUBTENSOR_CCIP_SELECTOR = 2135107236357186872n;
 var RAO_PER_TAO = 1000000000n;
 var EVM_WEI_PER_RAO = 1000000000n;
-var FOREVERMONEY_DEPLOYMENT_VERSION = "1.1.0";
+var SN80_NETUID = 80n;
+var FOREVERMONEY_DEPLOYMENT_VERSION = "1.2.0";
 var foreverMoneyDeployment = Object.freeze({
   version: FOREVERMONEY_DEPLOYMENT_VERSION,
   base: Object.freeze({
@@ -154,26 +171,32 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: BASE_CHAIN_ID,
     ccipSelector: BASE_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: (0, import_ethers2.getAddress)("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C"),
-      wrappedTao: (0, import_ethers2.getAddress)(
+      gateway: (0, import_viem2.getAddress)("0x1da2415229b614C787e145D1D7346eb496319C52"),
+      legacyGateway: (0, import_viem2.getAddress)(
+        "0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C"
+      ),
+      wrappedTao: (0, import_viem2.getAddress)(
         "0xf3081494b87e8d5fb7960f066e931d1d0e6e3d67"
       ),
-      ccipRouter: (0, import_ethers2.getAddress)(
+      wrappedSn80: (0, import_viem2.getAddress)(
+        "0x6f63d869011f95274498023b4abfc00b30c34378"
+      ),
+      ccipRouter: (0, import_viem2.getAddress)(
         "0x881e3A65B4d4a04dD529061dd0071cf975F58bCD"
       ),
-      ccipOffRampFromSubtensor: (0, import_ethers2.getAddress)(
+      ccipOffRampFromSubtensor: (0, import_viem2.getAddress)(
         "0xf09AFe78d3c7d359b334d7cB88995751F7eC5E13"
       ),
-      vaultFactory: (0, import_ethers2.getAddress)(
+      vaultFactory: (0, import_viem2.getAddress)(
         "0x9b7F3c7aa335D8BF9f91741E541820466735F868"
       ),
-      vaultManagerImplementation: (0, import_ethers2.getAddress)(
+      vaultManagerImplementation: (0, import_viem2.getAddress)(
         "0x235Ad8654fe3a1619a9892eBCaD9361F416168da"
       ),
-      batchLiquidityManagerQuery: (0, import_ethers2.getAddress)(
+      batchLiquidityManagerQuery: (0, import_viem2.getAddress)(
         "0xd117176C5E6809b68500995F59589A8c081565A5"
       ),
-      weth: (0, import_ethers2.getAddress)("0x4200000000000000000000000000000000000006")
+      weth: (0, import_viem2.getAddress)("0x4200000000000000000000000000000000000006")
     }),
     deploymentBlock: 50098800
   }),
@@ -183,14 +206,17 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: ROBINHOOD_CHAIN_ID,
     ccipSelector: ROBINHOOD_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: (0, import_ethers2.getAddress)("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8"),
-      wrappedTao: (0, import_ethers2.getAddress)(
+      gateway: (0, import_viem2.getAddress)("0xf27fdA637131E25B2A1b4865ED9597d881980c7E"),
+      legacyGateway: (0, import_viem2.getAddress)(
+        "0x53Dcc4FE04193e489BE537F722F65317DB1E65d8"
+      ),
+      wrappedTao: (0, import_viem2.getAddress)(
         "0xf3081494B87e8D5fb7960f066E931D1D0e6E3d67"
       ),
-      ccipRouter: (0, import_ethers2.getAddress)(
+      ccipRouter: (0, import_viem2.getAddress)(
         "0x06fC836cf9839B1cd891C440A0a45242DA6Ae1c9"
       ),
-      ccipOffRampFromSubtensor: (0, import_ethers2.getAddress)(
+      ccipOffRampFromSubtensor: (0, import_viem2.getAddress)(
         "0xcDca5D374e46A6DDDab50bD2D9acB8c796eC35C3"
       )
     })
@@ -199,23 +225,29 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: SUBTENSOR_CHAIN_ID,
     ccipSelector: SUBTENSOR_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: (0, import_ethers2.getAddress)("0x998f20Fea90bF7792774dECc7f994716442B1705"),
-      alphaVault: (0, import_ethers2.getAddress)(
+      gateway: (0, import_viem2.getAddress)("0xcd0C6d98D0A126B1c113d15b4c28F38321437787"),
+      legacyGateway: (0, import_viem2.getAddress)(
+        "0x998f20Fea90bF7792774dECc7f994716442B1705"
+      ),
+      alphaVault: (0, import_viem2.getAddress)(
         "0x11837459896D96F821a8D88eC93a3C8D152033D4"
       ),
-      wrappedTao: (0, import_ethers2.getAddress)(
+      wrappedTao: (0, import_viem2.getAddress)(
         "0xC5b6C1632d34901239396F5E1BDe54B342900256"
       ),
-      ccipRouter: (0, import_ethers2.getAddress)(
+      wrappedSn80: (0, import_viem2.getAddress)(
+        "0xfD628dE75EF96f0A5C59659159C6cA81E0DC2222"
+      ),
+      ccipRouter: (0, import_viem2.getAddress)(
         "0xD941fBEcD2b971d0F54b4C34286C95faB52B60B8"
       ),
-      ccipOffRampFromBase: (0, import_ethers2.getAddress)(
+      ccipOffRampFromBase: (0, import_viem2.getAddress)(
         "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
       ),
-      ccipOffRampFromRobinhood: (0, import_ethers2.getAddress)(
+      ccipOffRampFromRobinhood: (0, import_viem2.getAddress)(
         "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
       ),
-      stakingPrecompile: (0, import_ethers2.getAddress)(
+      stakingPrecompile: (0, import_viem2.getAddress)(
         "0x0000000000000000000000000000000000000805"
       )
     })
@@ -245,7 +277,7 @@ function parseTaoAmount(value) {
   }
   let amount;
   try {
-    amount = (0, import_ethers3.parseUnits)(value, 18);
+    amount = (0, import_viem3.parseUnits)(value, 18);
   } catch {
     throw new ForeverMoneyError(
       "AMOUNT_NOT_WHOLE_RAO",
@@ -274,7 +306,7 @@ function assertWholeRao(amountWei) {
       "The amount cannot be negative."
     );
   }
-  if (amountWei > import_ethers3.MaxUint256) {
+  if (amountWei > import_viem3.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The amount exceeds uint256."
@@ -300,7 +332,7 @@ function formatTaoAmount(amountWei) {
       "A TAO amount cannot be negative."
     );
   }
-  if (amountWei > import_ethers3.MaxUint256) {
+  if (amountWei > import_viem3.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The TAO amount exceeds uint256."
@@ -312,7 +344,8 @@ function formatTaoAmount(amountWei) {
       "TAO amounts must resolve to a whole RAO."
     );
   }
-  return (0, import_ethers3.formatUnits)(amountWei, 18);
+  const formatted = (0, import_viem3.formatUnits)(amountWei, 18);
+  return formatted.includes(".") ? formatted : `${formatted}.0`;
 }
 function mulDivCeil(value, numerator, denominator) {
   return (value * numerator + denominator - 1n) / denominator;
@@ -335,7 +368,7 @@ function feeWithBuffer(fee) {
     BASIS_POINTS + NETWORK_FEE_BUFFER_BPS,
     BASIS_POINTS
   );
-  if (buffered > import_ethers3.MaxUint256) {
+  if (buffered > import_viem3.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The buffered network fee exceeds uint256."
@@ -361,7 +394,7 @@ function gasLimitWithBuffer(gasLimit) {
     BASIS_POINTS + GAS_LIMIT_BUFFER_BPS,
     BASIS_POINTS
   );
-  if (buffered > import_ethers3.MaxUint256) {
+  if (buffered > import_viem3.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The buffered gas limit exceeds uint256."
@@ -385,23 +418,34 @@ var SPOKE_GATEWAY_ABI = Object.freeze([
   "function ROUTER() view returns (address)",
   "function BITTENSOR_SELECTOR() view returns (uint64)",
   "function SUBTENSOR_GATEWAY() view returns (address)",
+  "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 bridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) 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)"
 ]);
 var ALPHA_GATEWAY_ABI = Object.freeze([
   "function ROUTER() view returns (address)",
   "function allowedLane(uint64 selector) view returns (bool)",
+  "function maxIntegratorFeeBps() view returns (uint16)",
+  "function bridgeFeeBps() view returns (uint16)",
+  "function integratorTaoTopUp(uint256 taoAmount,uint16 bps) pure returns (uint256)",
   "function quoteBridgeOut(uint64 destSelector,address token,address recipient,uint256 mintedAmount) view returns (uint256 fee)",
   "function bridgeOut(uint64 destSelector,address token,address recipient,uint256 taoAmount,uint256 stakedAlphaRao,uint256 minTokenOut) payable returns (bytes32 messageId)",
+  "function integratorCut(uint256 amount,uint16 bps) pure returns (uint256)",
+  "function quoteBridgeOutWithFee(uint64 destSelector,address token,address recipient,uint256 mintedAmount,uint256 taoAmount,uint256 stakedAlphaRao,(address recipient,uint16 bps) integrator) view returns (uint256 fee,uint256 nativeTopUp,uint256 alphaTopUp,uint256 amountCrossing)",
+  "function bridgeOutWithFee(uint64 destSelector,address token,address recipient,uint256 taoAmount,uint256 stakedAlphaRao,uint256 minTokenOut,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
   "function claimLiquid(address token,uint256 minTaoOut,address to)",
   "function claimNative(address to)",
   "function claimStaked(address token,bytes32 destColdkey,address to)",
   "function claimToken(address token,address to)",
   "function claimableNative(address account) view returns (uint256)",
-  "function claimableToken(address account,address token) view returns (uint256)",
+  "function claimableToken(address token,address account) view returns (uint256)",
   "event BridgedOut(uint64 destChainSelector,address indexed token,address indexed sender,address indexed recipient,uint256 minted,bytes32 messageId)",
   "event Claimable(address indexed token,address indexed user,uint256 native,uint256 wsn)",
+  "event NotDelivered(uint64 indexed sourceChainSelector,address indexed token,uint256 amount,uint8 reason)",
   "event DeliveredLiquid(address indexed token,bytes32 indexed ss58,uint256 taoOut)",
   "event DeliveredStaked(address indexed token,bytes32 indexed ss58,uint256 alphaRao)"
 ]);
@@ -445,10 +489,10 @@ var foreverMoneyAbis = Object.freeze({
 });
 
 // src/bridge/plans.ts
-var import_ethers6 = require("ethers");
+var import_viem6 = require("viem");
 
 // src/core/plans.ts
-var import_ethers4 = require("ethers");
+var import_viem4 = require("viem");
 function createTransactionPlan(plan) {
   const steps = plan.steps.map(
     (step2) => Object.freeze({
@@ -465,12 +509,12 @@ function createTransactionPlan(plan) {
   };
   return Object.freeze({
     ...versionedPlan,
-    hash: (0, import_ethers4.keccak256)((0, import_ethers4.toUtf8Bytes)(JSON.stringify(versionedPlan)))
+    hash: (0, import_viem4.keccak256)((0, import_viem4.stringToBytes)(JSON.stringify(versionedPlan)))
   });
 }
 
 // src/core/validation.ts
-var import_ethers5 = require("ethers");
+var import_viem5 = require("viem");
 function assertBigInt(amount, label) {
   if (typeof amount !== "bigint") {
     throw new ForeverMoneyError(
@@ -493,7 +537,7 @@ function assertPositiveAmount(amount, label) {
       `${label} cannot be negative.`
     );
   }
-  if (amount > import_ethers5.MaxUint256) {
+  if (amount > import_viem5.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       `${label} exceeds uint256.`
@@ -508,7 +552,7 @@ function assertNonNegativeAmount(amount, label) {
       `${label} cannot be negative.`
     );
   }
-  if (amount > import_ethers5.MaxUint256) {
+  if (amount > import_viem5.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       `${label} exceeds uint256.`
@@ -540,7 +584,7 @@ function assertRecord(value, label) {
   }
 }
 function normalizeBytes32(value, label) {
-  if (!(0, import_ethers5.isHexString)(value, 32)) {
+  if (!(0, import_viem5.isHex)(value, { strict: true }) || value.length !== 66) {
     throw new ForeverMoneyError(
       "INVALID_BYTES32",
       `${label} must be a 32-byte hex value.`
@@ -549,16 +593,111 @@ function normalizeBytes32(value, label) {
   return value.toLowerCase();
 }
 function normalizeOptionalBytes32(value, label) {
-  return value === void 0 ? import_ethers5.ZeroHash : normalizeBytes32(value, label);
+  return value === void 0 ? import_viem5.zeroHash : normalizeBytes32(value, label);
 }
 
 // src/bridge/plans.ts
-var erc20Interface = new import_ethers6.Interface(ERC20_ABI);
-var spokeInterface = new import_ethers6.Interface(SPOKE_GATEWAY_ABI);
-var alphaInterface = new import_ethers6.Interface(ALPHA_GATEWAY_ABI);
-var stakingInterface = new import_ethers6.Interface(STAKING_ABI);
+var erc20Abi = (0, import_viem6.parseAbi)(ERC20_ABI);
+var spokeAbi = (0, import_viem6.parseAbi)(SPOKE_GATEWAY_ABI);
+var alphaAbi = (0, import_viem6.parseAbi)(ALPHA_GATEWAY_ABI);
+var stakingAbi = (0, import_viem6.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 MAX_PARTNER_FEE_BPS = 1e4;
+var NO_PARTNER_FEE = {
+  recipient: "0x0000000000000000000000000000000000000000",
+  bps: 0
+};
+function resolvePartnerFee(fee, gateway) {
+  if (fee === void 0) return NO_PARTNER_FEE;
+  if (typeof fee.bps !== "number" || !Number.isInteger(fee.bps) || fee.bps < 0 || fee.bps > MAX_PARTNER_FEE_BPS) {
+    throw new ForeverMoneyError(
+      "INVALID_PARTNER_FEE",
+      `Partner fee bps must be an integer between 0 and ${MAX_PARTNER_FEE_BPS}.`,
+      { bps: fee.bps }
+    );
+  }
+  if (fee.bps === 0) return NO_PARTNER_FEE;
+  const recipient = normalizeEvmAddress(fee.recipient);
+  if (recipient === NO_PARTNER_FEE.recipient || recipient.toLowerCase() === gateway.toLowerCase()) {
+    throw new ForeverMoneyError(
+      "INVALID_PARTNER_FEE",
+      "Partner fee recipient must not be the zero address or the gateway.",
+      { recipient }
+    );
+  }
+  return { recipient, bps: fee.bps };
+}
+function partnerFeeCut(amount, bps) {
+  return amount * BigInt(bps) / 10000n;
+}
+function partnerFeeTaoTopUp(taoAmount, bps) {
+  const raw = partnerFeeCut(taoAmount, bps);
+  if (raw === 0n) return 0n;
+  return (raw + EVM_WEI_PER_RAO - 1n) / EVM_WEI_PER_RAO * EVM_WEI_PER_RAO;
+}
+function assertPartnerFeeAllowed(fee, maxBps) {
+  if (fee.bps > maxBps) {
+    throw new ForeverMoneyError(
+      "INVALID_PARTNER_FEE",
+      `Partner fee of ${fee.bps} bps exceeds the gateway maximum of ${maxBps} bps.`,
+      { bps: fee.bps, maxBps }
+    );
+  }
+}
+function bridgeAsset(evmChain, asset = "tao") {
+  if (asset !== "tao" && asset !== "sn80") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      'Asset must be "tao" or "sn80".'
+    );
+  }
+  if (asset === "sn80" && evmChain !== "base") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "SN80 bridging is supported between Base and Subtensor."
+    );
+  }
+  const evm = getForeverMoneyEvmDeployment(evmChain);
+  return asset === "sn80" ? {
+    evmToken: foreverMoneyDeployment.base.contracts.wrappedSn80,
+    subtensorToken: foreverMoneyDeployment.subtensor.contracts.wrappedSn80,
+    label: "SN80",
+    wrappedLabel: "SN80"
+  } : {
+    evmToken: evm.contracts.wrappedTao,
+    subtensorToken: foreverMoneyDeployment.subtensor.contracts.wrappedTao,
+    label: "TAO",
+    wrappedLabel: "wrapped TAO"
+  };
+}
+function assertAssetMode(asset, mode) {
+  if (asset === "sn80" && mode !== "staked") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "SN80 bridging requires staked subnet 80 input or delivery; liquid TAO conversion is not supported."
+    );
+  }
+}
+function sourceNetuid(input) {
+  if (input.source !== "staked") return void 0;
+  const netuid = input.netuid ?? (input.asset === "sn80" ? SN80_NETUID : void 0);
+  if (netuid === void 0) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "A netuid is required when bridging staked TAO."
+    );
+  }
+  assertNonNegativeAmount(netuid, "netuid");
+  if (input.asset === "sn80" && netuid !== SN80_NETUID) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "SN80 staking approvals must use netuid 80."
+    );
+  }
+  return netuid;
+}
 function assertDelivery(value) {
   if (value !== "liquid" && value !== "staked") {
     throw new ForeverMoneyError(
@@ -588,6 +727,19 @@ function assertBaseToSubtensorAmount(amountWei, delivery) {
     );
   }
 }
+function assertSubtensorToEvmAmount(amountWei, source) {
+  assertWholeRao(amountWei);
+  if (source === "liquid" && amountWei < MIN_LIQUID_SUBTENSOR_TO_EVM_WEI) {
+    throw new ForeverMoneyError(
+      "AMOUNT_BELOW_MINIMUM",
+      "Bridging liquid TAO from Subtensor requires at least 0.002 TAO.",
+      {
+        amountWei: amountWei.toString(),
+        minimumAmountWei: MIN_LIQUID_SUBTENSOR_TO_EVM_WEI.toString()
+      }
+    );
+  }
+}
 function transactionStep(kind, label, chainId, from, to, data, value, gasLimit) {
   return {
     kind,
@@ -602,9 +754,94 @@ function transactionStep(kind, label, chainId, from, to, data, value, gasLimit)
     }
   };
 }
+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) {
+  return fee.bps === 0 ? (0, import_viem6.encodeFunctionData)({
+    abi: spokeAbi,
+    functionName: "bridgeToFinney",
+    args: [token, amountWei, exit]
+  }) : (0, import_viem6.encodeFunctionData)({
+    abi: spokeAbi,
+    functionName: "bridgeToFinneyWithFee",
+    args: [token, amountWei, exit, 0n, fee]
+  });
+}
+function encodeHubBridge(destSelector, token, recipient, taoAmount, stakedAlphaRao, minTokenOut, fee) {
+  const args = [
+    destSelector,
+    token,
+    recipient,
+    taoAmount,
+    stakedAlphaRao,
+    minTokenOut
+  ];
+  return fee.bps === 0 ? (0, import_viem6.encodeFunctionData)({
+    abi: alphaAbi,
+    functionName: "bridgeOut",
+    args
+  }) : (0, import_viem6.encodeFunctionData)({
+    abi: alphaAbi,
+    functionName: "bridgeOutWithFee",
+    args: [...args, fee]
+  });
+}
+async function quoteSpokeWithFee(provider, gateway, token, amountWei, exit, fee) {
+  const maxBps = await provider.readContract({
+    address: gateway,
+    abi: spokeAbi,
+    functionName: "maxIntegratorFeeBps"
+  });
+  assertPartnerFeeAllowed(fee, maxBps);
+  const [networkFee] = await provider.readContract({
+    address: gateway,
+    abi: spokeAbi,
+    functionName: "quoteBridgeToFinneyWithFee",
+    args: [token, amountWei, exit, 0n, fee]
+  });
+  return networkFee;
+}
+async function quoteHubWithFee(provider, gateway, destSelector, token, recipient, mintedAmount, taoAmount, stakedAlphaRao, fee) {
+  const maxBps = await provider.readContract({
+    address: gateway,
+    abi: alphaAbi,
+    functionName: "maxIntegratorFeeBps"
+  });
+  assertPartnerFeeAllowed(fee, maxBps);
+  const [networkFee, taoTopUp, alphaTopUpRao, crossing] = await provider.readContract({
+    address: gateway,
+    abi: alphaAbi,
+    functionName: "quoteBridgeOutWithFee",
+    args: [
+      destSelector,
+      token,
+      recipient,
+      mintedAmount,
+      taoAmount,
+      stakedAlphaRao,
+      fee
+    ]
+  });
+  if (crossing !== mintedAmount || taoTopUp !== partnerFeeTaoTopUp(taoAmount, fee.bps) || alphaTopUpRao !== partnerFeeCut(stakedAlphaRao, fee.bps)) {
+    throw new ForeverMoneyError(
+      "INVALID_PROVIDER_RESPONSE",
+      "The gateway partner fee quote does not match the SDK fee calculation.",
+      {
+        crossing: crossing.toString(),
+        taoTopUp: taoTopUp.toString(),
+        alphaTopUpRao: alphaTopUpRao.toString()
+      }
+    );
+  }
+  return { networkFee, taoTopUp, alphaTopUpRao };
+}
 function buildEvmToSubtensorPlan(input) {
   const sender = normalizeEvmAddress(input.sender);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertDelivery(input.delivery);
+  assertAssetMode(input.asset, input.delivery);
   assertBaseToSubtensorAmount(input.amountWei, input.delivery);
   assertNonNegativeAmount(input.allowanceWei, "Token allowance");
   assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
@@ -616,19 +853,25 @@ function buildEvmToSubtensorPlan(input) {
     minTaoOut: input.amountWei
   };
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    evm.contracts.gateway
+  );
+  const cut = partnerFeeCut(input.amountWei, partnerFee.bps);
   const steps = [];
-  if (input.allowanceWei < input.amountWei) {
+  if (input.allowanceWei < input.amountWei + cut) {
     steps.push(
       transactionStep(
         "approval",
-        "Approve wrapped TAO for the ForeverMoney gateway",
+        `Approve ${asset.wrappedLabel} for the ForeverMoney gateway`,
         evm.chainId,
         sender,
-        evm.contracts.wrappedTao,
-        erc20Interface.encodeFunctionData("approve", [
-          evm.contracts.gateway,
-          input.amountWei
-        ]),
+        asset.evmToken,
+        (0, import_viem6.encodeFunctionData)({
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [evm.contracts.gateway, input.amountWei + cut]
+        }),
         0n
       )
     );
@@ -637,13 +880,15 @@ function buildEvmToSubtensorPlan(input) {
   steps.push(
     transactionStep(
       "transaction",
-      `Bridge wrapped TAO from ${evm.name} to Subtensor (${input.delivery})`,
+      `Bridge ${asset.wrappedLabel} from ${evm.name} to Subtensor (${input.delivery})`,
       evm.chainId,
       sender,
       evm.contracts.gateway,
-      spokeInterface.encodeFunctionData(
-        "bridgeToFinney(address,uint256,(bytes32,address,bool,uint256))",
-        [evm.contracts.wrappedTao, input.amountWei, exit]
+      encodeSpokeBridge(
+        asset.evmToken,
+        input.amountWei,
+        exit,
+        partnerFee
       ),
       value,
       input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
@@ -651,7 +896,7 @@ function buildEvmToSubtensorPlan(input) {
   );
   return createTransactionPlan({
     action: evm.key === "base" ? "bridge.base-to-subtensor" : "bridge.robinhood-to-subtensor",
-    summary: `Bridge ${input.amountWei} wei of wrapped TAO from ${evm.name} to ${destination}.`,
+    summary: `Bridge ${input.amountWei} wei of ${asset.wrappedLabel} from ${evm.name} to ${destination}.${partnerFeeSummary(cut, asset.wrappedLabel, partnerFee)}`,
     steps
   });
 }
@@ -661,21 +906,23 @@ function buildBaseToSubtensorPlan(input) {
 function buildSubtensorToEvmPlan(input) {
   const sender = normalizeEvmAddress(input.sender);
   const recipient = normalizeEvmAddress(input.recipient);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertSource(input.source);
-  assertWholeRao(input.amountWei);
+  assertAssetMode(input.asset, input.source);
+  const netuid = sourceNetuid(input);
+  assertSubtensorToEvmAmount(input.amountWei, input.source);
   assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    subtensor.contracts.gateway
+  );
   const amountRao = input.amountWei / EVM_WEI_PER_RAO;
+  const alphaTopUpRao = input.source === "staked" ? partnerFeeCut(amountRao, partnerFee.bps) : 0n;
+  const taoTopUp = input.source === "liquid" ? partnerFeeTaoTopUp(input.amountWei, partnerFee.bps) : 0n;
   const steps = [];
   if (input.source === "staked") {
-    if (input.netuid === void 0) {
-      throw new ForeverMoneyError(
-        "INVALID_TRANSACTION_PLAN",
-        "A netuid is required when bridging staked TAO."
-      );
-    }
-    assertNonNegativeAmount(input.netuid, "netuid");
     if (input.stakingAllowanceRao === void 0) {
       throw new ForeverMoneyError(
         "INVALID_TRANSACTION_PLAN",
@@ -683,19 +930,23 @@ function buildSubtensorToEvmPlan(input) {
       );
     }
     assertNonNegativeAmount(input.stakingAllowanceRao, "Staking allowance");
-    if (input.stakingAllowanceRao < amountRao) {
+    if (input.stakingAllowanceRao < amountRao + alphaTopUpRao) {
       steps.push(
         transactionStep(
           "approval",
-          "Approve staked TAO for the ForeverMoney gateway",
+          `Approve staked ${asset.label} for the ForeverMoney gateway`,
           subtensor.chainId,
           sender,
           subtensor.contracts.stakingPrecompile,
-          stakingInterface.encodeFunctionData("approve", [
-            subtensor.contracts.gateway,
-            input.netuid,
-            amountRao
-          ]),
+          (0, import_viem6.encodeFunctionData)({
+            abi: stakingAbi,
+            functionName: "approve",
+            args: [
+              subtensor.contracts.gateway,
+              netuid,
+              amountRao + alphaTopUpRao
+            ]
+          }),
           0n
         )
       );
@@ -708,30 +959,35 @@ function buildSubtensorToEvmPlan(input) {
   }
   const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
   const stakedAlphaRao = input.source === "staked" ? amountRao : 0n;
-  const value = taoAmount + feeWithBuffer(input.exactNetworkFeeWei);
+  const value = taoAmount + taoTopUp + feeWithBuffer(input.exactNetworkFeeWei);
   assertNonNegativeAmount(value, "Transaction value");
   steps.push(
     transactionStep(
       "transaction",
-      `Bridge ${input.source} TAO from Subtensor to ${evm.name}`,
+      `Bridge ${input.source} ${asset.label} from Subtensor to ${evm.name}`,
       subtensor.chainId,
       sender,
       subtensor.contracts.gateway,
-      alphaInterface.encodeFunctionData("bridgeOut", [
+      encodeHubBridge(
         evm.ccipSelector,
-        subtensor.contracts.wrappedTao,
+        asset.subtensorToken,
         recipient,
         taoAmount,
         stakedAlphaRao,
-        input.amountWei
-      ]),
+        input.amountWei,
+        partnerFee
+      ),
       value,
       input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
     )
   );
   return createTransactionPlan({
     action: evm.key === "base" ? "bridge.subtensor-to-base" : "bridge.subtensor-to-robinhood",
-    summary: `Bridge ${input.amountWei} wei of ${input.source} TAO from Subtensor to ${recipient} on ${evm.name}.`,
+    summary: `Bridge ${input.amountWei} wei of ${input.source} ${asset.label} from Subtensor to ${recipient} on ${evm.name}.${partnerFeeSummary(
+      input.source === "liquid" ? taoTopUp : alphaTopUpRao * EVM_WEI_PER_RAO,
+      input.source === "liquid" ? "TAO" : `staked ${asset.label}`,
+      partnerFee
+    )}`,
     steps
   });
 }
@@ -740,7 +996,9 @@ function buildSubtensorToBasePlan(input) {
 }
 async function prepareEvmToSubtensor(provider, input) {
   const sender = normalizeEvmAddress(input.sender);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertDelivery(input.delivery);
+  assertAssetMode(input.asset, input.delivery);
   assertBaseToSubtensorAmount(input.amountWei, input.delivery);
   const destination = normalizeSS58(input.destination);
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
@@ -750,29 +1008,42 @@ async function prepareEvmToSubtensor(provider, input) {
     wantLiquid: input.delivery === "liquid",
     minTaoOut: input.amountWei
   };
-  const token = new import_ethers6.Contract(evm.contracts.wrappedTao, ERC20_ABI, provider);
-  const gateway = new import_ethers6.Contract(
-    evm.contracts.gateway,
-    SPOKE_GATEWAY_ABI,
-    provider
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    evm.contracts.gateway
   );
+  const cut = partnerFeeCut(input.amountWei, partnerFee.bps);
   const [allowanceWei, exactNetworkFeeWei] = await Promise.all([
-    token.getFunction("allowance")(
-      sender,
-      evm.contracts.gateway
-    ),
-    gateway.getFunction(
-      "quoteBridgeToFinney(address,uint256,(bytes32,address,bool,uint256))"
-    )(evm.contracts.wrappedTao, input.amountWei, exit)
+    provider.readContract({
+      address: asset.evmToken,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [sender, evm.contracts.gateway]
+    }),
+    partnerFee.bps === 0 ? provider.readContract({
+      address: evm.contracts.gateway,
+      abi: spokeAbi,
+      functionName: "quoteBridgeToFinney",
+      args: [asset.evmToken, input.amountWei, exit]
+    }) : quoteSpokeWithFee(
+      provider,
+      evm.contracts.gateway,
+      asset.evmToken,
+      input.amountWei,
+      exit,
+      partnerFee
+    )
   ]);
   let estimatedBridgeGas;
-  if (allowanceWei >= input.amountWei) {
-    const data = spokeInterface.encodeFunctionData(
-      "bridgeToFinney(address,uint256,(bytes32,address,bool,uint256))",
-      [evm.contracts.wrappedTao, input.amountWei, exit]
+  if (allowanceWei >= input.amountWei + cut) {
+    const data = encodeSpokeBridge(
+      asset.evmToken,
+      input.amountWei,
+      exit,
+      partnerFee
     );
     estimatedBridgeGas = await provider.estimateGas({
-      from: sender,
+      account: sender,
       to: evm.contracts.gateway,
       data,
       value: feeWithBuffer(exactNetworkFeeWei)
@@ -787,6 +1058,7 @@ async function prepareEvmToSubtensor(provider, input) {
   return Object.freeze({
     exactNetworkFeeWei,
     transactionValueWei: feeWithBuffer(exactNetworkFeeWei),
+    partnerFeeWei: cut,
     plan
   });
 }
@@ -796,58 +1068,67 @@ function prepareBaseToSubtensor(provider, input) {
 async function prepareSubtensorToEvm(provider, input) {
   const sender = normalizeEvmAddress(input.sender);
   const recipient = normalizeEvmAddress(input.recipient);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertSource(input.source);
-  assertWholeRao(input.amountWei);
+  assertAssetMode(input.asset, input.source);
+  const netuid = sourceNetuid(input);
+  assertSubtensorToEvmAmount(input.amountWei, input.source);
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
-  const gateway = new import_ethers6.Contract(
-    subtensor.contracts.gateway,
-    ALPHA_GATEWAY_ABI,
-    provider
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    subtensor.contracts.gateway
   );
-  const exactNetworkFeeWei = await gateway.getFunction("quoteBridgeOut")(
+  const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
+  const stakedAlphaRao = input.source === "staked" ? input.amountWei / EVM_WEI_PER_RAO : 0n;
+  const exactNetworkFeeWei = partnerFee.bps === 0 ? await provider.readContract({
+    address: subtensor.contracts.gateway,
+    abi: alphaAbi,
+    functionName: "quoteBridgeOut",
+    args: [
+      evm.ccipSelector,
+      asset.subtensorToken,
+      recipient,
+      input.amountWei
+    ]
+  }) : (await quoteHubWithFee(
+    provider,
+    subtensor.contracts.gateway,
     evm.ccipSelector,
-    subtensor.contracts.wrappedTao,
+    asset.subtensorToken,
     recipient,
-    input.amountWei
-  );
+    input.amountWei,
+    taoAmount,
+    stakedAlphaRao,
+    partnerFee
+  )).networkFee;
   let stakingAllowanceRao;
   if (input.source === "staked") {
-    if (input.netuid === void 0) {
-      throw new ForeverMoneyError(
-        "INVALID_TRANSACTION_PLAN",
-        "A netuid is required when bridging staked TAO."
-      );
-    }
-    assertNonNegativeAmount(input.netuid, "netuid");
-    const staking = new import_ethers6.Contract(
-      subtensor.contracts.stakingPrecompile,
-      STAKING_ABI,
-      provider
-    );
-    stakingAllowanceRao = await staking.getFunction("allowance")(
-      sender,
-      subtensor.contracts.gateway,
-      input.netuid
-    );
+    stakingAllowanceRao = await provider.readContract({
+      address: subtensor.contracts.stakingPrecompile,
+      abi: stakingAbi,
+      functionName: "allowance",
+      args: [sender, subtensor.contracts.gateway, netuid]
+    });
   }
-  const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
-  const stakedAlphaRao = input.source === "staked" ? input.amountWei / EVM_WEI_PER_RAO : 0n;
-  const value = taoAmount + feeWithBuffer(exactNetworkFeeWei);
+  const alphaTopUpRao = partnerFeeCut(stakedAlphaRao, partnerFee.bps);
+  const taoTopUp = partnerFeeTaoTopUp(taoAmount, partnerFee.bps);
+  const value = taoAmount + taoTopUp + feeWithBuffer(exactNetworkFeeWei);
   assertNonNegativeAmount(value, "Transaction value");
   let estimatedBridgeGas;
-  if (input.source === "liquid" || stakingAllowanceRao !== void 0 && stakingAllowanceRao >= stakedAlphaRao) {
+  if (input.source === "liquid" || stakingAllowanceRao !== void 0 && stakingAllowanceRao >= stakedAlphaRao + alphaTopUpRao) {
     estimatedBridgeGas = await provider.estimateGas({
-      from: sender,
+      account: sender,
       to: subtensor.contracts.gateway,
-      data: alphaInterface.encodeFunctionData("bridgeOut", [
+      data: encodeHubBridge(
         evm.ccipSelector,
-        subtensor.contracts.wrappedTao,
+        asset.subtensorToken,
         recipient,
         taoAmount,
         stakedAlphaRao,
-        input.amountWei
-      ]),
+        input.amountWei,
+        partnerFee
+      ),
       value
     });
   }
@@ -860,6 +1141,7 @@ async function prepareSubtensorToEvm(provider, input) {
   return Object.freeze({
     exactNetworkFeeWei,
     transactionValueWei: value,
+    partnerFeeWei: input.source === "liquid" ? taoTopUp : alphaTopUpRao * EVM_WEI_PER_RAO,
     plan
   });
 }
@@ -868,7 +1150,7 @@ function prepareSubtensorToBase(provider, input) {
 }
 
 // src/core/transport.ts
-var import_ethers7 = require("ethers");
+var import_viem7 = require("viem");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -987,10 +1269,38 @@ function providerFromTransport(transport) {
       "An EIP-1193-compatible RPC transport is required."
     );
   }
-  return new import_ethers7.BrowserProvider(transport);
+  return (0, import_viem7.createPublicClient)({
+    transport: (0, import_viem7.custom)(transport, { retryCount: 0 }),
+    cacheTime: 0,
+    batch: { multicall: false }
+  });
+}
+function trackingClient(provider) {
+  if (provider && "getChainId" in provider && typeof provider.getChainId === "function")
+    return provider;
+  if (provider && "send" in provider && typeof provider.send === "function") {
+    return providerFromTransport({
+      request: ({ method, params }) => {
+        if (params !== void 0 && !Array.isArray(params))
+          throw new ForeverMoneyError(
+            "RPC_ERROR",
+            "Tracking RPC params must be an array."
+          );
+        return provider.send(
+          method,
+          params === void 0 ? [] : [...params]
+        );
+      }
+    });
+  }
+  throw new ForeverMoneyError(
+    "MISSING_TRANSPORT",
+    "A viem public client or JSON-RPC provider is required."
+  );
 }
 
 // src/core/provider-errors.ts
+var import_viem8 = require("viem");
 function stringProperty(value, property) {
   if (typeof value !== "object" || value === null || !(property in value)) {
     return void 0;
@@ -1003,9 +1313,13 @@ async function providerOperation(operation, action) {
     return await action();
   } catch (error) {
     if (error instanceof ForeverMoneyError) throw error;
-    const causeCode = stringProperty(error, "code");
-    const reason = stringProperty(error, "reason");
-    const reverted = causeCode === "CALL_EXCEPTION";
+    const revert = error instanceof import_viem8.BaseError ? error.walk(
+      (cause) => cause instanceof import_viem8.ContractFunctionRevertedError || cause instanceof import_viem8.ExecutionRevertedError
+    ) : void 0;
+    const viemRevert = revert instanceof import_viem8.ContractFunctionRevertedError || revert instanceof import_viem8.ExecutionRevertedError;
+    const causeCode = viemRevert ? revert.name : stringProperty(error, "code");
+    const reason = viemRevert ? revert instanceof import_viem8.ContractFunctionRevertedError ? revert.data?.errorName ?? revert.reason : void 0 : stringProperty(error, "reason");
+    const reverted = viemRevert || causeCode === "CALL_EXCEPTION";
     throw new ForeverMoneyError(
       reverted ? "SIMULATION_REVERTED" : "RPC_ERROR",
       reverted ? `${operation} reverted.` : `${operation} failed.`,
@@ -1018,10 +1332,10 @@ async function providerOperation(operation, action) {
 }
 
 // src/vaults/plans.ts
-var import_ethers8 = require("ethers");
-var erc20Interface2 = new import_ethers8.Interface(ERC20_ABI);
-var factoryInterface = new import_ethers8.Interface(VAULT_FACTORY_ABI);
-var managerInterface = new import_ethers8.Interface(VAULT_MANAGER_ABI);
+var import_viem9 = require("viem");
+var erc20Abi2 = (0, import_viem9.parseAbi)(ERC20_ABI);
+var factoryAbi = (0, import_viem9.parseAbi)(VAULT_FACTORY_ABI);
+var managerAbi = (0, import_viem9.parseAbi)(VAULT_MANAGER_ABI);
 function step(kind, label, from, to, data, value = 0n) {
   return {
     kind,
@@ -1138,10 +1452,11 @@ function buildCreateVaultPlan(input) {
           `Approve ${stash.token} for the vault factory`,
           owner,
           stash.token,
-          erc20Interface2.encodeFunctionData("approve", [
-            base.contracts.vaultFactory,
-            stash.amount
-          ])
+          (0, import_viem9.encodeFunctionData)({
+            abi: erc20Abi2,
+            functionName: "approve",
+            args: [base.contracts.vaultFactory, stash.amount]
+          })
         )
       );
     }
@@ -1152,15 +1467,19 @@ function buildCreateVaultPlan(input) {
       "Create ForeverMoney vault",
       owner,
       base.contracts.vaultFactory,
-      factoryInterface.encodeFunctionData("create", [
-        owner,
-        associatedMiner,
-        akAddress,
-        poolManager,
-        poolAddress,
-        positionManagerImplementation,
-        stashTokens
-      ]),
+      (0, import_viem9.encodeFunctionData)({
+        abi: factoryAbi,
+        functionName: "create",
+        args: [
+          owner,
+          associatedMiner,
+          akAddress,
+          poolManager,
+          poolAddress,
+          positionManagerImplementation,
+          stashTokens
+        ]
+      }),
       value
     )
   );
@@ -1179,14 +1498,15 @@ async function prepareCreateVault(provider, input) {
   const allowances = await Promise.all(
     erc20Stash.map(async ({ token }) => ({
       token,
-      allowance: await new import_ethers8.Contract(
-        token,
-        ERC20_ABI,
-        provider
-      ).getFunction("allowance")(
-        owner,
-        foreverMoneyDeployment.base.contracts.vaultFactory
-      )
+      allowance: await provider.readContract({
+        address: token,
+        abi: erc20Abi2,
+        functionName: "allowance",
+        args: [
+          owner,
+          foreverMoneyDeployment.base.contracts.vaultFactory
+        ]
+      })
     }))
   );
   return buildCreateVaultPlan({ ...input, allowances });
@@ -1213,11 +1533,11 @@ function buildDepositVaultPlan(input) {
           "Deposit native ETH into the vault as WETH",
           owner,
           manager,
-          managerInterface.encodeFunctionData("topUpAk", [
-            akAddress,
-            import_ethers8.ZeroAddress,
-            deposit.amount
-          ]),
+          (0, import_viem9.encodeFunctionData)({
+            abi: managerAbi,
+            functionName: "topUpAk",
+            args: [akAddress, import_viem9.zeroAddress, deposit.amount]
+          }),
           deposit.amount
         )
       );
@@ -1237,10 +1557,11 @@ function buildDepositVaultPlan(input) {
           `Approve ${deposit.token} for the vault manager`,
           owner,
           deposit.token,
-          erc20Interface2.encodeFunctionData("approve", [
-            manager,
-            deposit.amount
-          ])
+          (0, import_viem9.encodeFunctionData)({
+            abi: erc20Abi2,
+            functionName: "approve",
+            args: [manager, deposit.amount]
+          })
         )
       );
     }
@@ -1250,11 +1571,11 @@ function buildDepositVaultPlan(input) {
         `Deposit ${deposit.token} into the vault`,
         owner,
         manager,
-        managerInterface.encodeFunctionData("topUpAk", [
-          akAddress,
-          deposit.token,
-          deposit.amount
-        ])
+        (0, import_viem9.encodeFunctionData)({
+          abi: managerAbi,
+          functionName: "topUpAk",
+          args: [akAddress, deposit.token, deposit.amount]
+        })
       )
     );
   }
@@ -1274,11 +1595,12 @@ async function prepareDepositVault(provider, input) {
   const allowances = await Promise.all(
     erc20Deposits.map(async ({ token }) => ({
       token,
-      allowance: await new import_ethers8.Contract(
-        token,
-        ERC20_ABI,
-        provider
-      ).getFunction("allowance")(owner, manager)
+      allowance: await provider.readContract({
+        address: token,
+        abi: erc20Abi2,
+        functionName: "allowance",
+        args: [owner, manager]
+      })
     }))
   );
   return buildDepositVaultPlan({ ...input, allowances });
@@ -1309,16 +1631,17 @@ function buildWithdrawVaultPlan(input) {
         "Withdraw assets from the vault",
         owner,
         manager,
-        managerInterface.encodeFunctionData(
-          "withdrawFromAkAndPositions",
-          [
+        (0, import_viem9.encodeFunctionData)({
+          abi: managerAbi,
+          functionName: "withdrawFromAkAndPositions",
+          args: [
             akAddress,
             input.amount0,
             input.amount1,
             input.decreaseTokenIds,
             input.unwrapWeth
           ]
-        )
+        })
       )
     ]
   });
@@ -1336,9 +1659,11 @@ function buildClaimVaultFeesPlan(input) {
         "Claim vault fees",
         owner,
         manager,
-        managerInterface.encodeFunctionData("claimFees(address)", [
-          akAddress
-        ])
+        (0, import_viem9.encodeFunctionData)({
+          abi: managerAbi,
+          functionName: "claimFees",
+          args: [akAddress]
+        })
       )
     ]
   });
@@ -1358,20 +1683,21 @@ function buildSetVaultStakingPlan(input) {
         `${input.staking ? "Stake" : "Unstake"} the vault position`,
         owner,
         manager,
-        managerInterface.encodeFunctionData(
-          `${action}(address,bytes)`,
-          [akAddress, "0x"]
-        )
+        (0, import_viem9.encodeFunctionData)({
+          abi: managerAbi,
+          functionName: action,
+          args: [akAddress, "0x"]
+        })
       )
     ]
   });
 }
 
 // src/bridge/tracking.ts
-var import_ethers10 = require("ethers");
+var import_viem11 = require("viem");
 
 // src/bridge/receipts.ts
-var import_ethers9 = require("ethers");
+var import_viem10 = require("viem");
 
 // src/core/receipts.ts
 function isLogFrom(log, address) {
@@ -1379,8 +1705,8 @@ function isLogFrom(log, address) {
 }
 
 // src/bridge/receipts.ts
-var alphaGatewayInterface = new import_ethers9.Interface(ALPHA_GATEWAY_ABI);
-var spokeGatewayInterface = new import_ethers9.Interface(SPOKE_GATEWAY_ABI);
+var alphaGatewayAbi = (0, import_viem10.parseAbi)(ALPHA_GATEWAY_ABI);
+var spokeGatewayAbi = (0, import_viem10.parseAbi)(SPOKE_GATEWAY_ABI);
 function assertBridgeDirection(value) {
   if (value !== "base-to-subtensor" && value !== "robinhood-to-subtensor" && value !== "subtensor-to-base" && value !== "subtensor-to-robinhood") {
     throw new ForeverMoneyError(
@@ -1403,20 +1729,28 @@ function bridgeMessageIdFromReceipt(direction, receipt) {
     evmChainFromBridgeDirection(direction)
   );
   const evmToSubtensor = isEvmToSubtensorDirection(direction);
-  const [address, contractInterface, eventName] = evmToSubtensor ? [evm.contracts.gateway, spokeGatewayInterface, "BridgedToFinney"] : [
-    foreverMoneyDeployment.subtensor.contracts.gateway,
-    alphaGatewayInterface,
+  const [addresses, contractAbi, eventName] = evmToSubtensor ? [
+    [evm.contracts.legacyGateway, evm.contracts.gateway],
+    spokeGatewayAbi,
+    "BridgedToFinney"
+  ] : [
+    [
+      foreverMoneyDeployment.subtensor.contracts.legacyGateway,
+      foreverMoneyDeployment.subtensor.contracts.gateway
+    ],
+    alphaGatewayAbi,
     "BridgedOut"
   ];
   for (const log of receipt.logs) {
-    if (!isLogFrom(log, address)) continue;
+    if (!addresses.some((address) => isLogFrom(log, address))) continue;
     try {
-      const parsed = contractInterface.parseLog({
+      const parsed = (0, import_viem10.decodeEventLog)({
+        abi: contractAbi,
         data: log.data,
         topics: [...log.topics]
       });
-      const messageId = parsed?.args.messageId;
-      if (parsed?.name === eventName && typeof messageId === "string" && (0, import_ethers9.isHexString)(messageId, 32) && (evmToSubtensor || parsed.args.destChainSelector === evm.ccipSelector)) {
+      const messageId = "messageId" in parsed.args ? parsed.args.messageId : void 0;
+      if (parsed.eventName === eventName && typeof messageId === "string" && (0, import_viem10.isHex)(messageId, { strict: true }) && messageId.length === 66 && (evmToSubtensor || "destChainSelector" in parsed.args && parsed.args.destChainSelector === evm.ccipSelector)) {
         return messageId.toLowerCase();
       }
     } catch {
@@ -1426,8 +1760,8 @@ function bridgeMessageIdFromReceipt(direction, receipt) {
 }
 
 // src/bridge/tracking.ts
-var ccipExecutionInterface = new import_ethers10.Interface(CCIP_EXECUTION_ABI);
-var alphaGatewayInterface2 = new import_ethers10.Interface(ALPHA_GATEWAY_ABI);
+var ccipExecutionAbi = (0, import_viem11.parseAbi)(CCIP_EXECUTION_ABI);
+var alphaGatewayAbi2 = (0, import_viem11.parseAbi)(ALPHA_GATEWAY_ABI);
 function destinationChainId(direction) {
   assertBridgeDirection(direction);
   const evm = getForeverMoneyEvmDeployment(
@@ -1443,14 +1777,14 @@ function sourceChainId(direction) {
   return isEvmToSubtensorDirection(direction) ? evm.chainId : foreverMoneyDeployment.subtensor.chainId;
 }
 async function assertProviderChain(provider, expectedChainId, label) {
-  const network = await provider.getNetwork();
-  if (network.chainId !== BigInt(expectedChainId)) {
+  const chainId = await provider.getChainId();
+  if (chainId !== expectedChainId) {
     throw new ForeverMoneyError(
       "CHAIN_MISMATCH",
-      `${label} transport reported chain ID ${network.chainId}; expected ${expectedChainId}.`,
+      `${label} transport reported chain ID ${chainId}; expected ${expectedChainId}.`,
       {
         expectedChainId,
-        actualChainId: network.chainId.toString()
+        actualChainId: chainId.toString()
       }
     );
   }
@@ -1461,13 +1795,14 @@ async function assertDestinationProvider(provider, direction) {
   return expectedChainId;
 }
 async function getBridgeSourceStatus(provider, input) {
+  const client = trackingClient(provider);
   const expectedChainId = sourceChainId(input.direction);
   const transactionHash = normalizeBytes32(
     input.transactionHash,
     "Transaction hash"
   );
-  await assertProviderChain(provider, expectedChainId, "Bridge source");
-  const receipt = await provider.getTransactionReceipt(transactionHash);
+  await assertProviderChain(client, expectedChainId, "Bridge source");
+  const receipt = await receiptOrNull(client, transactionHash);
   if (receipt === null) {
     return Object.freeze({
       direction: input.direction,
@@ -1477,7 +1812,7 @@ async function getBridgeSourceStatus(provider, input) {
       messageId: null
     });
   }
-  if (receipt.status === 0) {
+  if (receipt.status === "reverted") {
     return Object.freeze({
       direction: input.direction,
       sourceChainId: expectedChainId,
@@ -1486,7 +1821,7 @@ async function getBridgeSourceStatus(provider, input) {
       messageId: null
     });
   }
-  if (receipt.status !== 1) {
+  if (receipt.status !== "success") {
     throw new ForeverMoneyError(
       "INVALID_PROVIDER_RESPONSE",
       "The bridge source receipt has an invalid status."
@@ -1508,8 +1843,10 @@ async function getBridgeSourceStatus(provider, input) {
   });
 }
 async function getCcipDeliveryCheckpoint(provider, direction) {
-  const expectedChainId = await assertDestinationProvider(provider, direction);
-  const fromBlock = await provider.getBlockNumber();
+  const client = trackingClient(provider);
+  const expectedChainId = await assertDestinationProvider(client, direction);
+  const blockNumber = await client.getBlockNumber({ cacheTime: 0 });
+  const fromBlock = Number(blockNumber);
   if (!Number.isSafeInteger(fromBlock) || fromBlock < 0) {
     throw new ForeverMoneyError(
       "INVALID_PROVIDER_RESPONSE",
@@ -1523,6 +1860,7 @@ async function getCcipDeliveryCheckpoint(provider, direction) {
   });
 }
 async function getCcipDeliveryStatus(provider, input) {
+  const client = trackingClient(provider);
   const expectedChainId = destinationChainId(input.direction);
   const messageId = normalizeBytes32(input.messageId, "CCIP message ID");
   if (!Number.isSafeInteger(input.fromBlock) || input.fromBlock < 0) {
@@ -1531,42 +1869,50 @@ async function getCcipDeliveryStatus(provider, input) {
       "CCIP fromBlock must be a non-negative safe integer."
     );
   }
-  await assertProviderChain(provider, expectedChainId, "Bridge destination");
-  const event = ccipExecutionInterface.getEvent("ExecutionStateChanged");
-  if (event === null) {
-    throw new Error("CCIP execution event is missing from the SDK ABI.");
-  }
+  await assertProviderChain(client, expectedChainId, "Bridge destination");
   const evmChain = evmChainFromBridgeDirection(input.direction);
   const evm = getForeverMoneyEvmDeployment(evmChain);
   const evmToSubtensor = isEvmToSubtensorDirection(input.direction);
   const sourceSelector = evmToSubtensor ? evm.ccipSelector : foreverMoneyDeployment.subtensor.ccipSelector;
   const offRamp = evmToSubtensor ? evmChain === "base" ? foreverMoneyDeployment.subtensor.contracts.ccipOffRampFromBase : foreverMoneyDeployment.subtensor.contracts.ccipOffRampFromRobinhood : evm.contracts.ccipOffRampFromSubtensor;
-  const logs = await provider.getLogs({
+  const logs = await client.getLogs({
     address: offRamp,
-    fromBlock: input.fromBlock,
+    fromBlock: BigInt(input.fromBlock),
     toBlock: "latest",
-    topics: [event.topicHash, (0, import_ethers10.toBeHex)(sourceSelector, 32), null, messageId]
+    event: ccipExecutionAbi[0],
+    args: { sourceChainSelector: sourceSelector, messageId },
+    strict: true
   });
   const latest = logs.at(-1);
   if (latest === void 0) return "waiting";
-  const parsed = ccipExecutionInterface.parseLog(latest);
-  const state = Number(parsed?.args.state);
+  const state = latest.args.state;
   if (state === 3) return "failure";
   if (state !== 2) return "waiting";
   if (!evmToSubtensor) return "success";
-  const receipt = await provider.getTransactionReceipt(latest.transactionHash);
+  const receipt = await receiptOrNull(client, latest.transactionHash);
   if (receipt === null) {
     throw new ForeverMoneyError(
       "INVALID_PROVIDER_RESPONSE",
       "The CCIP execution receipt is unavailable."
     );
   }
+  const subtensorGateways = [
+    foreverMoneyDeployment.subtensor.contracts.legacyGateway,
+    foreverMoneyDeployment.subtensor.contracts.gateway
+  ];
   for (const log of receipt.logs) {
-    if (log.address.toLowerCase() !== foreverMoneyDeployment.subtensor.contracts.gateway.toLowerCase()) {
+    if (!subtensorGateways.some(
+      (gateway) => log.address.toLowerCase() === gateway.toLowerCase()
+    )) {
       continue;
     }
     try {
-      if (alphaGatewayInterface2.parseLog(log)?.name === "Claimable") {
+      const { eventName } = (0, import_viem11.decodeEventLog)({
+        abi: alphaGatewayAbi2,
+        data: log.data,
+        topics: log.topics
+      });
+      if (eventName === "Claimable" || eventName === "NotDelivered") {
         return "recovery";
       }
     } catch {
@@ -1574,20 +1920,28 @@ async function getCcipDeliveryStatus(provider, input) {
   }
   return "success";
 }
+async function receiptOrNull(provider, hash) {
+  try {
+    return await provider.getTransactionReceipt({ hash });
+  } catch (error) {
+    if (error instanceof import_viem11.TransactionReceiptNotFoundError) return null;
+    throw error;
+  }
+}
 
 // src/client.ts
 async function assertProviderChain2(provider, expectedChainId, name) {
-  const network = await providerOperation(
+  const chainId = await providerOperation(
     `Reading the ${name} chain ID`,
-    () => provider.getNetwork()
+    () => provider.getChainId()
   );
-  if (network.chainId !== BigInt(expectedChainId)) {
+  if (chainId !== expectedChainId) {
     throw new ForeverMoneyError(
       "CHAIN_MISMATCH",
-      `${name} transport reported chain ID ${network.chainId}; expected ${expectedChainId}.`,
+      `${name} transport reported chain ID ${chainId}; expected ${expectedChainId}.`,
       {
         expectedChainId,
-        actualChainId: network.chainId.toString()
+        actualChainId: chainId.toString()
       }
     );
   }
@@ -1719,19 +2073,20 @@ function createForeverMoneyClient(options) {
 }
 
 // src/vaults/receipts.ts
-var import_ethers11 = require("ethers");
-var vaultFactoryInterface = new import_ethers11.Interface(VAULT_FACTORY_ABI);
+var import_viem12 = require("viem");
+var vaultFactoryAbi = (0, import_viem12.parseAbi)(VAULT_FACTORY_ABI);
 function vaultManagerFromCreationReceipt(receipt) {
   for (const log of receipt.logs) {
     if (!isLogFrom(log, foreverMoneyDeployment.base.contracts.vaultFactory)) {
       continue;
     }
     try {
-      const parsed = vaultFactoryInterface.parseLog({
+      const parsed = (0, import_viem12.decodeEventLog)({
+        abi: vaultFactoryAbi,
         data: log.data,
         topics: [...log.topics]
       });
-      if (parsed?.name === "SnLiquidityManagerCreated") {
+      if (parsed.eventName === "SnLiquidityManagerCreated") {
         return normalizeEvmAddress(String(parsed.args.manager));
       }
     } catch {
@@ -1741,7 +2096,7 @@ function vaultManagerFromCreationReceipt(receipt) {
 }
 
 // src/core/transactions.ts
-var import_ethers12 = require("ethers");
+var import_viem13 = require("viem");
 function decimalQuantity(value, label) {
   if (!/^(0|[1-9][0-9]*)$/.test(value)) {
     throw new ForeverMoneyError(
@@ -1750,7 +2105,7 @@ function decimalQuantity(value, label) {
     );
   }
   const quantity = BigInt(value);
-  if (quantity > import_ethers12.MaxUint256) {
+  if (quantity > import_viem13.maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       `${label} exceeds uint256.`
@@ -1786,4 +2141,50 @@ function toEthersTransaction(transaction) {
     }
   });
 }
+var transactionChains = new Map(
+  [
+    [BASE_CHAIN_ID, "Base", "Ether", "ETH"],
+    [ROBINHOOD_CHAIN_ID, "Robinhood", "Ether", "ETH"],
+    [SUBTENSOR_CHAIN_ID, "Subtensor", "TAO", "TAO"]
+  ].map(([id, name, currency, symbol]) => [
+    id,
+    Object.freeze(
+      (0, import_viem13.defineChain)({
+        id,
+        name,
+        nativeCurrency: Object.freeze({
+          name: currency,
+          symbol,
+          decimals: 18
+        }),
+        // Chain identity only. The caller retains ownership of the wallet transport.
+        rpcUrls: Object.freeze({
+          default: Object.freeze({ http: Object.freeze([]) })
+        })
+      })
+    )
+  ])
+);
+function toViemTransaction(transaction) {
+  const chain = transactionChains.get(transaction.chainId);
+  if (!chain)
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "Unsupported transaction chain."
+    );
+  return Object.freeze({
+    chain,
+    account: transaction.from,
+    chainId: transaction.chainId,
+    to: transaction.to,
+    data: transaction.data,
+    value: decimalQuantity(transaction.value, "Transaction value"),
+    ...transaction.gasLimit === void 0 ? {} : {
+      gas: decimalQuantity(
+        transaction.gasLimit,
+        "Transaction gas limit"
+      )
+    }
+  });
+}
 //# sourceMappingURL=index.cjs.map