@forevermoney/sdk 0.2.0 → 0.5.0

package/dist/index.js

@@ -92,7 +92,8 @@ var ROBINHOOD_CCIP_SELECTOR = 6180753054346818345n;
 var SUBTENSOR_CCIP_SELECTOR = 2135107236357186872n;
 var RAO_PER_TAO = 1000000000n;
 var EVM_WEI_PER_RAO = 1000000000n;
-var FOREVERMONEY_DEPLOYMENT_VERSION = "1.1.0";
+var SN80_NETUID = 80n;
+var FOREVERMONEY_DEPLOYMENT_VERSION = "1.3.0";
 var foreverMoneyDeployment = Object.freeze({
   version: FOREVERMONEY_DEPLOYMENT_VERSION,
   base: Object.freeze({
@@ -101,10 +102,18 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: BASE_CHAIN_ID,
     ccipSelector: BASE_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: getAddress2("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C"),
+      gateway: getAddress2("0x1da2415229b614C787e145D1D7346eb496319C52"),
+      // Retired gateways, oldest first; kept only to track transfers sent
+      // through them.
+      legacyGateways: [
+        getAddress2("0x5EF3d7D19e4b233a1A169DA0d5CB02ec6b160a2C")
+      ],
       wrappedTao: getAddress2(
         "0xf3081494b87e8d5fb7960f066e931d1d0e6e3d67"
       ),
+      wrappedSn80: getAddress2(
+        "0x6f63d869011f95274498023b4abfc00b30c34378"
+      ),
       ccipRouter: getAddress2(
         "0x881e3A65B4d4a04dD529061dd0071cf975F58bCD"
       ),
@@ -130,7 +139,10 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: ROBINHOOD_CHAIN_ID,
     ccipSelector: ROBINHOOD_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: getAddress2("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8"),
+      gateway: getAddress2("0xf27fdA637131E25B2A1b4865ED9597d881980c7E"),
+      legacyGateways: [
+        getAddress2("0x53Dcc4FE04193e489BE537F722F65317DB1E65d8")
+      ],
       wrappedTao: getAddress2(
         "0xf3081494B87e8D5fb7960f066E931D1D0e6E3d67"
       ),
@@ -146,13 +158,23 @@ var foreverMoneyDeployment = Object.freeze({
     chainId: SUBTENSOR_CHAIN_ID,
     ccipSelector: SUBTENSOR_CCIP_SELECTOR,
     contracts: Object.freeze({
-      gateway: getAddress2("0x998f20Fea90bF7792774dECc7f994716442B1705"),
+      // V5.1 AlphaGateway: multi-validator staked input (tao-bridge 485c898).
+      gateway: getAddress2("0xd5Fa238aa4177f6c1341491969d9cBeec94EEd69"),
+      // V4 and V5 hubs. The spokes still deliver to the V5 hub (their hub
+      // pointer is immutable), so it stays here for delivery tracking.
+      legacyGateways: [
+        getAddress2("0x998f20Fea90bF7792774dECc7f994716442B1705"),
+        getAddress2("0xcd0C6d98D0A126B1c113d15b4c28F38321437787")
+      ],
       alphaVault: getAddress2(
         "0x11837459896D96F821a8D88eC93a3C8D152033D4"
       ),
       wrappedTao: getAddress2(
         "0xC5b6C1632d34901239396F5E1BDe54B342900256"
       ),
+      wrappedSn80: getAddress2(
+        "0xfD628dE75EF96f0A5C59659159C6cA81E0DC2222"
+      ),
       ccipRouter: getAddress2(
         "0xD941fBEcD2b971d0F54b4C34286C95faB52B60B8"
       ),
@@ -333,23 +355,39 @@ var SPOKE_GATEWAY_ABI = Object.freeze([
   "function ROUTER() view returns (address)",
   "function BITTENSOR_SELECTOR() view returns (uint64)",
   "function SUBTENSOR_GATEWAY() view returns (address)",
+  "function maxIntegratorFeeBps() view returns (uint16)",
+  "function bridgeFeeBps() view returns (uint16)",
   "function quoteBridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) view returns (uint256 fee)",
   "function bridgeToFinney(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit) payable returns (bytes32 messageId)",
+  "function quoteBridgeToFinneyWithFee(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit,uint256 gasLimit,(address recipient,uint16 bps) integrator) view returns (uint256 fee,uint256 cut,uint256 amountCrossing)",
+  "function bridgeToFinneyWithFee(address token,uint256 amount,(bytes32 ss58,address evmFallback,bool wantLiquid,uint256 minTaoOut) exit,uint256 gasLimit,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
   "event BridgedToFinney(address indexed token,address indexed sender,bytes32 indexed ss58,uint256 amount,bytes32 messageId)"
 ]);
 var ALPHA_GATEWAY_ABI = Object.freeze([
   "function ROUTER() view returns (address)",
   "function allowedLane(uint64 selector) view returns (bool)",
+  "function maxIntegratorFeeBps() view returns (uint16)",
+  "function bridgeFeeBps() view returns (uint16)",
+  "function integratorTaoTopUp(uint256 taoAmount,uint16 bps) pure returns (uint256)",
   "function quoteBridgeOut(uint64 destSelector,address token,address recipient,uint256 mintedAmount) view returns (uint256 fee)",
   "function bridgeOut(uint64 destSelector,address token,address recipient,uint256 taoAmount,uint256 stakedAlphaRao,uint256 minTokenOut) payable returns (bytes32 messageId)",
+  "function integratorCut(uint256 amount,uint16 bps) pure returns (uint256)",
+  "function quoteBridgeOutWithFee(uint64 destSelector,address token,address recipient,uint256 mintedAmount,uint256 taoAmount,uint256 stakedAlphaRao,(address recipient,uint16 bps) integrator) view returns (uint256 fee,uint256 nativeTopUp,uint256 alphaTopUp,uint256 amountCrossing)",
+  "function bridgeOutWithFee(uint64 destSelector,address token,address recipient,uint256 taoAmount,uint256 stakedAlphaRao,uint256 minTokenOut,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
+  "function bridgeOutFromValidators(uint64 destSelector,address token,address recipient,uint256 taoAmount,(bytes32 validator,uint256 alphaRao)[] sources,uint256 minTokenOut) payable returns (bytes32 messageId)",
+  "function bridgeOutFromValidatorsWithFee(uint64 destSelector,address token,address recipient,uint256 taoAmount,(bytes32 validator,uint256 alphaRao)[] sources,uint256 minTokenOut,(address recipient,uint16 bps) integrator) payable returns (bytes32 messageId)",
+  "function minStakeRequired() view returns (uint256)",
+  "function MAX_STAKE_SOURCES() view returns (uint256)",
+  "function GATEWAY_COLDKEY() view returns (bytes32)",
   "function claimLiquid(address token,uint256 minTaoOut,address to)",
   "function claimNative(address to)",
   "function claimStaked(address token,bytes32 destColdkey,address to)",
   "function claimToken(address token,address to)",
   "function claimableNative(address account) view returns (uint256)",
-  "function claimableToken(address account,address token) view returns (uint256)",
+  "function claimableToken(address token,address account) view returns (uint256)",
   "event BridgedOut(uint64 destChainSelector,address indexed token,address indexed sender,address indexed recipient,uint256 minted,bytes32 messageId)",
   "event Claimable(address indexed token,address indexed user,uint256 native,uint256 wsn)",
+  "event NotDelivered(uint64 indexed sourceChainSelector,address indexed token,uint256 amount,uint8 reason)",
   "event DeliveredLiquid(address indexed token,bytes32 indexed ss58,uint256 taoOut)",
   "event DeliveredStaked(address indexed token,bytes32 indexed ss58,uint256 alphaRao)"
 ]);
@@ -507,6 +545,112 @@ 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;
+var MIN_LIQUID_SUBTENSOR_TO_EVM_WEI = 2000000n * EVM_WEI_PER_RAO;
+var MAX_PARTNER_FEE_BPS = 1e4;
+var MAX_STAKE_PULLS = 16;
+var NO_PARTNER_FEE = {
+  recipient: "0x0000000000000000000000000000000000000000",
+  bps: 0
+};
+function resolvePartnerFee(fee, gateway) {
+  if (fee === void 0) return NO_PARTNER_FEE;
+  if (typeof fee.bps !== "number" || !Number.isInteger(fee.bps) || fee.bps < 0 || fee.bps > MAX_PARTNER_FEE_BPS) {
+    throw new ForeverMoneyError(
+      "INVALID_PARTNER_FEE",
+      `Partner fee bps must be an integer between 0 and ${MAX_PARTNER_FEE_BPS}.`,
+      { bps: fee.bps }
+    );
+  }
+  if (fee.bps === 0) return NO_PARTNER_FEE;
+  const recipient = normalizeEvmAddress(fee.recipient);
+  if (recipient === NO_PARTNER_FEE.recipient || recipient.toLowerCase() === gateway.toLowerCase()) {
+    throw new ForeverMoneyError(
+      "INVALID_PARTNER_FEE",
+      "Partner fee recipient must not be the zero address or the gateway.",
+      { recipient }
+    );
+  }
+  return { recipient, bps: fee.bps };
+}
+function partnerFeeCut(amount, bps) {
+  return amount * BigInt(bps) / 10000n;
+}
+function partnerFeeTaoTopUp(taoAmount, bps) {
+  const raw = partnerFeeCut(taoAmount, bps);
+  if (raw === 0n) return 0n;
+  return (raw + EVM_WEI_PER_RAO - 1n) / EVM_WEI_PER_RAO * EVM_WEI_PER_RAO;
+}
+function assertPartnerFeeAllowed(fee, maxBps) {
+  if (fee.bps > maxBps) {
+    throw new ForeverMoneyError(
+      "INVALID_PARTNER_FEE",
+      `Partner fee of ${fee.bps} bps exceeds the gateway maximum of ${maxBps} bps.`,
+      { bps: fee.bps, maxBps }
+    );
+  }
+}
+function bridgeAsset(evmChain, asset = "tao") {
+  if (asset !== "tao" && asset !== "sn80") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      'Asset must be "tao" or "sn80".'
+    );
+  }
+  if (asset === "sn80" && evmChain !== "base") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "SN80 bridging is supported between Base and Subtensor."
+    );
+  }
+  const evm = getForeverMoneyEvmDeployment(evmChain);
+  return asset === "sn80" ? {
+    evmToken: foreverMoneyDeployment.base.contracts.wrappedSn80,
+    subtensorToken: foreverMoneyDeployment.subtensor.contracts.wrappedSn80,
+    label: "SN80",
+    wrappedLabel: "SN80"
+  } : {
+    evmToken: evm.contracts.wrappedTao,
+    subtensorToken: foreverMoneyDeployment.subtensor.contracts.wrappedTao,
+    label: "TAO",
+    wrappedLabel: "wrapped TAO"
+  };
+}
+function assertAssetMode(asset, mode) {
+  if (asset === "sn80" && mode !== "staked") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "SN80 bridging requires staked subnet 80 input or delivery; liquid TAO conversion is not supported."
+    );
+  }
+}
+function sourceNetuid(input) {
+  if (input.source !== "staked") return void 0;
+  const netuid = input.netuid ?? (input.asset === "sn80" ? SN80_NETUID : void 0);
+  if (netuid === void 0) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "A netuid is required when bridging staked TAO."
+    );
+  }
+  assertNonNegativeAmount(netuid, "netuid");
+  if (input.asset === "sn80" && netuid !== SN80_NETUID) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "SN80 staking approvals must use netuid 80."
+    );
+  }
+  return netuid;
+}
+function stakePullsFor(input, amountRao) {
+  if (input.stakePulls === void 0) return void 0;
+  if (input.source !== "staked") {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "Stake pulls are only valid for a staked source."
+    );
+  }
+  return resolveStakePulls(input.stakePulls, amountRao);
+}
 function assertDelivery(value) {
   if (value !== "liquid" && value !== "staked") {
     throw new ForeverMoneyError(
@@ -536,6 +680,19 @@ function assertBaseToSubtensorAmount(amountWei, delivery) {
     );
   }
 }
+function assertSubtensorToEvmAmount(amountWei, source) {
+  assertWholeRao(amountWei);
+  if (source === "liquid" && amountWei < MIN_LIQUID_SUBTENSOR_TO_EVM_WEI) {
+    throw new ForeverMoneyError(
+      "AMOUNT_BELOW_MINIMUM",
+      "Bridging liquid TAO from Subtensor requires at least 0.002 TAO.",
+      {
+        amountWei: amountWei.toString(),
+        minimumAmountWei: MIN_LIQUID_SUBTENSOR_TO_EVM_WEI.toString()
+      }
+    );
+  }
+}
 function transactionStep(kind, label, chainId, from, to, data, value, gasLimit) {
   return {
     kind,
@@ -550,9 +707,159 @@ function transactionStep(kind, label, chainId, from, to, data, value, gasLimit)
     }
   };
 }
