@forevermoney/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1770 @@
+// src/core/addresses.ts
+import { isHex, u8aToHex } from "@polkadot/util";
+import {
+  decodeAddress,
+  encodeAddress,
+  evmToAddress
+} from "@polkadot/util-crypto";
+import { ZeroAddress, getAddress, isAddress } from "ethers";
+
+// src/core/errors.ts
+var ForeverMoneyError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "ForeverMoneyError";
+    this.code = code;
+    this.details = details === void 0 ? void 0 : Object.freeze({ ...details });
+  }
+};
+
+// src/core/addresses.ts
+var BITTENSOR_SS58_PREFIX = 42;
+function normalizeEvmAddress(value) {
+  if (!isAddress(value) || value === ZeroAddress) {
+    throw new ForeverMoneyError(
+      "INVALID_ADDRESS",
+      "Expected a non-zero EVM address."
+    );
+  }
+  return getAddress(value);
+}
+function evmToMirrorSS58(evmAddress) {
+  return evmToAddress(normalizeEvmAddress(evmAddress), BITTENSOR_SS58_PREFIX);
+}
+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.");
+    return publicKey;
+  } catch {
+    throw new ForeverMoneyError(
+      "INVALID_SS58",
+      "Expected a Bittensor SS58 address with prefix 42."
+    );
+  }
+}
+function normalizeSS58(value) {
+  return encodeAddress(decodeBittensorAddress(value), BITTENSOR_SS58_PREFIX);
+}
+function isBittensorSS58(value) {
+  try {
+    decodeBittensorAddress(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ss58ToPublicKey(value) {
+  return u8aToHex(decodeBittensorAddress(value));
+}
+
+// src/core/amounts.ts
+import { MaxUint256, formatUnits, parseUnits } from "ethers";
+
+// src/chains/deployment.ts
+import { getAddress as getAddress2 } from "ethers";
+var BASE_CHAIN_ID = 8453;
+var ROBINHOOD_CHAIN_ID = 4663;
+var SUBTENSOR_CHAIN_ID = 964;
+var BASE_CCIP_SELECTOR = 15971525489660198786n;
+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 foreverMoneyDeployment = Object.freeze({
+  version: FOREVERMONEY_DEPLOYMENT_VERSION,
+  base: Object.freeze({
+    key: "base",
+    name: "Base",
+    chainId: BASE_CHAIN_ID,
+    ccipSelector: BASE_CCIP_SELECTOR,
+    contracts: Object.freeze({
+      gateway: getAddress2("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C"),
+      wrappedTao: getAddress2(
+        "0xf3081494b87e8d5fb7960f066e931d1d0e6e3d67"
+      ),
+      ccipRouter: getAddress2(
+        "0x881e3A65B4d4a04dD529061dd0071cf975F58bCD"
+      ),
+      ccipOffRampFromSubtensor: getAddress2(
+        "0xf09AFe78d3c7d359b334d7cB88995751F7eC5E13"
+      ),
+      vaultFactory: getAddress2(
+        "0x9b7F3c7aa335D8BF9f91741E541820466735F868"
+      ),
+      vaultManagerImplementation: getAddress2(
+        "0x235Ad8654fe3a1619a9892eBCaD9361F416168da"
+      ),
+      batchLiquidityManagerQuery: getAddress2(
+        "0xd117176C5E6809b68500995F59589A8c081565A5"
+      ),
+      weth: getAddress2("0x4200000000000000000000000000000000000006")
+    }),
+    deploymentBlock: 50098800
+  }),
+  robinhood: Object.freeze({
+    key: "robinhood",
+    name: "Robinhood",
+    chainId: ROBINHOOD_CHAIN_ID,
+    ccipSelector: ROBINHOOD_CCIP_SELECTOR,
+    contracts: Object.freeze({
+      gateway: getAddress2("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8"),
+      wrappedTao: getAddress2(
+        "0xf3081494B87e8D5fb7960f066E931D1D0e6E3d67"
+      ),
+      ccipRouter: getAddress2(
+        "0x06fC836cf9839B1cd891C440A0a45242DA6Ae1c9"
+      ),
+      ccipOffRampFromSubtensor: getAddress2(
+        "0xcDca5D374e46A6DDDab50bD2D9acB8c796eC35C3"
+      )
+    })
+  }),
+  subtensor: Object.freeze({
+    chainId: SUBTENSOR_CHAIN_ID,
+    ccipSelector: SUBTENSOR_CCIP_SELECTOR,
+    contracts: Object.freeze({
+      gateway: getAddress2("0x998f20Fea90bF7792774dECc7f994716442B1705"),
+      alphaVault: getAddress2(
+        "0x11837459896D96F821a8D88eC93a3C8D152033D4"
+      ),
+      wrappedTao: getAddress2(
+        "0xC5b6C1632d34901239396F5E1BDe54B342900256"
+      ),
+      ccipRouter: getAddress2(
+        "0xD941fBEcD2b971d0F54b4C34286C95faB52B60B8"
+      ),
+      ccipOffRampFromBase: getAddress2(
+        "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
+      ),
+      ccipOffRampFromRobinhood: getAddress2(
+        "0x51a6150400ed9F0Ae240F5D1b15E3b45Fc4339C7"
+      ),
+      stakingPrecompile: getAddress2(
+        "0x0000000000000000000000000000000000000805"
+      )
+    })
+  })
+});
+function getForeverMoneyEvmDeployment(chain = "base") {
+  return foreverMoneyDeployment[chain];
+}
+
+// src/core/amounts.ts
+var BASIS_POINTS = 10000n;
+var NETWORK_FEE_BUFFER_BPS = 200n;
+var GAS_LIMIT_BUFFER_BPS = 5000n;
+function parseTaoAmount(value) {
+  if (typeof value !== "string") {
+    throw new ForeverMoneyError(
+      "AMOUNT_NOT_WHOLE_RAO",
+      "TAO amounts must be decimal strings."
+    );
+  }
+  const decimalPlaces = value.includes(".") ? value.split(".")[1]?.length ?? 0 : 0;
+  if (decimalPlaces > 9) {
+    throw new ForeverMoneyError(
+      "AMOUNT_NOT_WHOLE_RAO",
+      "TAO amounts must be positive decimal strings with at most nine decimal places."
+    );
+  }
+  let amount;
+  try {
+    amount = parseUnits(value, 18);
+  } catch {
+    throw new ForeverMoneyError(
+      "AMOUNT_NOT_WHOLE_RAO",
+      "TAO amounts must be positive decimal strings with at most nine decimal places."
+    );
+  }
+  assertWholeRao(amount);
+  return amount;
+}
+function assertWholeRao(amountWei) {
+  if (typeof amountWei !== "bigint") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The amount must be a bigint."
+    );
+  }
+  if (amountWei === 0n) {
+    throw new ForeverMoneyError(
+      "AMOUNT_ZERO",
+      "The amount must be greater than zero."
+    );
+  }
+  if (amountWei < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The amount cannot be negative."
+    );
+  }
+  if (amountWei > MaxUint256) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The amount exceeds uint256."
+    );
+  }
+  if (amountWei % EVM_WEI_PER_RAO !== 0n) {
+    throw new ForeverMoneyError(
+      "AMOUNT_NOT_WHOLE_RAO",
+      "TAO amounts must resolve to a whole RAO."
+    );
+  }
+}
+function formatTaoAmount(amountWei) {
+  if (typeof amountWei !== "bigint") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The TAO amount must be a bigint."
+    );
+  }
+  if (amountWei < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "A TAO amount cannot be negative."
+    );
+  }
+  if (amountWei > MaxUint256) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The TAO amount exceeds uint256."
+    );
+  }
+  if (amountWei % EVM_WEI_PER_RAO !== 0n) {
+    throw new ForeverMoneyError(
+      "AMOUNT_NOT_WHOLE_RAO",
+      "TAO amounts must resolve to a whole RAO."
+    );
+  }
+  return formatUnits(amountWei, 18);
+}
+function mulDivCeil(value, numerator, denominator) {
+  return (value * numerator + denominator - 1n) / denominator;
+}
+function feeWithBuffer(fee) {
+  if (typeof fee !== "bigint") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The network fee must be a bigint."
+    );
+  }
+  if (fee < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "A network fee cannot be negative."
+    );
+  }
+  const buffered = mulDivCeil(
+    fee,
+    BASIS_POINTS + NETWORK_FEE_BUFFER_BPS,
+    BASIS_POINTS
+  );
+  if (buffered > MaxUint256) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The buffered network fee exceeds uint256."
+    );
+  }
+  return buffered;
+}
+function gasLimitWithBuffer(gasLimit) {
+  if (typeof gasLimit !== "bigint") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The gas limit must be a bigint."
+    );
+  }
+  if (gasLimit <= 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "A gas limit must be greater than zero."
+    );
+  }
+  const buffered = mulDivCeil(
+    gasLimit,
+    BASIS_POINTS + GAS_LIMIT_BUFFER_BPS,
+    BASIS_POINTS
+  );
+  if (buffered > MaxUint256) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "The buffered gas limit exceeds uint256."
+    );
+  }
+  return buffered;
+}
+
+// src/abis/index.ts
+var ERC20_ABI = Object.freeze([
+  "function allowance(address owner,address spender) view returns (uint256)",
+  "function approve(address spender,uint256 amount) returns (bool)",
+  "function balanceOf(address account) view returns (uint256)"
+]);
+var STAKING_ABI = Object.freeze([
+  "function allowance(address sourceAddress,address spenderAddress,uint256 netuid) view returns (uint256)",
+  "function approve(address spenderAddress,uint256 netuid,uint256 absoluteAmount)",
+  "function getStake(bytes32 hotkey,bytes32 coldkey,uint256 netuid) view returns (uint256)"
+]);
+var SPOKE_GATEWAY_ABI = Object.freeze([
+  "function ROUTER() view returns (address)",
+  "function BITTENSOR_SELECTOR() view returns (uint64)",
+  "function SUBTENSOR_GATEWAY() view returns (address)",
+  "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)",
+  "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 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 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)",
+  "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 DeliveredLiquid(address indexed token,bytes32 indexed ss58,uint256 taoOut)",
+  "event DeliveredStaked(address indexed token,bytes32 indexed ss58,uint256 alphaRao)"
+]);
+var ALPHA_VAULT_ABI = Object.freeze([
+  "function isPaused() view returns (bool)",
+  "function pausedUntil() view returns (uint256)",
+  "function isListed(address token) view returns (bool)",
+  "function backing(address token) view returns (uint256 stakedAlpha)",
+  "function positionOf(address token) view returns (bytes32 validator,uint256 netuid)"
+]);
+var VAULT_FACTORY_ABI = Object.freeze([
+  "function create(address owner,bytes32 associatedMiner,address akAddress,address poolManager,address poolAddress,address positionManagerImpl,(address token,uint256 amount)[] stashTokens) payable returns (address manager)",
+  "event SnLiquidityManagerCreated(address indexed manager,address indexed owner,bytes32 associatedMiner,address akAddress,address poolAddress,address poolManager,address positionManager)"
+]);
+var VAULT_MANAGER_ABI = Object.freeze([
+  "function claimFees(address akAddress)",
+  "function topUpAk(address akAddress,address token,uint256 amount) payable",
+  "function withdrawFromAkAndPositions(address akAddress,uint256 amount0,uint256 amount1,uint256[] decreaseTokenIds,bool unwrapETH)",
+  "function stake(address akAddress,bytes data)",
+  "function unstake(address akAddress,bytes data)",
+  "function owner() view returns (address)",
+  "event AKStashTopUp(address akAddress,address token,uint256 amount)",
+  "event AKStashWithdraw(address akAddress,address token,uint256 amount)"
+]);
+var CCIP_EXECUTION_ABI = Object.freeze([
+  "event ExecutionStateChanged(uint64 indexed sourceChainSelector,uint64 indexed sequenceNumber,bytes32 indexed messageId,bytes32 messageHash,uint8 state,bytes returnData,uint256 gasUsed)"
+]);
+var CCIP_ROUTER_ABI = Object.freeze([
+  "function isOffRamp(uint64 sourceChainSelector,address offRamp) view returns (bool)"
+]);
+var foreverMoneyAbis = Object.freeze({
+  alphaGateway: ALPHA_GATEWAY_ABI,
+  alphaVault: ALPHA_VAULT_ABI,
+  ccipExecution: CCIP_EXECUTION_ABI,
+  ccipRouter: CCIP_ROUTER_ABI,
+  erc20: ERC20_ABI,
+  spokeGateway: SPOKE_GATEWAY_ABI,
+  staking: STAKING_ABI,
+  vaultFactory: VAULT_FACTORY_ABI,
+  vaultManager: VAULT_MANAGER_ABI
+});
+
+// src/bridge/plans.ts
+import { Contract, Interface } from "ethers";
+
+// src/core/plans.ts
+import { keccak256, toUtf8Bytes } from "ethers";
+function createTransactionPlan(plan) {
+  const steps = plan.steps.map(
+    (step2) => Object.freeze({
+      ...step2,
+      transaction: Object.freeze({ ...step2.transaction })
+    })
+  );
+  const versionedPlan = {
+    version: "1",
+    deploymentVersion: FOREVERMONEY_DEPLOYMENT_VERSION,
+    action: plan.action,
+    summary: plan.summary,
+    steps: Object.freeze(steps)
+  };
+  return Object.freeze({
+    ...versionedPlan,
+    hash: keccak256(toUtf8Bytes(JSON.stringify(versionedPlan)))
+  });
+}
+
+// src/core/validation.ts
+import { MaxUint256 as MaxUint2562, ZeroHash, isHexString } from "ethers";
+function assertBigInt(amount, label) {
+  if (typeof amount !== "bigint") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be a bigint.`
+    );
+  }
+}
+function assertPositiveAmount(amount, label) {
+  assertBigInt(amount, label);
+  if (amount === 0n) {
+    throw new ForeverMoneyError(
+      "AMOUNT_ZERO",
+      `${label} must be greater than zero.`
+    );
+  }
+  if (amount < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} cannot be negative.`
+    );
+  }
+  if (amount > MaxUint2562) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} exceeds uint256.`
+    );
+  }
+}
+function assertNonNegativeAmount(amount, label) {
+  assertBigInt(amount, label);
+  if (amount < 0n) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} cannot be negative.`
+    );
+  }
+  if (amount > MaxUint2562) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} exceeds uint256.`
+    );
+  }
+}
+function assertBoolean(value, label) {
+  if (typeof value !== "boolean") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be a boolean.`
+    );
+  }
+}
+function assertArray(value, label) {
+  if (!Array.isArray(value)) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be an array.`
+    );
+  }
+}
+function assertRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be an object.`
+    );
+  }
+}
+function normalizeBytes32(value, label) {
+  if (!isHexString(value, 32)) {
+    throw new ForeverMoneyError(
+      "INVALID_BYTES32",
+      `${label} must be a 32-byte hex value.`
+    );
+  }
+  return value.toLowerCase();
+}
+function normalizeOptionalBytes32(value, label) {
+  return value === void 0 ? ZeroHash : normalizeBytes32(value, label);
+}
+
+// src/bridge/plans.ts
+var 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 MIN_LIQUID_EVM_TO_SUBTENSOR_WEI = 10000000000000000n;
+var MIN_LIQUID_BASE_TO_SUBTENSOR_WEI = MIN_LIQUID_EVM_TO_SUBTENSOR_WEI;
+function assertDelivery(value) {
+  if (value !== "liquid" && value !== "staked") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      'Delivery must be "liquid" or "staked".'
+    );
+  }
+}
+function assertSource(value) {
+  if (value !== "liquid" && value !== "staked") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      'Source must be "liquid" or "staked".'
+    );
+  }
+}
+function assertBaseToSubtensorAmount(amountWei, delivery) {
+  assertWholeRao(amountWei);
+  if (delivery === "liquid" && amountWei < MIN_LIQUID_EVM_TO_SUBTENSOR_WEI) {
+    throw new ForeverMoneyError(
+      "AMOUNT_BELOW_MINIMUM",
+      "Liquid delivery from an EVM chain to Subtensor requires at least 0.01 TAO.",
+      {
+        amountWei: amountWei.toString(),
+        minimumAmountWei: MIN_LIQUID_EVM_TO_SUBTENSOR_WEI.toString()
+      }
+    );
+  }
+}
+function transactionStep(kind, label, chainId, from, to, data, value, gasLimit) {
+  return {
+    kind,
+    label,
+    transaction: {
+      chainId,
+      from,
+      to,
+      data,
+      value: value.toString(),
+      ...gasLimit === void 0 ? {} : { gasLimit: gasLimit.toString() }
+    }
+  };
+}
+function buildEvmToSubtensorPlan(input) {
+  const sender = normalizeEvmAddress(input.sender);
+  assertDelivery(input.delivery);
+  assertBaseToSubtensorAmount(input.amountWei, input.delivery);
+  assertNonNegativeAmount(input.allowanceWei, "Token allowance");
+  assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
+  const destination = normalizeSS58(input.destination);
+  const exit = {
+    ss58: ss58ToPublicKey(destination),
+    evmFallback: sender,
+    wantLiquid: input.delivery === "liquid",
+    minTaoOut: input.amountWei
+  };
+  const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const steps = [];
+  if (input.allowanceWei < input.amountWei) {
+    steps.push(
+      transactionStep(
+        "approval",
+        "Approve wrapped TAO for the ForeverMoney gateway",
+        evm.chainId,
+        sender,
+        evm.contracts.wrappedTao,
+        erc20Interface.encodeFunctionData("approve", [
+          evm.contracts.gateway,
+          input.amountWei
+        ]),
+        0n
+      )
+    );
+  }
+  const value = feeWithBuffer(input.exactNetworkFeeWei);
+  steps.push(
+    transactionStep(
+      "transaction",
+      `Bridge wrapped TAO 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]
+      ),
+      value,
+      input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
+    )
+  );
+  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}.`,
+    steps
+  });
+}
+function buildBaseToSubtensorPlan(input) {
+  return buildEvmToSubtensorPlan({ ...input, evmChain: "base" });
+}
+function buildSubtensorToEvmPlan(input) {
+  const sender = normalizeEvmAddress(input.sender);
+  const recipient = normalizeEvmAddress(input.recipient);
+  assertSource(input.source);
+  assertWholeRao(input.amountWei);
+  assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
+  const { subtensor } = foreverMoneyDeployment;
+  const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const amountRao = input.amountWei / EVM_WEI_PER_RAO;
+  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",
+        "The staking allowance is required when bridging staked TAO."
+      );
+    }
+    assertNonNegativeAmount(input.stakingAllowanceRao, "Staking allowance");
+    if (input.stakingAllowanceRao < amountRao) {
+      steps.push(
+        transactionStep(
+          "approval",
+          "Approve staked TAO for the ForeverMoney gateway",
+          subtensor.chainId,
+          sender,
+          subtensor.contracts.stakingPrecompile,
+          stakingInterface.encodeFunctionData("approve", [
+            subtensor.contracts.gateway,
+            input.netuid,
+            amountRao
+          ]),
+          0n
+        )
+      );
+    }
+  } else if (input.netuid !== void 0 || input.stakingAllowanceRao !== void 0) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "netuid and staking allowance are only valid for staked TAO."
+    );
+  }
+  const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
+  const stakedAlphaRao = input.source === "staked" ? amountRao : 0n;
+  const value = taoAmount + feeWithBuffer(input.exactNetworkFeeWei);
+  assertNonNegativeAmount(value, "Transaction value");
+  steps.push(
+    transactionStep(
+      "transaction",
+      `Bridge ${input.source} TAO from Subtensor to ${evm.name}`,
+      subtensor.chainId,
+      sender,
+      subtensor.contracts.gateway,
+      alphaInterface.encodeFunctionData("bridgeOut", [
+        evm.ccipSelector,
+        subtensor.contracts.wrappedTao,
+        recipient,
+        taoAmount,
+        stakedAlphaRao,
+        input.amountWei
+      ]),
+      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}.`,
+    steps
+  });
+}
+function buildSubtensorToBasePlan(input) {
+  return buildSubtensorToEvmPlan({ ...input, evmChain: "base" });
+}
+async function prepareEvmToSubtensor(provider, input) {
+  const sender = normalizeEvmAddress(input.sender);
+  assertDelivery(input.delivery);
+  assertBaseToSubtensorAmount(input.amountWei, input.delivery);
+  const destination = normalizeSS58(input.destination);
+  const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const exit = {
+    ss58: ss58ToPublicKey(destination),
+    evmFallback: sender,
+    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)
+  ]);
+  let estimatedBridgeGas;
+  if (allowanceWei >= input.amountWei) {
+    const data = spokeInterface.encodeFunctionData(
+      "bridgeToFinney(address,uint256,(bytes32,address,bool,uint256))",
+      [evm.contracts.wrappedTao, input.amountWei, exit]
+    );
+    estimatedBridgeGas = await provider.estimateGas({
+      from: sender,
+      to: evm.contracts.gateway,
+      data,
+      value: feeWithBuffer(exactNetworkFeeWei)
+    });
+  }
+  const plan = buildEvmToSubtensorPlan({
+    ...input,
+    allowanceWei,
+    exactNetworkFeeWei,
+    ...estimatedBridgeGas === void 0 ? {} : { estimatedBridgeGas }
+  });
+  return Object.freeze({
+    exactNetworkFeeWei,
+    transactionValueWei: feeWithBuffer(exactNetworkFeeWei),
+    plan
+  });
+}
+function prepareBaseToSubtensor(provider, input) {
+  return prepareEvmToSubtensor(provider, { ...input, evmChain: "base" });
+}
+async function prepareSubtensorToEvm(provider, input) {
+  const sender = normalizeEvmAddress(input.sender);
+  const recipient = normalizeEvmAddress(input.recipient);
+  assertSource(input.source);
+  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
+  );
+  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 Contract(
+      subtensor.contracts.stakingPrecompile,
+      STAKING_ABI,
+      provider
+    );
+    stakingAllowanceRao = await staking.getFunction("allowance")(
+      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;
+  const value = taoAmount + feeWithBuffer(exactNetworkFeeWei);
+  assertNonNegativeAmount(value, "Transaction value");
+  let estimatedBridgeGas;
+  if (input.source === "liquid" || stakingAllowanceRao !== void 0 && stakingAllowanceRao >= stakedAlphaRao) {
+    estimatedBridgeGas = await provider.estimateGas({
+      from: sender,
+      to: subtensor.contracts.gateway,
+      data: alphaInterface.encodeFunctionData("bridgeOut", [
+        evm.ccipSelector,
+        subtensor.contracts.wrappedTao,
+        recipient,
+        taoAmount,
+        stakedAlphaRao,
+        input.amountWei
+      ]),
+      value
+    });
+  }
+  const plan = buildSubtensorToEvmPlan({
+    ...input,
+    exactNetworkFeeWei,
+    ...stakingAllowanceRao === void 0 ? {} : { stakingAllowanceRao },
+    ...estimatedBridgeGas === void 0 ? {} : { estimatedBridgeGas }
+  });
+  return Object.freeze({
+    exactNetworkFeeWei,
+    transactionValueWei: value,
+    plan
+  });
+}
+function prepareSubtensorToBase(provider, input) {
+  return prepareSubtensorToEvm(provider, { ...input, evmChain: "base" });
+}
+
+// src/core/transport.ts
+import { BrowserProvider } from "ethers";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalidJsonRpcResponse() {
+  return new ForeverMoneyError(
+    "RPC_ERROR",
+    "RPC returned an invalid JSON-RPC response."
+  );
+}
+function isLoopback(endpoint) {
+  return endpoint.hostname === "localhost" || endpoint.hostname === "127.0.0.1" || endpoint.hostname === "[::1]";
+}
+function jsonRpcResult(body, expectedId) {
+  if (!isRecord(body) || body.jsonrpc !== "2.0" || body.id !== expectedId) {
+    throw invalidJsonRpcResponse();
+  }
+  if (body.error !== void 0) {
+    if (!isRecord(body.error) || !Number.isInteger(body.error.code) || typeof body.error.message !== "string") {
+      throw invalidJsonRpcResponse();
+    }
+    throw new ForeverMoneyError("RPC_ERROR", body.error.message, {
+      rpcCode: body.error.code,
+      ...body.error.data === void 0 ? {} : { rpcData: body.error.data }
+    });
+  }
+  if (!Object.prototype.hasOwnProperty.call(body, "result")) {
+    throw invalidJsonRpcResponse();
+  }
+  return body.result;
+}
+function http(url, options = {}) {
+  let endpoint;
+  try {
+    endpoint = new URL(url);
+  } catch {
+    throw new ForeverMoneyError("RPC_ERROR", "RPC URL is invalid.");
+  }
+  if (endpoint.protocol !== "https:" && endpoint.protocol !== "http:") {
+    throw new ForeverMoneyError(
+      "RPC_ERROR",
+      "RPC URL must use HTTP or HTTPS."
+    );
+  }
+  if (endpoint.protocol === "http:" && !isLoopback(endpoint)) {
+    throw new ForeverMoneyError(
+      "RPC_ERROR",
+      "Non-local RPC URLs must use HTTPS."
+    );
+  }
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+    throw new ForeverMoneyError(
+      "RPC_ERROR",
+      "RPC timeout must be a positive integer."
+    );
+  }
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImplementation !== "function") {
+    throw new ForeverMoneyError(
+      "RPC_ERROR",
+      "This runtime does not provide fetch. Pass an explicit fetch implementation."
+    );
+  }
+  let requestId = 0;
+  return Object.freeze({
+    async request(request) {
+      if (!isRecord(request) || typeof request.method !== "string" || request.method.length === 0) {
+        throw new ForeverMoneyError(
+          "RPC_ERROR",
+          "RPC method must be a non-empty string."
+        );
+      }
+      if (request.params !== void 0 && !Array.isArray(request.params) && !isRecord(request.params)) {
+        throw new ForeverMoneyError(
+          "RPC_ERROR",
+          "RPC params must be an array or object."
+        );
+      }
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      const id = ++requestId;
+      try {
+        const response = await fetchImplementation(endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            method: request.method,
+            params: request.params ?? []
+          }),
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new ForeverMoneyError(
+            "RPC_ERROR",
+            `RPC returned HTTP ${response.status}.`,
+            { status: response.status }
+          );
+        }
+        return jsonRpcResult(await response.json(), id);
+      } catch (error) {
+        if (error instanceof ForeverMoneyError) throw error;
+        const message = error instanceof Error && error.name === "AbortError" ? `RPC request timed out after ${timeoutMs}ms.` : "RPC request failed.";
+        throw new ForeverMoneyError("RPC_ERROR", message);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  });
+}
+function providerFromTransport(transport) {
+  if (!transport || typeof transport.request !== "function") {
+    throw new ForeverMoneyError(
+      "MISSING_TRANSPORT",
+      "An EIP-1193-compatible RPC transport is required."
+    );
+  }
+  return new BrowserProvider(transport);
+}
+
+// src/core/provider-errors.ts
+function stringProperty(value, property) {
+  if (typeof value !== "object" || value === null || !(property in value)) {
+    return void 0;
+  }
+  const entry = value[property];
+  return typeof entry === "string" ? entry : void 0;
+}
+async function providerOperation(operation, action) {
+  try {
+    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";
+    throw new ForeverMoneyError(
+      reverted ? "SIMULATION_REVERTED" : "RPC_ERROR",
+      reverted ? `${operation} reverted.` : `${operation} failed.`,
+      {
+        ...causeCode === void 0 ? {} : { causeCode },
+        ...reason === void 0 ? {} : { reason }
+      }
+    );
+  }
+}
+
+// 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);
+function step(kind, label, from, to, data, value = 0n) {
+  return {
+    kind,
+    label,
+    transaction: {
+      chainId: foreverMoneyDeployment.base.chainId,
+      from,
+      to,
+      data,
+      value: value.toString()
+    }
+  };
+}
+function normalizeStashTokens(stashTokens) {
+  assertArray(stashTokens, "Stash tokens");
+  const seen = /* @__PURE__ */ new Set();
+  return stashTokens.map((entry) => {
+    assertRecord(entry, "Stash token");
+    if (typeof entry.token !== "string") {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        "Stash token address must be a string."
+      );
+    }
+    const normalizedToken = normalizeEvmAddress(entry.token);
+    assertPositiveAmount(entry.amount, "Stash amount");
+    const key = normalizedToken.toLowerCase();
+    if (seen.has(key)) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        `Duplicate stash token: ${normalizedToken}.`
+      );
+    }
+    seen.add(key);
+    return Object.freeze({
+      token: normalizedToken,
+      amount: entry.amount
+    });
+  });
+}
+function allowanceMap(allowances) {
+  assertArray(allowances, "Token allowances");
+  const result = /* @__PURE__ */ new Map();
+  for (const entry of allowances) {
+    assertRecord(entry, "Token allowance");
+    if (typeof entry.token !== "string") {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        "Allowance token address must be a string."
+      );
+    }
+    const token = normalizeEvmAddress(entry.token).toLowerCase();
+    assertNonNegativeAmount(entry.allowance, "Token allowance");
+    if (result.has(token)) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        `Duplicate allowance for token ${entry.token}.`
+      );
+    }
+    result.set(token, entry.allowance);
+  }
+  return result;
+}
+function assertAllowanceSet(allowances, tokens) {
+  const expected = new Set(
+    tokens.filter(
+      ({ token }) => token !== foreverMoneyDeployment.base.contracts.weth
+    ).map(({ token }) => token.toLowerCase())
+  );
+  for (const token of allowances.keys()) {
+    if (!expected.has(token)) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        `Unexpected allowance for token ${token}.`
+      );
+    }
+  }
+}
+function buildCreateVaultPlan(input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const akAddress = normalizeEvmAddress(input.akAddress);
+  const poolManager = normalizeEvmAddress(input.poolManager);
+  const poolAddress = normalizeEvmAddress(input.poolAddress);
+  const positionManagerImplementation = normalizeEvmAddress(
+    input.positionManagerImplementation
+  );
+  const associatedMiner = normalizeOptionalBytes32(
+    input.associatedMiner,
+    "Associated miner"
+  );
+  const stashTokens = normalizeStashTokens(input.stashTokens);
+  const allowances = allowanceMap(input.allowances);
+  assertAllowanceSet(allowances, stashTokens);
+  const { base } = foreverMoneyDeployment;
+  const steps = [];
+  let value = 0n;
+  for (const stash of stashTokens) {
+    if (stash.token === base.contracts.weth) {
+      value += stash.amount;
+      assertNonNegativeAmount(value, "Vault creation value");
+      continue;
+    }
+    const allowance = allowances.get(stash.token.toLowerCase());
+    if (allowance === void 0) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        `Missing allowance for stash token ${stash.token}.`
+      );
+    }
+    if (allowance < stash.amount) {
+      steps.push(
+        step(
+          "approval",
+          `Approve ${stash.token} for the vault factory`,
+          owner,
+          stash.token,
+          erc20Interface2.encodeFunctionData("approve", [
+            base.contracts.vaultFactory,
+            stash.amount
+          ])
+        )
+      );
+    }
+  }
+  steps.push(
+    step(
+      "transaction",
+      "Create ForeverMoney vault",
+      owner,
+      base.contracts.vaultFactory,
+      factoryInterface.encodeFunctionData("create", [
+        owner,
+        associatedMiner,
+        akAddress,
+        poolManager,
+        poolAddress,
+        positionManagerImplementation,
+        stashTokens
+      ]),
+      value
+    )
+  );
+  return createTransactionPlan({
+    action: "vault.create",
+    summary: `Create a vault owned by ${owner} with ${stashTokens.length} initial stash token(s).`,
+    steps
+  });
+}
+async function prepareCreateVault(provider, input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const stashTokens = normalizeStashTokens(input.stashTokens);
+  const erc20Stash = stashTokens.filter(
+    ({ token }) => token !== foreverMoneyDeployment.base.contracts.weth
+  );
+  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
+      )
+    }))
+  );
+  return buildCreateVaultPlan({ ...input, allowances });
+}
+function buildDepositVaultPlan(input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const manager = normalizeEvmAddress(input.manager);
+  const akAddress = normalizeEvmAddress(input.akAddress);
+  const deposits = normalizeStashTokens(input.deposits);
+  if (deposits.length === 0) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "At least one vault deposit is required."
+    );
+  }
+  const allowances = allowanceMap(input.allowances);
+  assertAllowanceSet(allowances, deposits);
+  const steps = [];
+  for (const deposit of deposits) {
+    if (deposit.token === foreverMoneyDeployment.base.contracts.weth) {
+      steps.push(
+        step(
+          "transaction",
+          "Deposit native ETH into the vault as WETH",
+          owner,
+          manager,
+          managerInterface.encodeFunctionData("topUpAk", [
+            akAddress,
+            ZeroAddress2,
+            deposit.amount
+          ]),
+          deposit.amount
+        )
+      );
+      continue;
+    }
+    const allowance = allowances.get(deposit.token.toLowerCase());
+    if (allowance === void 0) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        `Missing allowance for deposit token ${deposit.token}.`
+      );
+    }
+    if (allowance < deposit.amount) {
+      steps.push(
+        step(
+          "approval",
+          `Approve ${deposit.token} for the vault manager`,
+          owner,
+          deposit.token,
+          erc20Interface2.encodeFunctionData("approve", [
+            manager,
+            deposit.amount
+          ])
+        )
+      );
+    }
+    steps.push(
+      step(
+        "transaction",
+        `Deposit ${deposit.token} into the vault`,
+        owner,
+        manager,
+        managerInterface.encodeFunctionData("topUpAk", [
+          akAddress,
+          deposit.token,
+          deposit.amount
+        ])
+      )
+    );
+  }
+  return createTransactionPlan({
+    action: "vault.deposit",
+    summary: `Deposit ${deposits.length} token amount(s) into vault ${manager}.`,
+    steps
+  });
+}
+async function prepareDepositVault(provider, input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const manager = normalizeEvmAddress(input.manager);
+  const deposits = normalizeStashTokens(input.deposits);
+  const erc20Deposits = deposits.filter(
+    ({ token }) => token !== foreverMoneyDeployment.base.contracts.weth
+  );
+  const allowances = await Promise.all(
+    erc20Deposits.map(async ({ token }) => ({
+      token,
+      allowance: await new Contract2(
+        token,
+        ERC20_ABI,
+        provider
+      ).getFunction("allowance")(owner, manager)
+    }))
+  );
+  return buildDepositVaultPlan({ ...input, allowances });
+}
+function buildWithdrawVaultPlan(input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const manager = normalizeEvmAddress(input.manager);
+  const akAddress = normalizeEvmAddress(input.akAddress);
+  assertArray(input.decreaseTokenIds, "Position token IDs");
+  assertBoolean(input.unwrapWeth, "unwrapWeth");
+  assertNonNegativeAmount(input.amount0, "Token 0 withdrawal");
+  assertNonNegativeAmount(input.amount1, "Token 1 withdrawal");
+  if (input.amount0 === 0n && input.amount1 === 0n) {
+    throw new ForeverMoneyError(
+      "AMOUNT_ZERO",
+      "At least one withdrawal amount must be greater than zero."
+    );
+  }
+  for (const tokenId of input.decreaseTokenIds) {
+    assertNonNegativeAmount(tokenId, "Position token ID");
+  }
+  return createTransactionPlan({
+    action: "vault.withdraw",
+    summary: `Withdraw token amounts from vault ${manager}.`,
+    steps: [
+      step(
+        "transaction",
+        "Withdraw assets from the vault",
+        owner,
+        manager,
+        managerInterface.encodeFunctionData(
+          "withdrawFromAkAndPositions",
+          [
+            akAddress,
+            input.amount0,
+            input.amount1,
+            input.decreaseTokenIds,
+            input.unwrapWeth
+          ]
+        )
+      )
+    ]
+  });
+}
+function buildClaimVaultFeesPlan(input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const manager = normalizeEvmAddress(input.manager);
+  const akAddress = normalizeEvmAddress(input.akAddress);
+  return createTransactionPlan({
+    action: "vault.claim-fees",
+    summary: `Claim all fees for ${akAddress} from vault ${manager}.`,
+    steps: [
+      step(
+        "transaction",
+        "Claim vault fees",
+        owner,
+        manager,
+        managerInterface.encodeFunctionData("claimFees(address)", [
+          akAddress
+        ])
+      )
+    ]
+  });
+}
+function buildSetVaultStakingPlan(input) {
+  const owner = normalizeEvmAddress(input.owner);
+  const manager = normalizeEvmAddress(input.manager);
+  const akAddress = normalizeEvmAddress(input.akAddress);
+  assertBoolean(input.staking, "staking");
+  const action = input.staking ? "stake" : "unstake";
+  return createTransactionPlan({
+    action: `vault.${action}`,
+    summary: `${input.staking ? "Stake" : "Unstake"} the active position in vault ${manager}.`,
+    steps: [
+      step(
+        "transaction",
+        `${input.staking ? "Stake" : "Unstake"} the vault position`,
+        owner,
+        manager,
+        managerInterface.encodeFunctionData(
+          `${action}(address,bytes)`,
+          [akAddress, "0x"]
+        )
+      )
+    ]
+  });
+}
+
+// src/bridge/tracking.ts
+import { Interface as Interface4, toBeHex } from "ethers";
+
+// src/bridge/receipts.ts
+import { Interface as Interface3, isHexString as isHexString2 } from "ethers";
+
+// src/core/receipts.ts
+function isLogFrom(log, address) {
+  return log.address.toLowerCase() === address.toLowerCase();
+}
+
+// src/bridge/receipts.ts
+var alphaGatewayInterface = new Interface3(ALPHA_GATEWAY_ABI);
+var spokeGatewayInterface = new Interface3(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(
+      "INVALID_TRANSACTION_PLAN",
+      "Bridge direction must identify a canonical Base or Robinhood lane."
+    );
+  }
+}
+function evmChainFromBridgeDirection(direction) {
+  assertBridgeDirection(direction);
+  return direction.includes("robinhood") ? "robinhood" : "base";
+}
+function isEvmToSubtensorDirection(direction) {
+  assertBridgeDirection(direction);
+  return direction.endsWith("-to-subtensor");
+}
+function bridgeMessageIdFromReceipt(direction, receipt) {
+  assertBridgeDirection(direction);
+  const evm = getForeverMoneyEvmDeployment(
+    evmChainFromBridgeDirection(direction)
+  );
+  const evmToSubtensor = isEvmToSubtensorDirection(direction);
+  const [address, contractInterface, eventName] = evmToSubtensor ? [evm.contracts.gateway, spokeGatewayInterface, "BridgedToFinney"] : [
+    foreverMoneyDeployment.subtensor.contracts.gateway,
+    alphaGatewayInterface,
+    "BridgedOut"
+  ];
+  for (const log of receipt.logs) {
+    if (!isLogFrom(log, address)) continue;
+    try {
+      const parsed = contractInterface.parseLog({
+        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)) {
+        return messageId.toLowerCase();
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/bridge/tracking.ts
+var ccipExecutionInterface = new Interface4(CCIP_EXECUTION_ABI);
+var alphaGatewayInterface2 = new Interface4(ALPHA_GATEWAY_ABI);
+function destinationChainId(direction) {
+  assertBridgeDirection(direction);
+  const evm = getForeverMoneyEvmDeployment(
+    evmChainFromBridgeDirection(direction)
+  );
+  return isEvmToSubtensorDirection(direction) ? foreverMoneyDeployment.subtensor.chainId : evm.chainId;
+}
+function sourceChainId(direction) {
+  assertBridgeDirection(direction);
+  const evm = getForeverMoneyEvmDeployment(
+    evmChainFromBridgeDirection(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)) {
+    throw new ForeverMoneyError(
+      "CHAIN_MISMATCH",
+      `${label} transport reported chain ID ${network.chainId}; expected ${expectedChainId}.`,
+      {
+        expectedChainId,
+        actualChainId: network.chainId.toString()
+      }
+    );
+  }
+}
+async function assertDestinationProvider(provider, direction) {
+  const expectedChainId = destinationChainId(direction);
+  await assertProviderChain(provider, expectedChainId, "Bridge destination");
+  return expectedChainId;
+}
+async function getBridgeSourceStatus(provider, input) {
+  const expectedChainId = sourceChainId(input.direction);
+  const transactionHash = normalizeBytes32(
+    input.transactionHash,
+    "Transaction hash"
+  );
+  await assertProviderChain(provider, expectedChainId, "Bridge source");
+  const receipt = await provider.getTransactionReceipt(transactionHash);
+  if (receipt === null) {
+    return Object.freeze({
+      direction: input.direction,
+      sourceChainId: expectedChainId,
+      transactionHash,
+      status: "pending",
+      messageId: null
+    });
+  }
+  if (receipt.status === 0) {
+    return Object.freeze({
+      direction: input.direction,
+      sourceChainId: expectedChainId,
+      transactionHash,
+      status: "failed",
+      messageId: null
+    });
+  }
+  if (receipt.status !== 1) {
+    throw new ForeverMoneyError(
+      "INVALID_PROVIDER_RESPONSE",
+      "The bridge source receipt has an invalid status."
+    );
+  }
+  const messageId = bridgeMessageIdFromReceipt(input.direction, receipt);
+  if (messageId === null) {
+    throw new ForeverMoneyError(
+      "INVALID_PROVIDER_RESPONSE",
+      "The confirmed bridge source receipt does not contain its canonical gateway event."
+    );
+  }
+  return Object.freeze({
+    direction: input.direction,
+    sourceChainId: expectedChainId,
+    transactionHash,
+    status: "confirmed",
+    messageId
+  });
+}
+async function getCcipDeliveryCheckpoint(provider, direction) {
+  const expectedChainId = await assertDestinationProvider(provider, direction);
+  const fromBlock = await provider.getBlockNumber();
+  if (!Number.isSafeInteger(fromBlock) || fromBlock < 0) {
+    throw new ForeverMoneyError(
+      "INVALID_PROVIDER_RESPONSE",
+      "Bridge destination transport returned an invalid block number."
+    );
+  }
+  return Object.freeze({
+    direction,
+    destinationChainId: expectedChainId,
+    fromBlock
+  });
+}
+async function getCcipDeliveryStatus(provider, input) {
+  const expectedChainId = destinationChainId(input.direction);
+  const messageId = normalizeBytes32(input.messageId, "CCIP message ID");
+  if (!Number.isSafeInteger(input.fromBlock) || input.fromBlock < 0) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "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.");
+  }
+  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({
+    address: offRamp,
+    fromBlock: input.fromBlock,
+    toBlock: "latest",
+    topics: [event.topicHash, toBeHex(sourceSelector, 32), null, messageId]
+  });
+  const latest = logs.at(-1);
+  if (latest === void 0) return "waiting";
+  const parsed = ccipExecutionInterface.parseLog(latest);
+  const state = Number(parsed?.args.state);
+  if (state === 3) return "failure";
+  if (state !== 2) return "waiting";
+  if (!evmToSubtensor) return "success";
+  const receipt = await provider.getTransactionReceipt(latest.transactionHash);
+  if (receipt === null) {
+    throw new ForeverMoneyError(
+      "INVALID_PROVIDER_RESPONSE",
+      "The CCIP execution receipt is unavailable."
+    );
+  }
+  for (const log of receipt.logs) {
+    if (log.address.toLowerCase() !== foreverMoneyDeployment.subtensor.contracts.gateway.toLowerCase()) {
+      continue;
+    }
+    try {
+      if (alphaGatewayInterface2.parseLog(log)?.name === "Claimable") {
+        return "recovery";
+      }
+    } catch {
+    }
+  }
+  return "success";
+}
+
+// src/client.ts
+async function assertProviderChain2(provider, expectedChainId, name) {
+  const network = await providerOperation(
+    `Reading the ${name} chain ID`,
+    () => provider.getNetwork()
+  );
+  if (network.chainId !== BigInt(expectedChainId)) {
+    throw new ForeverMoneyError(
+      "CHAIN_MISMATCH",
+      `${name} transport reported chain ID ${network.chainId}; expected ${expectedChainId}.`,
+      {
+        expectedChainId,
+        actualChainId: network.chainId.toString()
+      }
+    );
+  }
+}
+function createForeverMoneyClient(options) {
+  if (!options?.transports?.base || !options.transports.subtensor) {
+    throw new ForeverMoneyError(
+      "MISSING_TRANSPORT",
+      "Base and Subtensor transports are required."
+    );
+  }
+  const baseProvider = providerFromTransport(options.transports.base);
+  const subtensorProvider = providerFromTransport(
+    options.transports.subtensor
+  );
+  const robinhoodProvider = options.transports.robinhood ? providerFromTransport(options.transports.robinhood) : void 0;
+  const verifyBaseConnection = async () => {
+    await assertProviderChain2(baseProvider, BASE_CHAIN_ID, "Base");
+  };
+  const verifySubtensorConnection = async () => {
+    await assertProviderChain2(
+      subtensorProvider,
+      SUBTENSOR_CHAIN_ID,
+      "Subtensor"
+    );
+  };
+  const verifyRobinhoodConnection = async () => {
+    if (robinhoodProvider === void 0) return;
+    await assertProviderChain2(
+      robinhoodProvider,
+      ROBINHOOD_CHAIN_ID,
+      "Robinhood"
+    );
+  };
+  const verifyConnections = async () => {
+    await Promise.all([
+      verifyBaseConnection(),
+      verifyRobinhoodConnection(),
+      verifySubtensorConnection()
+    ]);
+  };
+  const providerForChain = (chainId) => {
+    if (chainId === BASE_CHAIN_ID) return baseProvider;
+    if (chainId === SUBTENSOR_CHAIN_ID) return subtensorProvider;
+    if (chainId === ROBINHOOD_CHAIN_ID && robinhoodProvider !== void 0) {
+      return robinhoodProvider;
+    }
+    throw new ForeverMoneyError(
+      "MISSING_TRANSPORT",
+      `A transport for chain ID ${chainId} is required for this operation.`
+    );
+  };
+  return Object.freeze({
+    bridge: Object.freeze({
+      async prepareEvmToSubtensor(input) {
+        const evm = getForeverMoneyEvmDeployment(input.evmChain);
+        const provider = providerForChain(evm.chainId);
+        await assertProviderChain2(provider, evm.chainId, evm.name);
+        return providerOperation(
+          `Preparing the ${evm.name} to Subtensor bridge`,
+          () => prepareEvmToSubtensor(provider, input)
+        );
+      },
+      async prepareBaseToSubtensor(input) {
+        await verifyBaseConnection();
+        return providerOperation(
+          "Preparing the Base to Subtensor bridge",
+          () => prepareBaseToSubtensor(baseProvider, input)
+        );
+      },
+      async prepareSubtensorToEvm(input) {
+        const evm = getForeverMoneyEvmDeployment(input.evmChain);
+        await verifySubtensorConnection();
+        return providerOperation(
+          `Preparing the Subtensor to ${evm.name} bridge`,
+          () => prepareSubtensorToEvm(subtensorProvider, input)
+        );
+      },
+      async prepareSubtensorToBase(input) {
+        await verifySubtensorConnection();
+        return providerOperation(
+          "Preparing the Subtensor to Base bridge",
+          () => prepareSubtensorToBase(subtensorProvider, input)
+        );
+      },
+      async getDeliveryCheckpoint(direction) {
+        const expectedChainId = destinationChainId(direction);
+        const provider = providerForChain(expectedChainId);
+        return providerOperation(
+          "Reading the bridge delivery checkpoint",
+          () => getCcipDeliveryCheckpoint(provider, direction)
+        );
+      },
+      async getDeliveryStatus(input) {
+        const expectedChainId = destinationChainId(input.direction);
+        const provider = providerForChain(expectedChainId);
+        return providerOperation(
+          "Reading CCIP delivery status",
+          () => getCcipDeliveryStatus(provider, input)
+        );
+      },
+      async getSourceStatus(input) {
+        const expectedChainId = sourceChainId(input.direction);
+        const provider = providerForChain(expectedChainId);
+        return providerOperation(
+          "Reading the bridge source transaction",
+          () => getBridgeSourceStatus(provider, input)
+        );
+      }
+    }),
+    vaults: Object.freeze({
+      async prepareCreate(input) {
+        await verifyBaseConnection();
+        return providerOperation(
+          "Preparing vault creation",
+          () => prepareCreateVault(baseProvider, input)
+        );
+      },
+      async prepareDeposit(input) {
+        await verifyBaseConnection();
+        return providerOperation(
+          "Preparing the vault deposit",
+          () => prepareDepositVault(baseProvider, input)
+        );
+      }
+    }),
+    verifyConnections
+  });
+}
+
+// src/vaults/receipts.ts
+import { Interface as Interface5 } from "ethers";
+var vaultFactoryInterface = new Interface5(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({
+        data: log.data,
+        topics: [...log.topics]
+      });
+      if (parsed?.name === "SnLiquidityManagerCreated") {
+        return normalizeEvmAddress(String(parsed.args.manager));
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/core/transactions.ts
+import { MaxUint256 as MaxUint2563 } from "ethers";
+function decimalQuantity(value, label) {
+  if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} must be an unsigned decimal integer.`
+    );
+  }
+  const quantity = BigInt(value);
+  if (quantity > MaxUint2563) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `${label} exceeds uint256.`
+    );
+  }
+  return quantity;
+}
+function hexQuantity(value) {
+  return `0x${value.toString(16)}`;
+}
+function toEip1193Transaction(transaction) {
+  const value = decimalQuantity(transaction.value, "Transaction value");
+  const gasLimit = transaction.gasLimit === void 0 ? void 0 : decimalQuantity(transaction.gasLimit, "Transaction gas limit");
+  return Object.freeze({
+    from: transaction.from,
+    to: transaction.to,
+    data: transaction.data,
+    value: hexQuantity(value),
+    ...gasLimit === void 0 ? {} : { gas: hexQuantity(gasLimit) }
+  });
+}
+function toEthersTransaction(transaction) {
+  return Object.freeze({
+    chainId: transaction.chainId,
+    to: transaction.to,
+    data: transaction.data,
+    value: decimalQuantity(transaction.value, "Transaction value"),
+    ...transaction.gasLimit === void 0 ? {} : {
+      gasLimit: decimalQuantity(
+        transaction.gasLimit,
+        "Transaction gas limit"
+      )
+    }
+  });
+}
+export {
+  BASE_CCIP_SELECTOR,
+  BASE_CHAIN_ID,
+  BASIS_POINTS,
+  EVM_WEI_PER_RAO,
+  FOREVERMONEY_DEPLOYMENT_VERSION,
+  ForeverMoneyError,
+  GAS_LIMIT_BUFFER_BPS,
+  MIN_LIQUID_BASE_TO_SUBTENSOR_WEI,
+  MIN_LIQUID_EVM_TO_SUBTENSOR_WEI,
+  NETWORK_FEE_BUFFER_BPS,
+  RAO_PER_TAO,
+  ROBINHOOD_CCIP_SELECTOR,
+  ROBINHOOD_CHAIN_ID,
+  SUBTENSOR_CCIP_SELECTOR,
+  SUBTENSOR_CHAIN_ID,
+  assertWholeRao,
+  bridgeMessageIdFromReceipt,
+  buildBaseToSubtensorPlan,
+  buildClaimVaultFeesPlan,
+  buildCreateVaultPlan,
+  buildDepositVaultPlan,
+  buildEvmToSubtensorPlan,
+  buildSetVaultStakingPlan,
+  buildSubtensorToBasePlan,
+  buildSubtensorToEvmPlan,
+  buildWithdrawVaultPlan,
+  createForeverMoneyClient,
+  destinationChainId,
+  evmChainFromBridgeDirection,
+  evmToMirrorSS58,
+  feeWithBuffer,
+  foreverMoneyAbis,
+  foreverMoneyDeployment,
+  formatTaoAmount,
+  gasLimitWithBuffer,
+  getBridgeSourceStatus,
+  getCcipDeliveryCheckpoint,
+  getCcipDeliveryStatus,
+  getForeverMoneyEvmDeployment,
+  http,
+  isBittensorSS58,
+  isEvmToSubtensorDirection,
+  normalizeEvmAddress,
+  normalizeSS58,
+  parseTaoAmount,
+  sourceChainId,
+  ss58ToPublicKey,
+  toEip1193Transaction,
+  toEthersTransaction,
+  vaultManagerFromCreationReceipt
+};
+//# sourceMappingURL=index.js.map