@forevermoney/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,11 +1,18 @@
 // src/core/addresses.ts
-import { isHex, u8aToHex } from "@polkadot/util";
 import {
-  decodeAddress,
-  encodeAddress,
-  evmToAddress
-} from "@polkadot/util-crypto";
-import { ZeroAddress, getAddress, isAddress } from "ethers";
+  AccountId,
+  Blake2256,
+  getSs58AddressInfo
+} from "@polkadot-api/substrate-bindings";
+import {
+  bytesToHex,
+  concat,
+  getAddress,
+  hexToBytes,
+  isAddress,
+  stringToBytes,
+  zeroAddress
+} from "viem";
 
 // src/core/errors.ts
 var ForeverMoneyError = class extends Error {
@@ -22,22 +29,33 @@ var ForeverMoneyError = class extends Error {
 // src/core/addresses.ts
 var BITTENSOR_SS58_PREFIX = 42;
 function normalizeEvmAddress(value) {
-  if (!isAddress(value) || value === ZeroAddress) {
+  const candidate = typeof value === "string" && /^0x[0-9A-F]{40}$/.test(value) ? value.toLowerCase() : value;
+  if (!isAddress(candidate) || candidate === zeroAddress) {
     throw new ForeverMoneyError(
       "INVALID_ADDRESS",
       "Expected a non-zero EVM address."
     );
   }
-  return getAddress(value);
+  return getAddress(candidate);
 }
 function evmToMirrorSS58(evmAddress) {
-  return evmToAddress(normalizeEvmAddress(evmAddress), BITTENSOR_SS58_PREFIX);
+  return AccountId(BITTENSOR_SS58_PREFIX).dec(
+    Blake2256(
+      concat([
+        stringToBytes("evm:"),
+        hexToBytes(normalizeEvmAddress(evmAddress))
+      ])
+    )
+  );
 }
 function decodeBittensorAddress(value) {
   try {
-    if (!value || isHex(value)) throw new Error("Raw hex is not SS58.");
-    const publicKey = 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 = 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(
@@ -47,7 +65,7 @@ function decodeBittensorAddress(value) {
   }
 }
 function normalizeSS58(value) {
-  return encodeAddress(decodeBittensorAddress(value), BITTENSOR_SS58_PREFIX);
+  return AccountId(BITTENSOR_SS58_PREFIX).dec(decodeBittensorAddress(value));
 }
 function isBittensorSS58(value) {
   try {
@@ -58,14 +76,14 @@ function isBittensorSS58(value) {
   }
 }
 function ss58ToPublicKey(value) {
-  return u8aToHex(decodeBittensorAddress(value));
+  return bytesToHex(decodeBittensorAddress(value));
 }
 
 // src/core/amounts.ts
-import { MaxUint256, formatUnits, parseUnits } from "ethers";
+import { maxUint256, formatUnits, parseUnits } from "viem";
 
 // src/chains/deployment.ts
-import { getAddress as getAddress2 } from "ethers";
+import { getAddress as getAddress2 } from "viem";
 var BASE_CHAIN_ID = 8453;
 var ROBINHOOD_CHAIN_ID = 4663;
 var SUBTENSOR_CHAIN_ID = 964;
@@ -203,7 +221,7 @@ function assertWholeRao(amountWei) {
       "The amount cannot be negative."
     );
   }
-  if (amountWei > MaxUint256) {
+  if (amountWei > maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The amount exceeds uint256."
@@ -229,7 +247,7 @@ function formatTaoAmount(amountWei) {
       "A TAO amount cannot be negative."
     );
   }
-  if (amountWei > MaxUint256) {
+  if (amountWei > maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The TAO amount exceeds uint256."
@@ -241,7 +259,8 @@ function formatTaoAmount(amountWei) {
       "TAO amounts must resolve to a whole RAO."
     );
   }
-  return formatUnits(amountWei, 18);
+  const formatted = formatUnits(amountWei, 18);
+  return formatted.includes(".") ? formatted : `${formatted}.0`;
 }
 function mulDivCeil(value, numerator, denominator) {
   return (value * numerator + denominator - 1n) / denominator;
@@ -264,7 +283,7 @@ function feeWithBuffer(fee) {
     BASIS_POINTS + NETWORK_FEE_BUFFER_BPS,
     BASIS_POINTS
   );
-  if (buffered > MaxUint256) {
+  if (buffered > maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The buffered network fee exceeds uint256."
@@ -290,7 +309,7 @@ function gasLimitWithBuffer(gasLimit) {
     BASIS_POINTS + GAS_LIMIT_BUFFER_BPS,
     BASIS_POINTS
   );
-  if (buffered > MaxUint256) {
+  if (buffered > maxUint256) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       "The buffered gas limit exceeds uint256."
@@ -374,10 +393,10 @@ var foreverMoneyAbis = Object.freeze({
 });
 
 // src/bridge/plans.ts
-import { Contract, Interface } from "ethers";
+import { encodeFunctionData, parseAbi } from "viem";
 
 // src/core/plans.ts
-import { keccak256, toUtf8Bytes } from "ethers";
+import { keccak256, stringToBytes as stringToBytes2 } from "viem";
 function createTransactionPlan(plan) {
   const steps = plan.steps.map(
     (step2) => Object.freeze({
@@ -394,12 +413,12 @@ function createTransactionPlan(plan) {
   };
   return Object.freeze({
     ...versionedPlan,
-    hash: keccak256(toUtf8Bytes(JSON.stringify(versionedPlan)))
+    hash: keccak256(stringToBytes2(JSON.stringify(versionedPlan)))
   });
 }
 
 // src/core/validation.ts
-import { MaxUint256 as MaxUint2562, ZeroHash, isHexString } from "ethers";
+import { maxUint256 as maxUint2562, zeroHash, isHex } from "viem";
 function assertBigInt(amount, label) {
   if (typeof amount !== "bigint") {
     throw new ForeverMoneyError(
@@ -422,7 +441,7 @@ function assertPositiveAmount(amount, label) {
       `${label} cannot be negative.`
     );
   }
-  if (amount > MaxUint2562) {
+  if (amount > maxUint2562) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       `${label} exceeds uint256.`
@@ -437,7 +456,7 @@ function assertNonNegativeAmount(amount, label) {
       `${label} cannot be negative.`
     );
   }
-  if (amount > MaxUint2562) {
+  if (amount > maxUint2562) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       `${label} exceeds uint256.`
@@ -469,7 +488,7 @@ function assertRecord(value, label) {
   }
 }
 function normalizeBytes32(value, label) {
-  if (!isHexString(value, 32)) {
+  if (!isHex(value, { strict: true }) || value.length !== 66) {
     throw new ForeverMoneyError(
       "INVALID_BYTES32",
       `${label} must be a 32-byte hex value.`
@@ -478,14 +497,14 @@ function normalizeBytes32(value, label) {
   return value.toLowerCase();
 }
 function normalizeOptionalBytes32(value, label) {
-  return value === void 0 ? ZeroHash : normalizeBytes32(value, label);
+  return value === void 0 ? zeroHash : normalizeBytes32(value, label);
 }
 
 // src/bridge/plans.ts
-var erc20Interface = new Interface(ERC20_ABI);
-var spokeInterface = new Interface(SPOKE_GATEWAY_ABI);
-var alphaInterface = new Interface(ALPHA_GATEWAY_ABI);
-var stakingInterface = new Interface(STAKING_ABI);
+var erc20Abi = parseAbi(ERC20_ABI);
+var spokeAbi = parseAbi(SPOKE_GATEWAY_ABI);
+var alphaAbi = parseAbi(ALPHA_GATEWAY_ABI);
+var stakingAbi = parseAbi(STAKING_ABI);
 var MIN_LIQUID_EVM_TO_SUBTENSOR_WEI = 10000000000000000n;
 var MIN_LIQUID_BASE_TO_SUBTENSOR_WEI = MIN_LIQUID_EVM_TO_SUBTENSOR_WEI;
 function assertDelivery(value) {
@@ -554,10 +573,11 @@ function buildEvmToSubtensorPlan(input) {
         evm.chainId,
         sender,
         evm.contracts.wrappedTao,
-        erc20Interface.encodeFunctionData("approve", [
-          evm.contracts.gateway,
-          input.amountWei
-        ]),
+        encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [evm.contracts.gateway, input.amountWei]
+        }),
         0n
       )
     );
@@ -570,10 +590,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]
-      ),
+      encodeFunctionData({
+        abi: spokeAbi,
+        functionName: "bridgeToFinney",
+        args: [evm.contracts.wrappedTao, input.amountWei, exit]
+      }),
       value,
       input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
     )
@@ -620,11 +641,15 @@ function buildSubtensorToEvmPlan(input) {
           subtensor.chainId,
           sender,
           subtensor.contracts.stakingPrecompile,
-          stakingInterface.encodeFunctionData("approve", [
-            subtensor.contracts.gateway,
-            input.netuid,
-            amountRao
-          ]),
+          encodeFunctionData({
+            abi: stakingAbi,
+            functionName: "approve",
+            args: [
+              subtensor.contracts.gateway,
+              input.netuid,
+              amountRao
+            ]
+          }),
           0n
         )
       );
@@ -646,14 +671,18 @@ function buildSubtensorToEvmPlan(input) {
       subtensor.chainId,
       sender,
       subtensor.contracts.gateway,
-      alphaInterface.encodeFunctionData("bridgeOut", [
-        evm.ccipSelector,
-        subtensor.contracts.wrappedTao,
-        recipient,
-        taoAmount,
-        stakedAlphaRao,
-        input.amountWei
-      ]),
+      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)
     )
@@ -679,29 +708,29 @@ async function prepareEvmToSubtensor(provider, input) {
     wantLiquid: input.delivery === "liquid",
     minTaoOut: input.amountWei
   };
-  const token = new Contract(evm.contracts.wrappedTao, ERC20_ABI, provider);
-  const gateway = new 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 = 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)
@@ -729,17 +758,17 @@ async function prepareSubtensorToEvm(provider, input) {
   assertWholeRao(input.amountWei);
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
-  const gateway = new 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) {
@@ -749,16 +778,12 @@ async function prepareSubtensorToEvm(provider, input) {
       );
     }
     assertNonNegativeAmount(input.netuid, "netuid");
-    const staking = new 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;
@@ -767,16 +792,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: encodeFunctionData({
+        abi: alphaAbi,
+        functionName: "bridgeOut",
+        args: [
+          evm.ccipSelector,
+          subtensor.contracts.wrappedTao,
+          recipient,
+          taoAmount,
+          stakedAlphaRao,
+          input.amountWei
+        ]
+      }),
       value
     });
   }
@@ -797,7 +826,7 @@ function prepareSubtensorToBase(provider, input) {
 }
 
 // src/core/transport.ts
-import { BrowserProvider } from "ethers";
+import { createPublicClient, custom } from "viem";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -916,10 +945,42 @@ function providerFromTransport(transport) {
       "An EIP-1193-compatible RPC transport is required."
     );
   }
-  return new BrowserProvider(transport);
+  return createPublicClient({
+    transport: 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
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  ExecutionRevertedError
+} from "viem";
 function stringProperty(value, property) {
   if (typeof value !== "object" || value === null || !(property in value)) {
     return void 0;
@@ -932,9 +993,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 BaseError ? error.walk(
+      (cause) => cause instanceof ContractFunctionRevertedError || cause instanceof ExecutionRevertedError
+    ) : void 0;
+    const viemRevert = revert instanceof ContractFunctionRevertedError || revert instanceof ExecutionRevertedError;
+    const causeCode = viemRevert ? revert.name : stringProperty(error, "code");
+    const reason = viemRevert ? revert instanceof 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.`,
@@ -947,10 +1012,14 @@ async function providerOperation(operation, action) {
 }
 
 // src/vaults/plans.ts
-import { Contract as Contract2, Interface as Interface2, ZeroAddress as ZeroAddress2 } from "ethers";
-var erc20Interface2 = new Interface2(ERC20_ABI);
-var factoryInterface = new Interface2(VAULT_FACTORY_ABI);
-var managerInterface = new Interface2(VAULT_MANAGER_ABI);
+import {
+  encodeFunctionData as encodeFunctionData2,
+  parseAbi as parseAbi2,
+  zeroAddress as zeroAddress2
+} from "viem";
+var erc20Abi2 = parseAbi2(ERC20_ABI);
+var factoryAbi = parseAbi2(VAULT_FACTORY_ABI);
+var managerAbi = parseAbi2(VAULT_MANAGER_ABI);
 function step(kind, label, from, to, data, value = 0n) {
   return {
     kind,
@@ -1067,10 +1136,11 @@ function buildCreateVaultPlan(input) {
           `Approve ${stash.token} for the vault factory`,
           owner,
           stash.token,
-          erc20Interface2.encodeFunctionData("approve", [
-            base.contracts.vaultFactory,
-            stash.amount
-          ])
+          encodeFunctionData2({
+            abi: erc20Abi2,
+            functionName: "approve",
+            args: [base.contracts.vaultFactory, stash.amount]
+          })
         )
       );
     }
@@ -1081,15 +1151,19 @@ function buildCreateVaultPlan(input) {
       "Create ForeverMoney vault",
       owner,
       base.contracts.vaultFactory,
-      factoryInterface.encodeFunctionData("create", [
-        owner,
-        associatedMiner,
-        akAddress,
-        poolManager,
-        poolAddress,
-        positionManagerImplementation,
-        stashTokens
-      ]),
+      encodeFunctionData2({
+        abi: factoryAbi,
+        functionName: "create",
+        args: [
+          owner,
+          associatedMiner,
+          akAddress,
+          poolManager,
+          poolAddress,
+          positionManagerImplementation,
+          stashTokens
+        ]
+      }),
       value
     )
   );
@@ -1108,14 +1182,15 @@ async function prepareCreateVault(provider, input) {
   const allowances = await Promise.all(
     erc20Stash.map(async ({ token }) => ({
       token,
-      allowance: await new Contract2(
-        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 });
@@ -1142,11 +1217,11 @@ function buildDepositVaultPlan(input) {
           "Deposit native ETH into the vault as WETH",
           owner,
           manager,
-          managerInterface.encodeFunctionData("topUpAk", [
-            akAddress,
-            ZeroAddress2,
-            deposit.amount
-          ]),
+          encodeFunctionData2({
+            abi: managerAbi,
+            functionName: "topUpAk",
+            args: [akAddress, zeroAddress2, deposit.amount]
+          }),
           deposit.amount
         )
       );
@@ -1166,10 +1241,11 @@ function buildDepositVaultPlan(input) {
           `Approve ${deposit.token} for the vault manager`,
           owner,
           deposit.token,
-          erc20Interface2.encodeFunctionData("approve", [
-            manager,
-            deposit.amount
-          ])
+          encodeFunctionData2({
+            abi: erc20Abi2,
+            functionName: "approve",
+            args: [manager, deposit.amount]
+          })
         )
       );
     }
@@ -1179,11 +1255,11 @@ function buildDepositVaultPlan(input) {
         `Deposit ${deposit.token} into the vault`,
         owner,
         manager,
-        managerInterface.encodeFunctionData("topUpAk", [
-          akAddress,
-          deposit.token,
-          deposit.amount
-        ])
+        encodeFunctionData2({
+          abi: managerAbi,
+          functionName: "topUpAk",
+          args: [akAddress, deposit.token, deposit.amount]
+        })
       )
     );
   }
@@ -1203,11 +1279,12 @@ async function prepareDepositVault(provider, input) {
   const allowances = await Promise.all(
     erc20Deposits.map(async ({ token }) => ({
       token,
-      allowance: await new Contract2(
-        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 });
@@ -1238,16 +1315,17 @@ function buildWithdrawVaultPlan(input) {
         "Withdraw assets from the vault",
         owner,
         manager,
-        managerInterface.encodeFunctionData(
-          "withdrawFromAkAndPositions",
-          [
+        encodeFunctionData2({
+          abi: managerAbi,
+          functionName: "withdrawFromAkAndPositions",
+          args: [
             akAddress,
             input.amount0,
             input.amount1,
             input.decreaseTokenIds,
             input.unwrapWeth
           ]
-        )
+        })
       )
     ]
   });
@@ -1265,9 +1343,11 @@ function buildClaimVaultFeesPlan(input) {
         "Claim vault fees",
         owner,
         manager,
-        managerInterface.encodeFunctionData("claimFees(address)", [
-          akAddress
-        ])
+        encodeFunctionData2({
+          abi: managerAbi,
+          functionName: "claimFees",
+          args: [akAddress]
+        })
       )
     ]
   });
@@ -1287,20 +1367,25 @@ function buildSetVaultStakingPlan(input) {
         `${input.staking ? "Stake" : "Unstake"} the vault position`,
         owner,
         manager,
-        managerInterface.encodeFunctionData(
-          `${action}(address,bytes)`,
-          [akAddress, "0x"]
-        )
+        encodeFunctionData2({
+          abi: managerAbi,
+          functionName: action,
+          args: [akAddress, "0x"]
+        })
       )
     ]
   });
 }
 
 // src/bridge/tracking.ts
-import { Interface as Interface4, toBeHex } from "ethers";
+import {
+  decodeEventLog as decodeEventLog2,
+  parseAbi as parseAbi4,
+  TransactionReceiptNotFoundError
+} from "viem";
 
 // src/bridge/receipts.ts
-import { Interface as Interface3, isHexString as isHexString2 } from "ethers";
+import { decodeEventLog, isHex as isHex2, parseAbi as parseAbi3 } from "viem";
 
 // src/core/receipts.ts
 function isLogFrom(log, address) {
@@ -1308,8 +1393,8 @@ function isLogFrom(log, address) {
 }
 
 // src/bridge/receipts.ts
-var alphaGatewayInterface = new Interface3(ALPHA_GATEWAY_ABI);
-var spokeGatewayInterface = new Interface3(SPOKE_GATEWAY_ABI);
+var alphaGatewayAbi = parseAbi3(ALPHA_GATEWAY_ABI);
+var spokeGatewayAbi = parseAbi3(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(
@@ -1332,20 +1417,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 = decodeEventLog({
+        abi: contractAbi,
         data: log.data,
         topics: [...log.topics]
       });
-      const messageId = parsed?.args.messageId;
-      if (parsed?.name === eventName && typeof messageId === "string" && isHexString2(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" && isHex2(messageId, { strict: true }) && messageId.length === 66 && (evmToSubtensor || "destChainSelector" in parsed.args && parsed.args.destChainSelector === evm.ccipSelector)) {
         return messageId.toLowerCase();
       }
     } catch {
@@ -1355,8 +1441,8 @@ function bridgeMessageIdFromReceipt(direction, receipt) {
 }
 
 // src/bridge/tracking.ts
-var ccipExecutionInterface = new Interface4(CCIP_EXECUTION_ABI);
-var alphaGatewayInterface2 = new Interface4(ALPHA_GATEWAY_ABI);
+var ccipExecutionAbi = parseAbi4(CCIP_EXECUTION_ABI);
+var alphaGatewayAbi2 = parseAbi4(ALPHA_GATEWAY_ABI);
 function destinationChainId(direction) {
   assertBridgeDirection(direction);
   const evm = getForeverMoneyEvmDeployment(
@@ -1372,14 +1458,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()
       }
     );
   }
@@ -1390,13 +1476,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,
@@ -1406,7 +1493,7 @@ async function getBridgeSourceStatus(provider, input) {
       messageId: null
     });
   }
-  if (receipt.status === 0) {
+  if (receipt.status === "reverted") {
     return Object.freeze({
       direction: input.direction,
       sourceChainId: expectedChainId,
@@ -1415,7 +1502,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."
@@ -1437,8 +1524,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",
@@ -1452,6 +1541,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) {
@@ -1460,30 +1550,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, 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",
@@ -1495,7 +1582,11 @@ async function getCcipDeliveryStatus(provider, input) {
       continue;
     }
     try {
-      if (alphaGatewayInterface2.parseLog(log)?.name === "Claimable") {
+      if (decodeEventLog2({
+        abi: alphaGatewayAbi2,
+        data: log.data,
+        topics: log.topics
+      }).eventName === "Claimable") {
         return "recovery";
       }
     } catch {
@@ -1503,20 +1594,28 @@ async function getCcipDeliveryStatus(provider, input) {
   }
   return "success";
 }
+async function receiptOrNull(provider, hash) {
+  try {
+    return await provider.getTransactionReceipt({ hash });
+  } catch (error) {
+    if (error instanceof 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()
       }
     );
   }
@@ -1648,19 +1747,20 @@ function createForeverMoneyClient(options) {
 }
 
 // src/vaults/receipts.ts
-import { Interface as Interface5 } from "ethers";
-var vaultFactoryInterface = new Interface5(VAULT_FACTORY_ABI);
+import { decodeEventLog as decodeEventLog3, parseAbi as parseAbi5 } from "viem";
+var vaultFactoryAbi = parseAbi5(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 = decodeEventLog3({
+        abi: vaultFactoryAbi,
         data: log.data,
         topics: [...log.topics]
       });
-      if (parsed?.name === "SnLiquidityManagerCreated") {
+      if (parsed.eventName === "SnLiquidityManagerCreated") {
         return normalizeEvmAddress(String(parsed.args.manager));
       }
     } catch {
@@ -1670,7 +1770,10 @@ function vaultManagerFromCreationReceipt(receipt) {
 }
 
 // src/core/transactions.ts
-import { MaxUint256 as MaxUint2563 } from "ethers";
+import {
+  defineChain,
+  maxUint256 as maxUint2563
+} from "viem";
 function decimalQuantity(value, label) {
   if (!/^(0|[1-9][0-9]*)$/.test(value)) {
     throw new ForeverMoneyError(
@@ -1679,7 +1782,7 @@ function decimalQuantity(value, label) {
     );
   }
   const quantity = BigInt(value);
-  if (quantity > MaxUint2563) {
+  if (quantity > maxUint2563) {
     throw new ForeverMoneyError(
       "INVALID_TRANSACTION_PLAN",
       `${label} exceeds uint256.`
@@ -1715,6 +1818,52 @@ 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(
+      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"
+      )
+    }
+  });
+}
 export {
   BASE_CCIP_SELECTOR,
   BASE_CHAIN_ID,
@@ -1765,6 +1914,7 @@ export {
   ss58ToPublicKey,
   toEip1193Transaction,
   toEthersTransaction,
+  toViemTransaction,
   vaultManagerFromCreationReceipt
 };
 //# sourceMappingURL=index.js.map