+function partnerFeeSummary(charged, unit, fee) {
+  if (fee.bps === 0) return "";
+  return ` Partner fee: ${charged} wei of ${unit} (${fee.bps} bps) on top, paid to ${fee.recipient}.`;
+}
+function encodeSpokeBridge(token, amountWei, exit, fee) {
+  return fee.bps === 0 ? encodeFunctionData({
+    abi: spokeAbi,
+    functionName: "bridgeToFinney",
+    args: [token, amountWei, exit]
+  }) : encodeFunctionData({
+    abi: spokeAbi,
+    functionName: "bridgeToFinneyWithFee",
+    args: [token, amountWei, exit, 0n, fee]
+  });
+}
+function resolveStakePulls(pulls, amountRao) {
+  if (pulls.length === 0 || pulls.length > MAX_STAKE_PULLS) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      `Between 1 and ${MAX_STAKE_PULLS} stake pulls are required.`,
+      { count: pulls.length }
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let total = 0n;
+  const resolved = pulls.map((pull) => {
+    const validator = normalizeBytes32(pull.hotkey, "Stake pull hotkey");
+    if (validator === `0x${"0".repeat(64)}`) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        "Stake pull hotkey must not be zero."
+      );
+    }
+    const key = validator.toLowerCase();
+    if (seen.has(key)) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        "Stake pulls must not repeat a hotkey.",
+        { hotkey: validator }
+      );
+    }
+    seen.add(key);
+    if (typeof pull.amountRao !== "bigint" || pull.amountRao <= 0n) {
+      throw new ForeverMoneyError(
+        "INVALID_TRANSACTION_PLAN",
+        "Each stake pull must take a positive amount of RAO.",
+        { hotkey: validator }
+      );
+    }
+    total += pull.amountRao;
+    return { validator, alphaRao: pull.amountRao };
+  });
+  if (total !== amountRao) {
+    throw new ForeverMoneyError(
+      "INVALID_TRANSACTION_PLAN",
+      "Stake pulls must sum to the bridged amount.",
+      { pulledRao: total.toString(), amountRao: amountRao.toString() }
+    );
+  }
+  return resolved;
+}
+function encodeHubBridge(destSelector, token, recipient, taoAmount, stakedAlphaRao, minTokenOut, fee, pulls) {
+  if (pulls !== void 0) {
+    const args2 = [
+      destSelector,
+      token,
+      recipient,
+      taoAmount,
+      pulls,
+      minTokenOut
+    ];
+    return fee.bps === 0 ? encodeFunctionData({
+      abi: alphaAbi,
+      functionName: "bridgeOutFromValidators",
+      args: args2
+    }) : encodeFunctionData({
+      abi: alphaAbi,
+      functionName: "bridgeOutFromValidatorsWithFee",
+      args: [...args2, fee]
+    });
+  }
+  const args = [
+    destSelector,
+    token,
+    recipient,
+    taoAmount,
+    stakedAlphaRao,
+    minTokenOut
+  ];
+  return fee.bps === 0 ? encodeFunctionData({
+    abi: alphaAbi,
+    functionName: "bridgeOut",
+    args
+  }) : encodeFunctionData({
+    abi: alphaAbi,
+    functionName: "bridgeOutWithFee",
+    args: [...args, fee]
+  });
+}
+async function quoteSpokeWithFee(provider, gateway, token, amountWei, exit, fee) {
+  const maxBps = await provider.readContract({
+    address: gateway,
+    abi: spokeAbi,
+    functionName: "maxIntegratorFeeBps"
+  });
+  assertPartnerFeeAllowed(fee, maxBps);
+  const [networkFee] = await provider.readContract({
+    address: gateway,
+    abi: spokeAbi,
+    functionName: "quoteBridgeToFinneyWithFee",
+    args: [token, amountWei, exit, 0n, fee]
+  });
+  return networkFee;
+}
+async function quoteHubWithFee(provider, gateway, destSelector, token, recipient, mintedAmount, taoAmount, stakedAlphaRao, fee) {
+  const maxBps = await provider.readContract({
+    address: gateway,
+    abi: alphaAbi,
+    functionName: "maxIntegratorFeeBps"
+  });
+  assertPartnerFeeAllowed(fee, maxBps);
+  const [networkFee, taoTopUp, alphaTopUpRao, crossing] = await provider.readContract({
+    address: gateway,
+    abi: alphaAbi,
+    functionName: "quoteBridgeOutWithFee",
+    args: [
+      destSelector,
+      token,
+      recipient,
+      mintedAmount,
+      taoAmount,
+      stakedAlphaRao,
+      fee
+    ]
+  });
+  if (crossing !== mintedAmount || taoTopUp !== partnerFeeTaoTopUp(taoAmount, fee.bps) || alphaTopUpRao !== partnerFeeCut(stakedAlphaRao, fee.bps)) {
+    throw new ForeverMoneyError(
+      "INVALID_PROVIDER_RESPONSE",
+      "The gateway partner fee quote does not match the SDK fee calculation.",
+      {
+        crossing: crossing.toString(),
+        taoTopUp: taoTopUp.toString(),
+        alphaTopUpRao: alphaTopUpRao.toString()
+      }
+    );
+  }
+  return { networkFee, taoTopUp, alphaTopUpRao };
+}
 function buildEvmToSubtensorPlan(input) {
   const sender = normalizeEvmAddress(input.sender);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertDelivery(input.delivery);
+  assertAssetMode(input.asset, input.delivery);
   assertBaseToSubtensorAmount(input.amountWei, input.delivery);
   assertNonNegativeAmount(input.allowanceWei, "Token allowance");
   assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
@@ -564,19 +871,24 @@ function buildEvmToSubtensorPlan(input) {
     minTaoOut: input.amountWei
   };
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    evm.contracts.gateway
+  );
+  const cut = partnerFeeCut(input.amountWei, partnerFee.bps);
   const steps = [];
