@forevermoney/sdk 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -69,14 +69,14 @@ __export(index_exports, {
   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 +93,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 +129,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 +140,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;
@@ -154,26 +165,26 @@ 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)("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C"),
+      wrappedTao: (0, import_viem2.getAddress)(
         "0xf3081494b87e8d5fb7960f066e931d1d0e6e3d67"
       ),
-      ccipRouter: (0, import_ethers2.getAddress)(
+      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 +194,14 @@ 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)("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 +210,23 @@ 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)("0x998f20Fea90bF7792774dECc7f994716442B1705"),
+      alphaVault: (0, import_viem2.getAddress)(
         "0x11837459896D96F821a8D88eC93a3C8D152033D4"
       ),
-      wrappedTao: (0, import_ethers2.getAddress)(
+      wrappedTao: (0, import_viem2.getAddress)(
         "0xC5b6C1632d34901239396F5E1BDe54B342900256"
       ),
-      ccipRouter: (0, import_ethers2.getAddress)(
+      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 +256,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 +285,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 +311,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 +323,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 +347,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 +373,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."
@@ -445,10 +457,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 +477,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 +505,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 +520,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 +552,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,14 +561,14 @@ 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;
 function assertDelivery(value) {
@@ -625,10 +637,11 @@ function buildEvmToSubtensorPlan(input) {
         evm.chainId,
         sender,
         evm.contracts.wrappedTao,
-        erc20Interface.encodeFunctionData("approve", [
-          evm.contracts.gateway,
-          input.amountWei
-        ]),
+        (0, import_viem6.encodeFunctionData)({
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [evm.contracts.gateway, input.amountWei]
+        }),
         0n
       )
     );
@@ -641,10 +654,11 @@ function buildEvmToSubtensorPlan(input) {
       evm.chainId,
       sender,
       evm.contracts.gateway,
-      spokeInterface.encodeFunctionData(
-        "bridgeToFinney(address,uint256,(bytes32,address,bool,uint256))",
-        [evm.contracts.wrappedTao, input.amountWei, exit]
-      ),
+      (0, import_viem6.encodeFunctionData)({
+        abi: spokeAbi,
+        functionName: "bridgeToFinney",
+        args: [evm.contracts.wrappedTao, input.amountWei, exit]
+      }),
       value,
       input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
     )
@@ -691,11 +705,15 @@ function buildSubtensorToEvmPlan(input) {
           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,
+              input.netuid,
+              amountRao
+            ]
+          }),
           0n
         )
       );
@@ -717,14 +735,18 @@ function buildSubtensorToEvmPlan(input) {
       subtensor.chainId,
       sender,
       subtensor.contracts.gateway,
-      alphaInterface.encodeFunctionData("bridgeOut", [
-        evm.ccipSelector,
-        subtensor.contracts.wrappedTao,
-        recipient,
-        taoAmount,
-        stakedAlphaRao,
-        input.amountWei
-      ]),
+      (0, import_viem6.encodeFunctionData)({
+        abi: alphaAbi,
+        functionName: "bridgeOut",
+        args: [
+          evm.ccipSelector,
+          subtensor.contracts.wrappedTao,
+          recipient,
+          taoAmount,
+          stakedAlphaRao,
+          input.amountWei
+        ]
+      }),
       value,
       input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
     )
@@ -750,29 +772,29 @@ 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 [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: evm.contracts.wrappedTao,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [sender, evm.contracts.gateway]
+    }),
+    provider.readContract({
+      address: evm.contracts.gateway,
+      abi: spokeAbi,
+      functionName: "quoteBridgeToFinney",
+      args: [evm.contracts.wrappedTao, input.amountWei, exit]
+    })
   ]);
   let estimatedBridgeGas;
   if (allowanceWei >= input.amountWei) {
-    const data = spokeInterface.encodeFunctionData(
-      "bridgeToFinney(address,uint256,(bytes32,address,bool,uint256))",
-      [evm.contracts.wrappedTao, input.amountWei, exit]
-    );
+    const data = (0, import_viem6.encodeFunctionData)({
+      abi: spokeAbi,
+      functionName: "bridgeToFinney",
+      args: [evm.contracts.wrappedTao, input.amountWei, exit]
+    });
     estimatedBridgeGas = await provider.estimateGas({
-      from: sender,
+      account: sender,
       to: evm.contracts.gateway,
       data,
       value: feeWithBuffer(exactNetworkFeeWei)
@@ -800,17 +822,17 @@ async function prepareSubtensorToEvm(provider, input) {
   assertWholeRao(input.amountWei);
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
-  const gateway = new import_ethers6.Contract(
-    subtensor.contracts.gateway,
-    ALPHA_GATEWAY_ABI,
-    provider
-  );
-  const exactNetworkFeeWei = await gateway.getFunction("quoteBridgeOut")(
-    evm.ccipSelector,
-    subtensor.contracts.wrappedTao,
-    recipient,
-    input.amountWei
-  );
+  const exactNetworkFeeWei = await provider.readContract({
+    address: subtensor.contracts.gateway,
+    abi: alphaAbi,
+    functionName: "quoteBridgeOut",
+    args: [
+      evm.ccipSelector,
+      subtensor.contracts.wrappedTao,
+      recipient,
+      input.amountWei
+    ]
+  });
   let stakingAllowanceRao;
   if (input.source === "staked") {
     if (input.netuid === void 0) {
@@ -820,16 +842,12 @@ async function prepareSubtensorToEvm(provider, input) {
       );
     }
     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, input.netuid]
+    });
   }
   const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
   const stakedAlphaRao = input.source === "staked" ? input.amountWei / EVM_WEI_PER_RAO : 0n;
@@ -838,16 +856,20 @@ async function prepareSubtensorToEvm(provider, input) {
   let estimatedBridgeGas;
   if (input.source === "liquid" || stakingAllowanceRao !== void 0 && stakingAllowanceRao >= stakedAlphaRao) {
     estimatedBridgeGas = await provider.estimateGas({
-      from: sender,
+      account: sender,
       to: subtensor.contracts.gateway,
-      data: alphaInterface.encodeFunctionData("bridgeOut", [
-        evm.ccipSelector,
-        subtensor.contracts.wrappedTao,
-        recipient,
-        taoAmount,
-        stakedAlphaRao,
-        input.amountWei
-      ]),
+      data: (0, import_viem6.encodeFunctionData)({
+        abi: alphaAbi,
+        functionName: "bridgeOut",
+        args: [
+          evm.ccipSelector,
+          subtensor.contracts.wrappedTao,
+          recipient,
+          taoAmount,
+          stakedAlphaRao,
+          input.amountWei
+        ]
+      }),
       value
     });
   }
@@ -868,7 +890,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 +1009,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 +1053,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 +1072,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 +1192,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 +1207,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 +1238,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 +1273,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 +1297,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 +1311,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 +1335,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 +1371,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 +1399,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 +1423,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 +1445,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 +1469,21 @@ function bridgeMessageIdFromReceipt(direction, receipt) {
     evmChainFromBridgeDirection(direction)
   );
   const evmToSubtensor = isEvmToSubtensorDirection(direction);
-  const [address, contractInterface, eventName] = evmToSubtensor ? [evm.contracts.gateway, spokeGatewayInterface, "BridgedToFinney"] : [
+  const [address, contractAbi, eventName] = evmToSubtensor ? [evm.contracts.gateway, spokeGatewayAbi, "BridgedToFinney"] : [
     foreverMoneyDeployment.subtensor.contracts.gateway,
-    alphaGatewayInterface,
+    alphaGatewayAbi,
     "BridgedOut"
   ];
   for (const log of receipt.logs) {
     if (!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 +1493,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 +1510,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 +1528,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 +1545,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 +1554,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 +1576,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 +1593,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,30 +1602,27 @@ 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",
@@ -1566,7 +1634,11 @@ async function getCcipDeliveryStatus(provider, input) {
       continue;
     }
     try {
-      if (alphaGatewayInterface2.parseLog(log)?.name === "Claimable") {
+      if ((0, import_viem11.decodeEventLog)({
+        abi: alphaGatewayAbi2,
+        data: log.data,
+        topics: log.topics
+      }).eventName === "Claimable") {
         return "recovery";
       }
     } catch {
@@ -1574,20 +1646,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 +1799,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 +1822,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 +1831,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 +1867,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