-  if (input.allowanceWei < input.amountWei) {
+  if (input.allowanceWei < input.amountWei + cut) {
     steps.push(
       transactionStep(
         "approval",
-        "Approve wrapped TAO for the ForeverMoney gateway",
+        `Approve ${asset.wrappedLabel} for the ForeverMoney gateway`,
         evm.chainId,
         sender,
-        evm.contracts.wrappedTao,
+        asset.evmToken,
         encodeFunctionData({
           abi: erc20Abi,
           functionName: "approve",
-          args: [evm.contracts.gateway, input.amountWei]
+          args: [evm.contracts.gateway, input.amountWei + cut]
         }),
         0n
       )
@@ -586,22 +898,23 @@ function buildEvmToSubtensorPlan(input) {
   steps.push(
     transactionStep(
       "transaction",
-      `Bridge wrapped TAO from ${evm.name} to Subtensor (${input.delivery})`,
+      `Bridge ${asset.wrappedLabel} from ${evm.name} to Subtensor (${input.delivery})`,
       evm.chainId,
       sender,
       evm.contracts.gateway,
-      encodeFunctionData({
-        abi: spokeAbi,
-        functionName: "bridgeToFinney",
-        args: [evm.contracts.wrappedTao, input.amountWei, exit]
-      }),
+      encodeSpokeBridge(
+        asset.evmToken,
+        input.amountWei,
+        exit,
+        partnerFee
+      ),
       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}.`,
+    summary: `Bridge ${input.amountWei} wei of ${asset.wrappedLabel} from ${evm.name} to ${destination}.${partnerFeeSummary(cut, asset.wrappedLabel, partnerFee)}`,
     steps
   });
 }
@@ -611,21 +924,23 @@ function buildBaseToSubtensorPlan(input) {
 function buildSubtensorToEvmPlan(input) {
   const sender = normalizeEvmAddress(input.sender);
   const recipient = normalizeEvmAddress(input.recipient);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertSource(input.source);
-  assertWholeRao(input.amountWei);
+  assertAssetMode(input.asset, input.source);
+  const netuid = sourceNetuid(input);
+  assertSubtensorToEvmAmount(input.amountWei, input.source);
   assertNonNegativeAmount(input.exactNetworkFeeWei, "Network fee");
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    subtensor.contracts.gateway
+  );
   const amountRao = input.amountWei / EVM_WEI_PER_RAO;
+  const alphaTopUpRao = input.source === "staked" ? partnerFeeCut(amountRao, partnerFee.bps) : 0n;
+  const taoTopUp = input.source === "liquid" ? partnerFeeTaoTopUp(input.amountWei, partnerFee.bps) : 0n;
   const steps = [];
   if (input.source === "staked") {
-    if (input.netuid === void 0) {
-      throw new ForeverMoneyError(
-        "INVALID_TRANSACTION_PLAN",
-        "A netuid is required when bridging staked TAO."
-      );
-    }
-    assertNonNegativeAmount(input.netuid, "netuid");
     if (input.stakingAllowanceRao === void 0) {
       throw new ForeverMoneyError(
         "INVALID_TRANSACTION_PLAN",
@@ -633,11 +948,11 @@ function buildSubtensorToEvmPlan(input) {
       );
     }
     assertNonNegativeAmount(input.stakingAllowanceRao, "Staking allowance");
-    if (input.stakingAllowanceRao < amountRao) {
+    if (input.stakingAllowanceRao < amountRao + alphaTopUpRao) {
       steps.push(
         transactionStep(
           "approval",
-          "Approve staked TAO for the ForeverMoney gateway",
+          `Approve staked ${asset.label} for the ForeverMoney gateway`,
           subtensor.chainId,
           sender,
           subtensor.contracts.stakingPrecompile,
@@ -646,8 +961,8 @@ function buildSubtensorToEvmPlan(input) {
             functionName: "approve",
             args: [
               subtensor.contracts.gateway,
-              input.netuid,
-              amountRao
+              netuid,
+              amountRao + alphaTopUpRao
             ]
           }),
           0n
@@ -662,34 +977,37 @@ function buildSubtensorToEvmPlan(input) {
   }
   const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
   const stakedAlphaRao = input.source === "staked" ? amountRao : 0n;
-  const value = taoAmount + feeWithBuffer(input.exactNetworkFeeWei);
+  const pulls = stakePullsFor(input, amountRao);
+  const value = taoAmount + taoTopUp + feeWithBuffer(input.exactNetworkFeeWei);
   assertNonNegativeAmount(value, "Transaction value");
   steps.push(
     transactionStep(
       "transaction",
-      `Bridge ${input.source} TAO from Subtensor to ${evm.name}`,
+      `Bridge ${input.source} ${asset.label} from Subtensor to ${evm.name}`,
       subtensor.chainId,
       sender,
       subtensor.contracts.gateway,
-      encodeFunctionData({
-        abi: alphaAbi,
-        functionName: "bridgeOut",
-        args: [
-          evm.ccipSelector,
-          subtensor.contracts.wrappedTao,
-          recipient,
-          taoAmount,
-          stakedAlphaRao,
-          input.amountWei
-        ]
-      }),
+      encodeHubBridge(
+        evm.ccipSelector,
+        asset.subtensorToken,
+        recipient,
+        taoAmount,
+        stakedAlphaRao,
+        input.amountWei,
+        partnerFee,
+        pulls
+      ),
       value,
       input.estimatedBridgeGas === void 0 ? void 0 : gasLimitWithBuffer(input.estimatedBridgeGas)
     )
   );
   return createTransactionPlan({
     action: evm.key === "base" ? "bridge.subtensor-to-base" : "bridge.subtensor-to-robinhood",
-    summary: `Bridge ${input.amountWei} wei of ${input.source} TAO from Subtensor to ${recipient} on ${evm.name}.`,
+    summary: `Bridge ${input.amountWei} wei of ${input.source} ${asset.label} from Subtensor to ${recipient} on ${evm.name}.${partnerFeeSummary(
+      input.source === "liquid" ? taoTopUp : alphaTopUpRao * EVM_WEI_PER_RAO,
+      input.source === "liquid" ? "TAO" : `staked ${asset.label}`,
+      partnerFee
+    )}`,
     steps
   });
 }
@@ -698,7 +1016,9 @@ function buildSubtensorToBasePlan(input) {
 }
 async function prepareEvmToSubtensor(provider, input) {
   const sender = normalizeEvmAddress(input.sender);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertDelivery(input.delivery);
+  assertAssetMode(input.asset, input.delivery);
   assertBaseToSubtensorAmount(input.amountWei, input.delivery);
   const destination = normalizeSS58(input.destination);
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
@@ -708,27 +1028,40 @@ async function prepareEvmToSubtensor(provider, input) {
     wantLiquid: input.delivery === "liquid",
     minTaoOut: input.amountWei
   };
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    evm.contracts.gateway
+  );
+  const cut = partnerFeeCut(input.amountWei, partnerFee.bps);
   const [allowanceWei, exactNetworkFeeWei] = await Promise.all([
     provider.readContract({
-      address: evm.contracts.wrappedTao,
+      address: asset.evmToken,
       abi: erc20Abi,
       functionName: "allowance",
       args: [sender, evm.contracts.gateway]
     }),
-    provider.readContract({
+    partnerFee.bps === 0 ? provider.readContract({
       address: evm.contracts.gateway,
       abi: spokeAbi,
       functionName: "quoteBridgeToFinney",
-      args: [evm.contracts.wrappedTao, input.amountWei, exit]
-    })
+      args: [asset.evmToken, input.amountWei, exit]
+    }) : quoteSpokeWithFee(
+      provider,
+      evm.contracts.gateway,
+      asset.evmToken,
+      input.amountWei,
+      exit,
+      partnerFee
+    )
   ]);
   let estimatedBridgeGas;
-  if (allowanceWei >= input.amountWei) {
-    const data = encodeFunctionData({
-      abi: spokeAbi,
-      functionName: "bridgeToFinney",
-      args: [evm.contracts.wrappedTao, input.amountWei, exit]
-    });
+  if (allowanceWei >= input.amountWei + cut) {
+    const data = encodeSpokeBridge(
+      asset.evmToken,
+      input.amountWei,
+      exit,
+      partnerFee
+    );
     estimatedBridgeGas = await provider.estimateGas({
       account: sender,
       to: evm.contracts.gateway,
@@ -745,6 +1078,7 @@ async function prepareEvmToSubtensor(provider, input) {
   return Object.freeze({
     exactNetworkFeeWei,
     transactionValueWei: feeWithBuffer(exactNetworkFeeWei),
+    partnerFeeWei: cut,
     plan
   });
 }
@@ -754,58 +1088,68 @@ function prepareBaseToSubtensor(provider, input) {
 async function prepareSubtensorToEvm(provider, input) {
   const sender = normalizeEvmAddress(input.sender);
   const recipient = normalizeEvmAddress(input.recipient);
+  const asset = bridgeAsset(input.evmChain, input.asset);
   assertSource(input.source);
-  assertWholeRao(input.amountWei);
+  assertAssetMode(input.asset, input.source);
+  const netuid = sourceNetuid(input);
+  assertSubtensorToEvmAmount(input.amountWei, input.source);
   const { subtensor } = foreverMoneyDeployment;
   const evm = getForeverMoneyEvmDeployment(input.evmChain);
-  const exactNetworkFeeWei = await provider.readContract({
+  const partnerFee = resolvePartnerFee(
+    input.partnerFee,
+    subtensor.contracts.gateway
+  );
+  const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
+  const stakedAlphaRao = input.source === "staked" ? input.amountWei / EVM_WEI_PER_RAO : 0n;
+  const exactNetworkFeeWei = partnerFee.bps === 0 ? await provider.readContract({
     address: subtensor.contracts.gateway,
     abi: alphaAbi,
     functionName: "quoteBridgeOut",
     args: [
       evm.ccipSelector,
-      subtensor.contracts.wrappedTao,
+      asset.subtensorToken,
       recipient,
       input.amountWei
     ]
-  });
+  }) : (await quoteHubWithFee(
+    provider,
+    subtensor.contracts.gateway,
+    evm.ccipSelector,
+    asset.subtensorToken,
+    recipient,
+    input.amountWei,
+    taoAmount,
+    stakedAlphaRao,
+    partnerFee
+  )).networkFee;
   let stakingAllowanceRao;
   if (input.source === "staked") {
-    if (input.netuid === void 0) {
-      throw new ForeverMoneyError(
-        "INVALID_TRANSACTION_PLAN",
-        "A netuid is required when bridging staked TAO."
-      );
-    }
-    assertNonNegativeAmount(input.netuid, "netuid");
     stakingAllowanceRao = await provider.readContract({
       address: subtensor.contracts.stakingPrecompile,
       abi: stakingAbi,
       functionName: "allowance",
-      args: [sender, subtensor.contracts.gateway, input.netuid]
+      args: [sender, subtensor.contracts.gateway, netuid]
     });
   }
-  const taoAmount = input.source === "liquid" ? input.amountWei : 0n;
-  const stakedAlphaRao = input.source === "staked" ? input.amountWei / EVM_WEI_PER_RAO : 0n;
-  const value = taoAmount + feeWithBuffer(exactNetworkFeeWei);
+  const alphaTopUpRao = partnerFeeCut(stakedAlphaRao, partnerFee.bps);
+  const taoTopUp = partnerFeeTaoTopUp(taoAmount, partnerFee.bps);
+  const value = taoAmount + taoTopUp + feeWithBuffer(exactNetworkFeeWei);
   assertNonNegativeAmount(value, "Transaction value");
   let estimatedBridgeGas;
-  if (input.source === "liquid" || stakingAllowanceRao !== void 0 && stakingAllowanceRao >= stakedAlphaRao) {
+  if (input.source === "liquid" || stakingAllowanceRao !== void 0 && stakingAllowanceRao >= stakedAlphaRao + alphaTopUpRao) {
     estimatedBridgeGas = await provider.estimateGas({
       account: sender,
       to: subtensor.contracts.gateway,
-      data: encodeFunctionData({
-        abi: alphaAbi,
-        functionName: "bridgeOut",
-        args: [
-          evm.ccipSelector,
-          subtensor.contracts.wrappedTao,
-          recipient,
-          taoAmount,
-          stakedAlphaRao,
-          input.amountWei
-        ]
-      }),
+      data: encodeHubBridge(
+        evm.ccipSelector,
+        asset.subtensorToken,
+        recipient,
+        taoAmount,
+        stakedAlphaRao,
+        input.amountWei,
+        partnerFee,
+        stakePullsFor(input, stakedAlphaRao)
+      ),
       value
     });
   }
@@ -818,6 +1162,7 @@ async function prepareSubtensorToEvm(provider, input) {
   return Object.freeze({
     exactNetworkFeeWei,
     transactionValueWei: value,
+    partnerFeeWei: input.source === "liquid" ? taoTopUp : alphaTopUpRao * EVM_WEI_PER_RAO,
     plan
   });
 }
@@ -1417,13 +1762,20 @@ function bridgeMessageIdFromReceipt(direction, receipt) {
     evmChainFromBridgeDirection(direction)
   );
   const evmToSubtensor = isEvmToSubtensorDirection(direction);
-  const [address, contractAbi, eventName] = evmToSubtensor ? [evm.contracts.gateway, spokeGatewayAbi, "BridgedToFinney"] : [
-    foreverMoneyDeployment.subtensor.contracts.gateway,
+  const [addresses, contractAbi, eventName] = evmToSubtensor ? [
+    [...evm.contracts.legacyGateways, evm.contracts.gateway],
+    spokeGatewayAbi,
+    "BridgedToFinney"
+  ] : [
+    [
+      ...foreverMoneyDeployment.subtensor.contracts.legacyGateways,
+      foreverMoneyDeployment.subtensor.contracts.gateway
+    ],
     alphaGatewayAbi,
     "BridgedOut"
   ];
   for (const log of receipt.logs) {
-    if (!isLogFrom(log, address)) continue;
+    if (!addresses.some((address) => isLogFrom(log, address))) continue;
     try {
       const parsed = decodeEventLog({
         abi: contractAbi,
@@ -1577,16 +1929,23 @@ async function getCcipDeliveryStatus(provider, input) {
       "The CCIP execution receipt is unavailable."
     );
   }
+  const subtensorGateways = [
+    ...foreverMoneyDeployment.subtensor.contracts.legacyGateways,
+    foreverMoneyDeployment.subtensor.contracts.gateway
+  ];
   for (const log of receipt.logs) {
-    if (log.address.toLowerCase() !== foreverMoneyDeployment.subtensor.contracts.gateway.toLowerCase()) {
+    if (!subtensorGateways.some(
+      (gateway) => log.address.toLowerCase() === gateway.toLowerCase()
+    )) {
       continue;
     }
     try {
-      if (decodeEventLog2({
+      const { eventName } = decodeEventLog2({
         abi: alphaGatewayAbi2,
         data: log.data,
         topics: log.topics
-      }).eventName === "Claimable") {
+      });
+      if (eventName === "Claimable" || eventName === "NotDelivered") {
         return "recovery";
       }
     } catch {
@@ -1872,12 +2231,16 @@ export {
   FOREVERMONEY_DEPLOYMENT_VERSION,
   ForeverMoneyError,
   GAS_LIMIT_BUFFER_BPS,
+  MAX_PARTNER_FEE_BPS,
+  MAX_STAKE_PULLS,
   MIN_LIQUID_BASE_TO_SUBTENSOR_WEI,
   MIN_LIQUID_EVM_TO_SUBTENSOR_WEI,
+  MIN_LIQUID_SUBTENSOR_TO_EVM_WEI,
   NETWORK_FEE_BUFFER_BPS,
   RAO_PER_TAO,
   ROBINHOOD_CCIP_SELECTOR,
   ROBINHOOD_CHAIN_ID,
+  SN80_NETUID,
   SUBTENSOR_CCIP_SELECTOR,
   SUBTENSOR_CHAIN_ID,
   assertWholeRao,
@@ -1910,6 +2273,8 @@ export {
   normalizeEvmAddress,
   normalizeSS58,
   parseTaoAmount,
+  partnerFeeCut,
+  partnerFeeTaoTopUp,
   sourceChainId,
   ss58ToPublicKey,
   toEip1193Transaction,