@hyperbridge/simplex 0.17.1 → 0.18.0

package/dist/index.js

@@ -4,7 +4,8 @@ import { createRequire } from 'module'; const require = createRequire(import.met
 import { EventEmitter as EventEmitter4 } from "node:events";
 
 // src/core/boot.ts
-import { formatUnits as formatUnits6 } from "viem";
+import { join } from "node:path";
+import { formatUnits as formatUnits7, toHex as toHex5 } from "viem";
 
 // src/core/filler.ts
 import { keccakAsU8a } from "@polkadot/util-crypto";
@@ -707,92 +708,6 @@ var AssetRegistry = class {
   }
 };
 
-// src/config/pairs.ts
-var RETIRED_PAIR_KEYS = ["bidPriceCurve", "askPriceCurve", "maxOrderSize", "referenceOnly"];
-function retiredPairKeys(pairs) {
-  const carried = /* @__PURE__ */ new Set();
-  for (const pair of pairs) {
-    for (const key of RETIRED_PAIR_KEYS) {
-      if (pair[key] !== void 0) carried.add(key);
-    }
-  }
-  return RETIRED_PAIR_KEYS.filter((key) => carried.has(key));
-}
-function isKnownSymbol(symbol, userAssets) {
-  const normalized = normalizeSymbol(symbol);
-  if (isRegistrySymbol(normalized)) return true;
-  return Object.keys(userAssets ?? {}).some((key) => normalizeSymbol(key) === normalized);
-}
-function assertPairSymbolsResolve(pairs, registry, chainNames) {
-  const pairSymbols = new Set(pairs.flatMap((pair) => [pair.token0, pair.token1]));
-  for (const pair of pairs) {
-    for (const symbol of [pair.token0, pair.token1]) {
-      const resolvesSomewhere = chainNames.some((chainName2) => registry.getAddress(symbol, chainName2) !== null);
-      if (!resolvesSomewhere) {
-        throw new Error(
-          `pairs.${pair.token0}/${pair.token1}: '${symbol}' does not resolve to a deployed contract on any configured chain`
-        );
-      }
-    }
-  }
-  for (const chainName2 of chainNames) {
-    const addressOwner = /* @__PURE__ */ new Map();
-    for (const symbol of pairSymbols) {
-      const address = registry.getAddress(symbol, chainName2)?.toLowerCase();
-      if (!address) continue;
-      const owner = addressOwner.get(address);
-      if (owner && normalizeSymbol(owner) !== normalizeSymbol(symbol)) {
-        throw new Error(
-          `assets: '${symbol}' and '${owner}' both resolve to ${address} on ${chainName2} \u2014 symbols must map to distinct contracts`
-        );
-      }
-      addressOwner.set(address, symbol);
-    }
-  }
-}
-function pickAnchorStable(pairs, symbol) {
-  const target = normalizeSymbol(symbol);
-  for (const stable of USD_STABLE_SYMBOLS) {
-    const taken = pairs.some((pair) => {
-      const token0 = normalizeSymbol(pair.token0);
-      const token1 = normalizeSymbol(pair.token1);
-      return token0 === stable && token1 === target || token0 === target && token1 === stable;
-    });
-    if (!taken) return stable;
-  }
-  return null;
-}
-function validatePairConfigs(pairs, userAssets) {
-  if (!Array.isArray(pairs) || pairs.length === 0) {
-    throw new Error("pairs: at least one [[pairs]] entry is required");
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const pair of pairs) {
-    if (!pair.token0 || !pair.token1) {
-      throw new Error("pairs: each entry needs 'token0' and 'token1' symbols");
-    }
-    const token0 = normalizeSymbol(pair.token0);
-    const token1 = normalizeSymbol(pair.token1);
-    const label = `${token0}/${token1}`;
-    if (seen.has(label)) {
-      throw new Error(`pairs.${label}: pair is declared twice`);
-    }
-    if (seen.has(`${token1}/${token0}`)) {
-      throw new Error(
-        `pairs.${label}: ${token1}/${token0} is already declared \u2014 a market has one orientation, and a limit order on either side trades it`
-      );
-    }
-    seen.add(label);
-    for (const symbol of [token0, token1]) {
-      if (!isKnownSymbol(symbol, userAssets)) {
-        throw new Error(
-          `pairs.${label}: unknown symbol '${symbol}' \u2014 the registry ships ${registrySymbols().join(", ")}; anything else needs an [assets.${symbol}] entry`
-        );
-      }
-    }
-  }
-}
-
 // src/config/abis/ERC20.ts
 var ERC20_ABI = [
   {
@@ -1610,7 +1525,7 @@ function validateOrderbookConfig(orderbook) {
 function validateConfig(config, cliWatchOnly = false) {
   if ("strategies" in config) {
     throw new Error(
-      "[[strategies]] was removed \u2014 declare top-level [[pairs]] instead (a same-token pair like USDC/USDC with an ask curve below par replaces the stable strategy; engine settings moved to [confirmationPolicies])"
+      "[[strategies]] was removed \u2014 simplex prices every fill from the limit orders you post. Run `simplex init` to migrate this config; per-strategy confirmation policies move to [confirmationPolicies]"
     );
   }
   const allChainsWatchOnly2 = cliWatchOnly || config.simplex?.watchOnly === true;
@@ -1675,9 +1590,6 @@ function validateConfig(config, cliWatchOnly = false) {
   if (config.assets) {
     validateAssetDefinitions(config.assets);
   }
-  if ((config.pairs?.length ?? 0) > 0) {
-    validatePairConfigs(config.pairs, config.assets);
-  }
   if (config.confirmationPolicies) {
     void new ConfirmationPolicy(config.confirmationPolicies);
   }
@@ -18437,15 +18349,19 @@ import {
   formatEther,
   maxUint256 as maxUint2562,
   erc20Abi as erc20Abi2,
-  BaseError,
-  ContractFunctionRevertedError,
-  ContractFunctionZeroDataError
+  BaseError as BaseError2,
+  ContractFunctionRevertedError as ContractFunctionRevertedError2,
+  ContractFunctionZeroDataError as ContractFunctionZeroDataError2
 } from "viem";
 
 // src/services/paymaster/types.ts
 import { encodePacked } from "viem";
 var RECOMMENDED_AMOUNT_USD = 5n;
 var VERIFICATION_GAS_LIMIT_PERMIT2 = 200000n;
+var PERMIT2_VERIFICATION_GAS_BY_CHAIN = { 137: 300000n };
+function permit2VerificationGasLimit(chainId) {
+  return PERMIT2_VERIFICATION_GAS_BY_CHAIN[chainId] ?? VERIFICATION_GAS_LIMIT_PERMIT2;
+}
 var VERIFICATION_GAS_LIMIT_PERMIT = 250000n;
 var PERMIT2_DEADLINE_SECONDS = 3600n;
 var POST_OP_GAS_LIMIT_SIMPLEX = 40000n;
@@ -18458,7 +18374,15 @@ function packPaymasterAndData(pm) {
 }
 
 // src/services/paymaster/permit.ts
-import { maxUint256, getContract } from "viem";
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  hashDomain,
+  maxUint256,
+  pad,
+  toHex as toHex2
+} from "viem";
 
 // src/config/abis/EIP2612.ts
 import { erc20Abi } from "viem";
@@ -18477,6 +18401,13 @@ var EIP2612_ABI = [
     outputs: [{ internalType: "string", name: "", type: "string" }],
     stateMutability: "view",
     type: "function"
+  },
+  {
+    inputs: [],
+    name: "DOMAIN_SEPARATOR",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
   }
 ];
 
@@ -18544,25 +18475,73 @@ function normalizeSignature65(signature) {
 }
 
 // src/services/paymaster/permit.ts
+var DOMAIN_SHAPES = [
+  {
+    fields: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ],
+    domain: (name, version, chainId, verifyingContract) => ({ name, version, chainId, verifyingContract })
+  },
+  // USDT0 on Polygon: the chain id goes in a salt instead of a chainId field.
+  {
+    fields: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" }
+    ],
+    domain: (name, version, chainId, verifyingContract) => ({
+      name,
+      version,
+      verifyingContract,
+      salt: pad(toHex2(chainId), { size: 32 })
+    })
+  }
+];
+var FALLBACK_VERSIONS = ["1", "2"];
+async function readIfPresent(read) {
+  try {
+    return await read();
+  } catch (error) {
+    const isRevert = error instanceof BaseError && error.walk((e) => e instanceof ContractFunctionRevertedError || e instanceof ContractFunctionZeroDataError);
+    if (isRevert) return void 0;
+    throw error;
+  }
+}
+async function resolvePermitDomain(client, tokenAddress, chainId) {
+  const read = (functionName) => readIfPresent(() => client.readContract({ address: tokenAddress, abi: EIP2612_ABI, functionName }));
+  const separator = await read("DOMAIN_SEPARATOR");
+  if (!separator) return null;
+  const name = await read("name");
+  if (name === void 0) return null;
+  const version = await read("version");
+  for (const candidate of version === void 0 ? FALLBACK_VERSIONS : [version]) {
+    for (const shape of DOMAIN_SHAPES) {
+      const domain = shape.domain(name, candidate, chainId, tokenAddress);
+      const hash = hashDomain({ domain, types: { EIP712Domain: shape.fields } });
+      if (hash.toLowerCase() === separator.toLowerCase()) return { domain, fields: shape.fields };
+    }
+  }
+  return null;
+}
 async function signEip2612Permit(client, signer, owner, spender, tokenAddress, value, chainId) {
-  const token = getContract({
-    client,
+  const permitDomain = await resolvePermitDomain(client, tokenAddress, chainId);
+  if (!permitDomain) {
+    throw new Error(`${tokenAddress} on chain ${chainId} has no EIP-2612 permit domain Simplex can sign for`);
+  }
+  const nonce = await client.readContract({
     address: tokenAddress,
-    abi: EIP2612_ABI
+    abi: EIP2612_ABI,
+    functionName: "nonces",
+    args: [owner]
   });
-  const [name, version, nonce] = await Promise.all([
-    token.read.name(),
-    token.read.version(),
-    token.read.nonces([owner])
-  ]);
   const typedData = {
     types: {
-      EIP712Domain: [
-        { name: "name", type: "string" },
-        { name: "version", type: "string" },
-        { name: "chainId", type: "uint256" },
-        { name: "verifyingContract", type: "address" }
-      ],
+      // Listed explicitly: custody backends hash the domain from this entry, not from `domain`.
+      EIP712Domain: permitDomain.fields,
       Permit: [
         { name: "owner", type: "address" },
         { name: "spender", type: "address" },
@@ -18572,12 +18551,7 @@ async function signEip2612Permit(client, signer, owner, spender, tokenAddress, v
       ]
     },
     primaryType: "Permit",
-    domain: {
-      name,
-      version,
-      chainId,
-      verifyingContract: tokenAddress
-    },
+    domain: permitDomain.domain,
     message: {
       owner,
       spender,
@@ -18651,7 +18625,7 @@ async function buildSimplexPaymasterData(client, walletClient, signer, solverAcc
     );
   }
   if (permit2Allowance < recommended) {
-    if (permitBootstrap && await tokenSupportsPermit(client, tokenAddress)) {
+    if (permitBootstrap && await tokenSupportsPermit(client, tokenAddress, chainId)) {
       const pm = await buildPermitMode(
         client,
         signer,
@@ -18687,7 +18661,7 @@ async function resolvePendingPermit2Approval(client, solverAccount, paymasterAdd
   return {
     token: selected.address,
     spender: permit2,
-    permitCapable: await tokenSupportsPermit(client, selected.address)
+    permitCapable: await tokenSupportsPermit(client, selected.address, configService.getChainId(chain))
   };
 }
 function isConfigured(address) {
@@ -18707,7 +18681,7 @@ function configuredFeeTokens(chain, configService) {
 }
 async function selectToken(client, solverAccount, tokens, permit2) {
   const balances = [];
-  let fallback2 = null;
+  let fallback3 = null;
   for (const token of tokens) {
     const balance = await client.readContract({
       address: token.address,
@@ -18721,12 +18695,12 @@ async function selectToken(client, solverAccount, tokens, permit2) {
       const permit2Allowance = await readAllowance(client, token.address, solverAccount, permit2);
       const candidate = { ...token, permit2Allowance };
       if (permit2Allowance >= RECOMMENDED_AMOUNT_USD * required) return { selected: candidate, balances };
-      fallback2 ?? (fallback2 = candidate);
+      fallback3 ?? (fallback3 = candidate);
     } else {
       balances.push({ symbol: token.symbol, balance, required });
     }
   }
-  return { selected: fallback2, balances };
+  return { selected: fallback3, balances };
 }
 var PERMIT2_SUPPORT_NEGATIVE_TTL_MS = 5 * 6e4;
 var permit2Support = /* @__PURE__ */ new Map();
@@ -18741,7 +18715,7 @@ async function paymasterSupportsPermit2(client, chainId, paymasterAddress) {
     permit2Support.set(key, { supported: true, checkedAt: Date.now() });
     return true;
   } catch (error) {
-    const isRevert = error instanceof BaseError && error.walk((e) => e instanceof ContractFunctionRevertedError || e instanceof ContractFunctionZeroDataError);
+    const isRevert = error instanceof BaseError2 && error.walk((e) => e instanceof ContractFunctionRevertedError2 || e instanceof ContractFunctionZeroDataError2);
     if (isRevert) {
       permit2Support.set(key, { supported: false, checkedAt: Date.now() });
       return false;
@@ -18779,7 +18753,7 @@ async function buildPermit2Mode(signer, p) {
   return {
     paymaster: p.spender,
     paymasterData,
-    paymasterVerificationGasLimit: VERIFICATION_GAS_LIMIT_PERMIT2,
+    paymasterVerificationGasLimit: permit2VerificationGasLimit(p.chainId),
     paymasterPostOpGasLimit: POST_OP_GAS_LIMIT_SIMPLEX
   };
 }
@@ -18849,27 +18823,8 @@ async function sendApproveTx(client, walletClient, tokenAddress, spender, amount
   });
   await client.waitForTransactionReceipt({ hash, confirmations: 2 });
 }
-async function tokenSupportsPermit(client, tokenAddress) {
-  try {
-    await client.readContract({
-      address: tokenAddress,
-      abi: [
-        {
-          inputs: [],
-          name: "version",
-          outputs: [{ type: "string" }],
-          stateMutability: "view",
-          type: "function"
-        }
-      ],
-      functionName: "version"
-    });
-    return true;
-  } catch (error) {
-    const isRevert = error instanceof BaseError && error.walk((e) => e instanceof ContractFunctionRevertedError || e instanceof ContractFunctionZeroDataError);
-    if (isRevert) return false;
-    throw error;
-  }
+async function tokenSupportsPermit(client, tokenAddress, chainId) {
+  return await resolvePermitDomain(client, tokenAddress, chainId) !== null;
 }
 
 // src/services/paymaster/index.ts
@@ -18885,7 +18840,7 @@ async function buildPaymasterAndData(options) {
   const shortfall = await depositShortfall(
     options,
     simplexAddr,
-    (permitBootstrap ? VERIFICATION_GAS_LIMIT_PERMIT : VERIFICATION_GAS_LIMIT_PERMIT2) + POST_OP_GAS_LIMIT_SIMPLEX
+    (permitBootstrap ? VERIFICATION_GAS_LIMIT_PERMIT : permit2VerificationGasLimit(configService.getChainId(chain))) + POST_OP_GAS_LIMIT_SIMPLEX
   );
   if (shortfall) {
     return { paymasterAndData: "0x", type: "none", reason: shortfall };
@@ -19677,12 +19632,12 @@ var ContractInteractionService = class {
     const declared = declaredMs ? declaredMs / 1e3 : void 0;
     const seconds = this.measureBlockTimeSeconds(client).then((measured) => declared ? Math.min(measured, declared) : measured).catch((err) => {
       this.blockTimes.delete(chain);
-      const fallback2 = declared ?? FALLBACK_BLOCK_TIME_SECONDS;
+      const fallback3 = declared ?? FALLBACK_BLOCK_TIME_SECONDS;
       this.logger.warn(
-        { err, chain, seconds: fallback2 },
+        { err, chain, seconds: fallback3 },
         "Could not measure the block time; using the declared one"
       );
-      return fallback2;
+      return fallback3;
     });
     this.blockTimes.set(chain, seconds);
     return seconds;
@@ -19877,7 +19832,7 @@ import {
   BundlerMethod,
   rundlerUserOperationFees
 } from "@hyperbridge/sdk";
-import { toHex as toHex2 } from "viem";
+import { toHex as toHex3 } from "viem";
 var FALLBACK_VERIFICATION_GAS_LIMIT = 250000n;
 var FALLBACK_CALL_GAS_LIMIT = 1500000n;
 var FALLBACK_PRE_VERIFICATION_GAS = 150000n;
@@ -19952,11 +19907,11 @@ var UserOpSender = class {
     });
     const formattedAuth = auth ? {
       address: auth.address,
-      chainId: toHex2(auth.chainId),
-      nonce: toHex2(auth.nonce),
+      chainId: toHex3(auth.chainId),
+      nonce: toHex3(auth.nonce),
       r: auth.r,
       s: auth.s,
-      yParity: toHex2(auth.yParity)
+      yParity: toHex3(auth.yParity)
     } : void 0;
     const { verificationGasLimit, callGasLimit, preVerificationGas } = gas ?? await this.estimateGas({
       bundlerUrl,
@@ -22886,18 +22841,17 @@ function adjustDecimalsFloor(amount, fromDecimals, toDecimals) {
   if (fromDecimals < toDecimals) return amount * BigInt(10 ** (toDecimals - fromDecimals));
   return amount / BigInt(10 ** (fromDecimals - toDecimals));
 }
-var FXFiller = class _FXFiller {
+var FXFiller = class {
   /**
    * @param signer          Filler's signing account for UserOp signatures.
    * @param configService   Network/config provider for addresses and decimals.
    * @param clientManager   Used to get viem PublicClients for chains.
    * @param contractService Shared contract interaction service.
-   * @param pairs           Trading pairs with their bid/ask price policies and per-order caps.
-   * @param registry        Asset symbol registry resolving pair symbols per chain.
+   * @param registry        Asset symbol registry resolving symbols per chain.
    * @param options.confirmationPolicy Optional per-chain confirmation policy for cross-chain orders.
    * @param options.fundingVenues  Optional funding venues for on-chain liquidity sourcing.
    */
-  constructor(signer, configService, clientManager, contractService, pairs, registry, options) {
+  constructor(signer, configService, clientManager, contractService, registry, options) {
     this.name = "FXFiller";
     /**
      * Consecutive orders where the overfill clamp activated. Dormant: the clamp
@@ -22910,17 +22864,9 @@ var FXFiller = class _FXFiller {
     this.logger = moduleLogger(configService.loggers, "fx-simplex");
     const { confirmationPolicy, fundingVenues = [], limitOrders } = options ?? {};
     this.limitOrders = limitOrders;
-    if (pairs.length === 0) {
-      throw new Error("FXFiller requires at least one trading pair");
-    }
-    const seenPairs = /* @__PURE__ */ new Set();
-    for (const pair of pairs) {
-      _FXFiller.assertPairValid(pair, seenPairs);
-    }
     this.configService = configService;
     this.clientManager = clientManager;
     this.contractService = contractService;
-    this.pairs = pairs;
     this.registry = registry;
     this.fundingVenues = fundingVenues;
     this.signer = signer;
@@ -22932,43 +22878,6 @@ var FXFiller = class _FXFiller {
       };
     }
   }
-  /** Per-pair invariants, shared by the constructor and addPair. Adds the accepted pair's label to `seenPairs`. */
-  static assertPairValid(pair, seenPairs) {
-    const label = `${normalizeSymbol(pair.token0)}/${normalizeSymbol(pair.token1)}`;
-    const reversed = `${normalizeSymbol(pair.token1)}/${normalizeSymbol(pair.token0)}`;
-    if (seenPairs.has(label) || seenPairs.has(reversed)) {
-      throw new Error(
-        `FXFiller pair ${pair.token0}/${pair.token1}: duplicate market (a pair and its reverse are the same market)`
-      );
-    }
-    seenPairs.add(label);
-  }
-  /**
-   * Adds a market to the running engine. All-or-nothing: the pair passes the
-   * same duplicate and reverse-orientation checks the constructor enforces
-   * before it is pushed.
-   */
-  addPair(pair) {
-    const seenPairs = new Set(this.pairs.map((p) => `${normalizeSymbol(p.token0)}/${normalizeSymbol(p.token1)}`));
-    _FXFiller.assertPairValid(pair, seenPairs);
-    this.pairs.push(pair);
-  }
-  /**
-   * Removes a market from the running engine. At least one market must remain.
-   * Matching reads the limit orders rather than the pairs, so removing a market
-   * changes what the dashboard lists, not what the filler fills.
-   */
-  removePair(pair) {
-    const index = this.pairs.indexOf(pair);
-    if (index < 0) {
-      throw new Error(`FXFiller pair ${pair.token0}/${pair.token1}: not a live market`);
-    }
-    const remaining = this.pairs.filter((_, i) => i !== index);
-    if (remaining.length === 0) {
-      throw new Error("FXFiller requires at least one trading pair \u2014 the last market cannot be removed live");
-    }
-    this.pairs.splice(index, 1);
-  }
   // =========================================================================
   // Lifecycle
   // =========================================================================
@@ -23659,7 +23568,7 @@ function minBigInt(first, ...rest) {
 
 // src/services/TokenSender.ts
 import { encodeERC7821ExecuteBatch as encodeERC7821ExecuteBatch4 } from "@hyperbridge/sdk";
-import { encodeFunctionData as encodeFunctionData4, isAddress as isAddress3, parseUnits as parseUnits4 } from "viem";
+import { encodeFunctionData as encodeFunctionData4, isAddress as isAddress3, maxUint256 as maxUint2565, parseUnits as parseUnits4 } from "viem";
 var TokenSender = class {
   constructor(clientManager, solver, getVaults, userOpSender, configService) {
     this.clientManager = clientManager;
@@ -23731,7 +23640,7 @@ var TokenSender = class {
         });
       }
     }
-    const result = await this.submit(chain, calls);
+    const result = await this.submitCalls(chain, calls);
     this.logger.warn({ chain, token, amount, to, redeemed, ...result }, "Operator send executed");
     return { ...result, redeemed };
   }
@@ -23787,16 +23696,23 @@ var TokenSender = class {
     }
     return null;
   }
-  async submit(chain, calls) {
+  /**
+   * Executes a batch from the filler wallet: sponsored UserOp first, native tx
+   * when no sponsor is available. Shared by every operator-initiated outbound flow.
+   */
+  async submitCalls(chain, calls) {
     if (this.userOpSender?.canSponsor(chain)) {
+      const bootstrap = await this.permit2Bootstrap(chain);
+      const batch = bootstrap ? [bootstrap, ...calls] : calls;
       const result = await this.userOpSender.trySendSponsored({
         chain,
-        callData: encodeERC7821ExecuteBatch4(calls),
+        callData: encodeERC7821ExecuteBatch4(batch),
         gas: {
           verificationGasLimit: 60000n,
-          callGasLimit: 450000n * BigInt(calls.length),
+          callGasLimit: 450000n * BigInt(batch.length),
           preVerificationGas: 150000n
-        }
+        },
+        permitBootstrap: !!bootstrap
       });
       if (result) return { txHash: result.txHash, sponsored: true };
       this.logger.warn({ chain }, "Sponsored send unavailable, sending native tx");
@@ -23818,7 +23734,1031 @@ var TokenSender = class {
     if (receipt.status !== "success") throw new Error(`Send tx reverted: ${tx}`);
     return { txHash: tx, sponsored: false };
   }
+  /**
+   * The `approve(Permit2, max)` to run first when the wallet has never approved Permit2 for its fee
+   * token on this chain, and that token has an EIP-2612 permit. The op then pays its gas with a permit
+   * and installs the approval, so a wallet with no native can still send; later ops use Permit2.
+   * Undefined otherwise, or when the check fails, and the send goes ahead as before.
+   */
+  async permit2Bootstrap(chain) {
+    const paymaster = this.configService?.getSimplexPaymasterAddress(chain);
+    if (!this.configService || !paymaster) return void 0;
+    try {
+      const pending = await resolvePendingPermit2Approval(
+        this.clientManager.getPublicClient(chain),
+        this.solver,
+        paymaster,
+        chain,
+        this.configService
+      );
+      if (!pending?.permitCapable) return void 0;
+      return {
+        target: pending.token,
+        value: 0n,
+        data: encodeFunctionData4({
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [pending.spender, maxUint2565]
+        })
+      };
+    } catch (error) {
+      this.logger.warn({ chain, error }, "Could not check whether this send must install the Permit2 approval");
+      return void 0;
+    }
+  }
+};
+
+// src/services/BridgeTopUp.ts
+import {
+  bytes20ToBytes32 as bytes20ToBytes323,
+  deriveCanonicalPlacedOrder,
+  IntentGatewayABI,
+  createQueryClient,
+  EvmChain as EvmChain2,
+  getChainId as getChainId4,
+  HyperFungibleTokenABI,
+  IntentGateway as IntentGateway2,
+  IsmpClient,
+  SubstrateChain
+} from "@hyperbridge/sdk";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { setTimeout as sleep } from "node:timers/promises";
+import {
+  createPublicClient as createPublicClient3,
+  encodeAbiParameters,
+  encodeFunctionData as encodeFunctionData5,
+  fallback as fallback2,
+  formatUnits as formatUnits5,
+  http as http3,
+  parseEventLogs as parseEventLogs2,
+  parseUnits as parseUnits5,
+  stringToHex,
+  toHex as toHex4
+} from "viem";
+import { bsc as bscChain } from "viem/chains";
+var SIMPLEX_REFERRER = stringToHex("Simplex", { size: 32 });
+var BRIDGE_TOP_UP_CHAIN = "EVM-56";
+var BRIDGE_TOKEN_BSC = "0x5b0c50fDd52ECC0d4c682c441eaBaD41FfDEABBB";
+var BRIDGE_DECIMALS = 18;
+var NEXUS_STATE_MACHINE = "POLKADOT-3367";
+var NEXUS_CONSENSUS_STATE = "DOT0";
+var NEXUS_WS_URL = "wss://nexus.rpc.polytope.technology";
+var NEXUS_UNIT = 10n ** 6n;
+var QUOTE_SLIPPAGE_BPS = 100n;
+var ORDER_WINDOW_SECONDS = 30 * 60;
+var AUCTION_TIME_MS = 15e3;
+var REFUND_POLL_MS = 1e4;
+var RECEIPT_TIMEOUT_MS = 12e4;
+var MAX_EVENTS = 50;
+var DELIVERY_POLL_MS = 15e3;
+var DELIVERY_RETRY_MS = 6e4;
+var SELF_RELAY_GRACE_MS = 9e4;
+var RELAYER_DELIVERY_WAIT_MS = 3 * 6e4;
+var STATUS_BACKFILL_MS = 30 * 6e4;
+var NETWORK_TIMEOUT_MS = 3e4;
+var LOG_CHUNK_BLOCKS = 300n;
+var FILL_SEARCH_BEFORE_MS = 3 * 6e4;
+var FILL_SEARCH_AFTER_MS = 6e4;
+var ORDER_FILLED_EVENT = IntentGatewayABI.find(
+  (item) => item.type === "event" && item.name === "OrderFilled"
+);
+var DELIVERY_REQUEST_QUERY = `query TopUpDelivery($hash: String!) {
+	requestV2s(
+		filter: {
+			source: { equalTo: "EVM-56" }
+			dest: { equalTo: "POLKADOT-3367" }
+			statusMetadata: { some: { transactionHash: { equalTo: $hash } } }
+		}
+	) {
+		nodes { commitment }
+	}
+}`;
+var ORDER_QUERY2 = `query TopUpOrder($commitment: String!) {
+	iOrderV3s(filter: { commitment: { equalTo: $commitment } }) {
+		nodes {
+			status
+			statusMetadata { nodes { status timestamp transactionHash filler } }
+		}
+	}
+}`;
+var CALL_TUPLE = [
+  {
+    type: "tuple[]",
+    components: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ]
+  }
+];
+var PENDING_STAGES = /* @__PURE__ */ new Set([
+  "placing",
+  "awaiting_bids",
+  "filling",
+  "delivering",
+  "unfilled",
+  "reclaiming"
+]);
+function isBridgeTopUpPending(stage) {
+  return PENDING_STAGES.has(stage);
+}
+function encodeBridgeTopUpCall(bridgeToken, recipient, amount) {
+  const data = encodeFunctionData5({
+    abi: HyperFungibleTokenABI,
+    functionName: "send",
+    args: [
+      {
+        dest: toHex4(NEXUS_STATE_MACHINE),
+        to: recipient,
+        amount,
+        timeout: 0n,
+        relayerFee: 0n,
+        data: "0x"
+      }
+    ]
+  });
+  return encodeAbiParameters(CALL_TUPLE, [[{ to: bridgeToken, value: 0n, data }]]);
+}
+function bidPreview(bid) {
+  return {
+    solverAddress: bid.solverAddress,
+    outputs: bid.outputs.map((output) => ({ token: output.token, amount: output.amount.toString() }))
+  };
+}
+function bridgeTopUpOutput(quotedOut) {
+  const afterSlippage = quotedOut * (10000n - QUOTE_SLIPPAGE_BPS) / 10000n;
+  return afterSlippage / NEXUS_UNIT * NEXUS_UNIT;
+}
+function serializeOrder(order) {
+  return JSON.stringify(order, (_key, value) => typeof value === "bigint" ? { $bigint: value.toString() } : value);
+}
+function deserializeOrder(json) {
+  return JSON.parse(
+    json,
+    (_key, value) => value && typeof value === "object" && typeof value.$bigint === "string" ? BigInt(value.$bigint) : value
+  );
+}
+var BridgeTopUp = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.gateways = /* @__PURE__ */ new Map();
+    /** Serializes state writes so a later stage never lands before an earlier one. */
+    this.writes = Promise.resolve();
+    this.logger = moduleLogger(deps.loggers, "bridge-top-up");
+  }
+  get bridgeToken() {
+    return this.deps.configService.getAssetBySymbol(BRIDGE_TOP_UP_CHAIN, "BRIDGE") ?? BRIDGE_TOKEN_BSC;
+  }
+  /** Loads the stored top-up and resumes driving it when it was left open. Never rejects. */
+  restore() {
+    this.loaded ?? (this.loaded = (async () => {
+      try {
+        this.record = (await this.deps.state.get()).bridgeTopUp;
+      } catch (err) {
+        this.logger.warn({ err }, "Could not read the stored BRIDGE top-up");
+        return;
+      }
+      const record = this.record;
+      if (record?.stage === "failed" && record.placeTxHash && !record.commitment && record.sessionPrivateKey) {
+        void this.recoverPlacement();
+        return;
+      }
+      if (!record || !isBridgeTopUpPending(record.stage)) return;
+      if (record.stage === "placing" && !record.placeTxHash) {
+        await this.update({
+          stage: "failed",
+          error: "Simplex restarted before the order was placed. Nothing was escrowed."
+        });
+        return;
+      }
+      if (record.stage === "placing") {
+        void this.recoverPlacement();
+        return;
+      }
+      if (record.stage === "awaiting_bids" || record.stage === "filling") void this.resumeOrder();
+      if (record.stage === "reclaiming") void this.driveReclaim();
+      if (record.stage === "delivering") void this.resumeDelivery();
+    })());
+    return this.loaded;
+  }
+  async current() {
+    await this.restore();
+    return this.record ? publicState(this.record) : void 0;
+  }
+  /** Networks the filler runs and has delegated its account on. */
+  async sourceChains() {
+    const chainIds = this.deps.configService.getConfiguredChainIds();
+    const delegated = await Promise.all(
+      chainIds.map((chainId) => this.deps.delegation.isDelegated(`EVM-${chainId}`).catch(() => false))
+    );
+    return chainIds.filter((_, index) => delegated[index]);
+  }
+  /** USDC and USDT wallet balances on every network a top-up can be paid from. */
+  async sources() {
+    const rows = (await this.sourceChains()).flatMap(
+      (chainId) => ["USDC", "USDT"].map(async (token) => {
+        const chain = `EVM-${chainId}`;
+        let tokenAddress;
+        let decimals;
+        try {
+          ;
+          ({ tokenAddress, decimals } = this.payToken(chain, token));
+        } catch {
+          return void 0;
+        }
+        const reserve = this.reserve(chain, tokenAddress);
+        const row = { chain, chainId, token, address: tokenAddress, reserve: formatUnits5(reserve, decimals) };
+        try {
+          const balance = await this.walletBalance(chain, tokenAddress);
+          return {
+            ...row,
+            balance: formatUnits5(balance, decimals),
+            spendable: formatUnits5(balance > reserve ? balance - reserve : 0n, decimals)
+          };
+        } catch (err) {
+          this.logger.debug({ err, chain, token }, "Could not read a top-up source balance");
+          return { ...row, balance: null, spendable: null };
+        }
+      })
+    );
+    return (await Promise.all(rows)).filter((row) => row !== void 0);
+  }
+  async quote(params) {
+    const { tokenAddress, decimals } = this.payToken(params.chain, params.token);
+    const amountIn = parseUnits5(params.amount, decimals);
+    if (amountIn <= 0n) throw new Error("Amount must be greater than 0");
+    const gateway = await this.gateway(params.chain);
+    const quote = await gateway.quoteIntent({ tokenIn: tokenAddress, tokenOut: this.bridgeToken, amountIn });
+    const bridgeOut = quote.fillable ? bridgeTopUpOutput(quote.amountOut) : 0n;
+    const rate = quote.amountIn > 0n ? Number(formatUnits5(quote.amountOut, BRIDGE_DECIMALS)) / Number(formatUnits5(quote.amountIn, decimals)) : 0;
+    return {
+      chain: params.chain,
+      token: params.token,
+      tokenAddress,
+      amountIn: formatUnits5(amountIn, decimals),
+      bridgeOut: formatUnits5(bridgeOut, BRIDGE_DECIMALS),
+      rate: rate.toString(),
+      fillable: quote.fillable && bridgeOut > 0n,
+      maxFillableIn: formatUnits5(quote.maxFillableIn, decimals),
+      route: quote.route
+    };
+  }
+  /** Re-quotes, then places and drives the order in the background. Returns its state. */
+  async start(params) {
+    if (!(await this.sourceChains()).includes(getChainId4(params.chain) ?? -1)) {
+      throw new Error(`${params.chain} is not a network the filler fills on`);
+    }
+    await this.restore();
+    if (this.record && isBridgeTopUpPending(this.record.stage)) {
+      throw new Error("A BRIDGE top-up is already pending");
+    }
+    const quote = await this.quote(params);
+    if (!quote.fillable) {
+      throw new Error(`The orderbook cannot fill ${quote.amountIn} ${params.token} (max ${quote.maxFillableIn})`);
+    }
+    const { tokenAddress, decimals } = this.payToken(params.chain, params.token);
+    const amountIn = parseUnits5(quote.amountIn, decimals);
+    const balance = await this.balanceOf(params.chain, tokenAddress);
+    if (balance < amountIn) {
+      const reserve = formatUnits5(this.reserve(params.chain, tokenAddress), decimals);
+      throw new Error(
+        `Not enough ${params.token}: ${formatUnits5(balance, decimals)} spendable after the ${reserve} ${params.token} kept for gas, need ${quote.amountIn}`
+      );
+    }
+    const order = await this.buildOrder(params.chain, tokenAddress, amountIn, parseUnits5(quote.bridgeOut, BRIDGE_DECIMALS));
+    if (this.record && isBridgeTopUpPending(this.record.stage)) {
+      throw new Error("A BRIDGE top-up is already pending");
+    }
+    const now = Date.now();
+    this.record = {
+      id: randomUUID2(),
+      chain: params.chain,
+      token: params.token,
+      amountIn: quote.amountIn,
+      bridgeOut: quote.bridgeOut,
+      stage: "placing",
+      createdAt: now,
+      updatedAt: now,
+      stageTimes: { placing: now },
+      order: serializeOrder(order)
+    };
+    await this.persist();
+    void this.place(order, tokenAddress);
+    return publicState(this.record);
+  }
+  /** Cancels an unfilled order and refunds its escrowed input to the filler wallet. */
+  async reclaim() {
+    await this.restore();
+    const record = this.record;
+    if (!record || record.stage !== "unfilled") throw new Error("There is no unfilled top-up to reclaim");
+    await this.update({ stage: "reclaiming", error: void 0 });
+    void this.driveReclaim();
+    return publicState(this.record);
+  }
+  /**
+   * Places the order, then tracks it. The SDK builds the `placeOrder` calldata and the
+   * session key; the receipt is read back here, through the filler's own multi-endpoint
+   * client, rather than by the SDK from one endpoint, where a node that has not caught up
+   * with the new block fails the read and loses track of an order that did land.
+   */
+  async place(order, tokenIn) {
+    await this.drive(async (gateway) => {
+      const gen = gateway.executeBest(order, SIMPLEX_REFERRER, { auctionTimeMs: AUCTION_TIME_MS });
+      const first = await gen.next();
+      await gen.return();
+      if (first.done || first.value.status !== "AWAITING_PLACE_ORDER") {
+        throw new Error("The SDK did not produce a placement transaction");
+      }
+      const placement = first.value;
+      await this.update({ sessionPrivateKey: placement.sessionPrivateKey });
+      const calls = this.placementCalls(order, tokenIn, placement);
+      const { txHash } = await this.deps.tokenSender.submitCalls(this.record.chain, calls);
+      await this.update({ placeTxHash: txHash });
+      await this.recordPlacement(order, txHash);
+      await this.trackOrder(gateway);
+    });
+  }
+  /**
+   * Reads the placement receipt and stores the order as the gateway committed it. Throws
+   * when the transaction placed no order, so the top-up is marked failed.
+   */
+  async recordPlacement(order, txHash) {
+    const receipt = await this.deps.clientManager.getPublicClient(this.record.chain).waitForTransactionReceipt({ hash: txHash, timeout: RECEIPT_TIMEOUT_MS });
+    const [placed] = parseEventLogs2({ abi: IntentGatewayABI, logs: receipt.logs, eventName: "OrderPlaced" });
+    if (!placed) throw new Error(`Transaction ${txHash} placed no order`);
+    const canonical = deriveCanonicalPlacedOrder(order, placed.args);
+    await this.update({
+      stage: "awaiting_bids",
+      commitment: canonical.id,
+      order: serializeOrder(canonical),
+      error: void 0
+    });
+  }
+  /** Continues an order whose placement landed but was not recorded. */
+  async recoverPlacement() {
+    await this.drive(async (gateway) => {
+      const record = this.record;
+      await this.recordPlacement(deserializeOrder(record.order), record.placeTxHash);
+      await this.trackOrder(gateway);
+    });
+  }
+  async resumeDelivery() {
+    await this.drive(() => this.deliver());
+  }
+  async resumeOrder() {
+    await this.drive((gateway) => this.trackOrder(gateway));
+  }
+  /** Follows a placed order through bids to a fill, or to its deadline. */
+  async trackOrder(gateway) {
+    const record = this.record;
+    const order = deserializeOrder(record.order);
+    if (await gateway.isOrderFilled(order)) {
+      await this.update({ stage: "delivering" });
+      await this.deliver();
+      return;
+    }
+    if (!record.sessionPrivateKey) {
+      await this.update({ stage: "unfilled", error: "The order's session key was not saved, so it cannot be resumed" });
+      return;
+    }
+    const gen = gateway.resumeBest(order, {
+      sessionPrivateKey: record.sessionPrivateKey,
+      auctionTimeMs: AUCTION_TIME_MS
+    });
+    for await (const value of gen) {
+      if (await this.applyExecutionUpdate(value)) break;
+    }
+    if (this.record.stage === "delivering") await this.deliver();
+  }
+  /**
+   * Carries the bought BRIDGE to Hyperbridge. The order's output call dispatched it from
+   * BSC with no relayer fee. Relayers may still deliver it; when none has shortly after BSC
+   * is final on Hyperbridge, the filler relays it itself: a request into Hyperbridge goes
+   * in as an unsigned extrinsic and costs nothing. Runs until the request is delivered.
+   */
+  async deliver() {
+    let relayedAt = 0;
+    while (!await this.syncDelivery()) {
+      const finalized = this.record.deliveryStatuses?.find((status2) => status2.status === "SOURCE_FINALIZED");
+      const due = finalized && Date.now() - finalized.timestamp > SELF_RELAY_GRACE_MS;
+      if (due && Date.now() - relayedAt > DELIVERY_RETRY_MS) {
+        relayedAt = Date.now();
+        await this.selfRelay(this.record.deliveryCommitment).catch((err) => {
+          this.logger.warn({ err }, "Self-relay of the BRIDGE to Hyperbridge failed; retrying");
+        });
+      }
+      await sleep(DELIVERY_POLL_MS);
+    }
+    const id = this.record.id;
+    while (this.record?.id === id && this.needsStatusBackfill()) {
+      await sleep(DELIVERY_POLL_MS);
+      await this.syncDelivery().catch((err) => this.logger.debug({ err }, "BRIDGE delivery backfill failed"));
+    }
+  }
+  /** Delivered, but the indexer has yet to record the delivery, and not for too long. */
+  needsStatusBackfill() {
+    const record = this.record;
+    if (!record || record.stage !== "delivered" || !record.deliveryCommitment) return false;
+    if (record.deliveryStatuses?.some((status2) => status2.status === "DESTINATION")) return false;
+    return Date.now() - (record.stageTimes?.delivered ?? 0) < STATUS_BACKFILL_MS;
+  }
+  /**
+   * Reads where the order and its BRIDGE are, from the indexer and the chains, and records
+   * it. Shared by the driver and {@link sync}, and never runs twice at once. True once the
+   * BRIDGE has reached Hyperbridge.
+   */
+  syncDelivery() {
+    this.deliverySync ?? (this.deliverySync = this.readDelivery().finally(() => {
+      this.deliverySync = void 0;
+    }));
+    return this.deliverySync;
+  }
+  async readDelivery() {
+    const record = this.record;
+    if (record.stage !== "delivering" && record.stage !== "delivered") return false;
+    if (!record.fillTxHash) {
+      const fillTxHash = await this.findFill();
+      if (!fillTxHash) return false;
+      await this.update({ fillTxHash });
+    }
+    if (!record.deliveryCommitment) {
+      await this.update({ deliveryCommitment: await this.deliveryRequest(record.fillTxHash) });
+    }
+    const hyperbridge = await this.hyperbridge();
+    const request = await withTimeout(
+      this.ismpClient(hyperbridge).queryRequestWithStatus(record.deliveryCommitment),
+      "the BRIDGE request status"
+    );
+    const statuses = (request?.statuses ?? []).filter((status2) => DELIVERY_STATUSES.has(status2.status)).map((status2) => ({
+      status: status2.status,
+      timestamp: toMs(status2.metadata.timestamp),
+      txHash: status2.metadata.transactionHash
+    }));
+    if (statuses.length > 0) await this.update({ deliveryStatuses: statuses });
+    const delivered = statuses.some((status2) => status2.status === "DESTINATION") || !!await withTimeout(hyperbridge.queryRequestReceipt(record.deliveryCommitment), "the request receipt");
+    if (delivered && record.stage !== "delivered") await this.update({ stage: "delivered", error: void 0 });
+    return delivered;
+  }
+  /**
+   * The HyperFungibleToken request the fill dispatched to Hyperbridge. The indexer finds it by
+   * the fill's transaction, as the explorer's search does; the fill's own `Sent` log is the
+   * fallback while the indexer catches up.
+   */
+  async deliveryRequest(fillTxHash) {
+    const response = await withTimeout(
+      fetch(this.deps.indexerUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ query: DELIVERY_REQUEST_QUERY, variables: { hash: fillTxHash } })
+      }),
+      "the indexer"
+    );
+    const body = await response.json();
+    const indexed = body.data?.requestV2s?.nodes[0]?.commitment;
+    if (indexed) return indexed;
+    const fill = await withTimeout(this.bsc().getTransactionReceipt({ hash: fillTxHash }), "the fill receipt");
+    const [sent] = parseEventLogs2({ abi: HyperFungibleTokenABI, logs: fill.logs, eventName: "Sent" });
+    if (!sent) throw new Error(`The fill ${fillTxHash} sent no BRIDGE to Hyperbridge`);
+    return sent.args.commitment;
+  }
+  /**
+   * BSC, read through every endpoint there is: the filler need not run it, and a single public
+   * endpoint refuses receipts it considers old.
+   */
+  bsc() {
+    this.bscClient ?? (this.bscClient = createPublicClient3({
+      chain: bscChain,
+      transport: fallback2(this.bscProofRpcUrls().map((url) => http3(url, { timeout: 1e4, retryCount: 0 })))
+    }));
+    return this.bscClient;
+  }
+  /**
+   * The transaction that filled the order. The executor reports it only for a fill this
+   * process selected, so it comes from the indexer, or, while the indexer has yet to reach
+   * BSC's latest blocks, from the gateway's `OrderFilled` log around when the fill was seen.
+   */
+  async findFill() {
+    const record = this.record;
+    const indexed = (await this.indexedOrder())?.find((status2) => status2.status === "FILLED");
+    if (indexed) {
+      if (indexed.filler && !record.filler) await this.update({ filler: indexed.filler });
+      return indexed.transactionHash;
+    }
+    const seenAt = record.events?.find((event) => event.status === "FILLED")?.timestamp ?? record.stageTimes?.delivering;
+    if (!seenAt) return void 0;
+    const client = this.bsc();
+    const [latest, blockTime] = await Promise.all([
+      withTimeout(client.getBlock(), "the latest BSC block"),
+      this.blockTimeSeconds()
+    ]);
+    const blockAt = (ms) => latest.number - BigInt(Math.ceil((Number(latest.timestamp) - ms / 1e3) / blockTime));
+    const from = blockAt(seenAt - FILL_SEARCH_BEFORE_MS);
+    const to = (() => {
+      const end = blockAt(seenAt + FILL_SEARCH_AFTER_MS);
+      return end < latest.number ? end : latest.number;
+    })();
+    for (let start = from; start <= to; start += LOG_CHUNK_BLOCKS) {
+      const end = start + LOG_CHUNK_BLOCKS - 1n < to ? start + LOG_CHUNK_BLOCKS - 1n : to;
+      const logs = await withTimeout(
+        client.getLogs({
+          address: this.deps.configService.getIntentGatewayAddress(BRIDGE_TOP_UP_CHAIN),
+          event: ORDER_FILLED_EVENT,
+          args: { commitment: record.commitment },
+          fromBlock: start,
+          toBlock: end
+        }),
+        "the fill on BSC"
+      );
+      if (logs[0]) return logs[0].transactionHash;
+    }
+    return void 0;
+  }
+  /** The order's statuses as the indexer has them: placed, filled, redeemed or refunded. */
+  async indexedOrder() {
+    const response = await withTimeout(
+      fetch(this.deps.indexerUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ query: ORDER_QUERY2, variables: { commitment: this.record.commitment } })
+      }),
+      "the indexer"
+    );
+    const body = await response.json();
+    return body.data?.iOrderV3s?.nodes[0]?.statusMetadata.nodes.map((node) => ({
+      status: node.status,
+      timestamp: toMs(node.timestamp),
+      transactionHash: node.transactionHash,
+      filler: node.filler ?? void 0
+    }));
+  }
+  /**
+   * Brings a pending top-up up to date from the chains and the indexer, for a dashboard that
+   * is showing it: someone may have filled, delivered or refunded it while this process was
+   * not looking. One sync at a time; a call made while one runs waits for that one.
+   */
+  sync() {
+    this.syncing ?? (this.syncing = this.reconcile().catch((err) => this.logger.debug({ err }, "BRIDGE top-up sync failed")).finally(() => {
+      this.syncing = void 0;
+    }));
+    return this.syncing;
+  }
+  async reconcile() {
+    await this.restore();
+    const record = this.record;
+    if (this.needsStatusBackfill()) {
+      await this.syncDelivery();
+      return;
+    }
+    if (!record || !isBridgeTopUpPending(record.stage) || !record.commitment) return;
+    if (record.stage === "awaiting_bids" || record.stage === "filling") {
+      const statuses = await this.indexedOrder();
+      const fill = statuses?.find((status2) => status2.status === "FILLED");
+      if (fill) {
+        await this.update({
+          stage: "delivering",
+          fillTxHash: fill.transactionHash,
+          filler: fill.filler ?? record.filler,
+          stageTimes: { ...record.stageTimes, delivering: fill.timestamp }
+        });
+        void this.resumeDelivery();
+      } else if (statuses?.some((status2) => status2.status === "REFUNDED")) {
+        await this.update({ stage: "reclaimed" });
+      }
+      return;
+    }
+    if (record.stage === "delivering") {
+      await this.syncDelivery();
+      return;
+    }
+    if (record.stage === "unfilled" || record.stage === "reclaiming") {
+      const gateway = await this.gateway(record.chain);
+      await this.refunded(gateway, deserializeOrder(record.order));
+    }
+  }
+  /**
+   * Submits the request to Hyperbridge with a proof from BSC state. Public BSC endpoints
+   * differ in whether they serve `eth_getProof` for recent blocks, so each is tried in turn.
+   */
+  async selfRelay(commitment) {
+    const hyperbridge = await this.hyperbridge();
+    const failures = [];
+    for (const rpcUrl of this.bscProofRpcUrls()) {
+      if (await withTimeout(hyperbridge.queryRequestReceipt(commitment), "the request receipt")) return;
+      try {
+        const client = this.ismpClient(hyperbridge, rpcUrl);
+        const receipt = await withTimeout(client.aggregateTransactionWithCommitment(commitment), "the relay", 12e4);
+        await this.update({ deliveryTxHash: receipt.transactionHash });
+        return;
+      } catch (err) {
+        const reason = err instanceof Error ? err.message.split("\n")[0] : String(err);
+        failures.push(`${new URL(rpcUrl).host}: ${reason}`);
+      }
+    }
+    throw new Error(`Could not relay the BRIDGE to Hyperbridge (${failures.join("; ")})`);
+  }
+  /** The operator's BSC endpoints first, then the free public ones. */
+  bscProofRpcUrls() {
+    const urls = [
+      ...this.deps.configService.getRpcUrls(BRIDGE_TOP_UP_CHAIN),
+      ...chainByChainId(getChainId4(BRIDGE_TOP_UP_CHAIN))?.defaultRpcUrls ?? []
+    ];
+    return urls.filter((url, index) => url && urls.indexOf(url) === index);
+  }
+  /** Records an executor update. True when the order reached a final state. */
+  async applyExecutionUpdate(value) {
+    switch (value.status) {
+      case "NEW_BID":
+      case "BIDS_RECEIVED": {
+        const bids = value.status === "NEW_BID" ? [value.bid] : value.bids;
+        const bidCount = value.status === "BIDS_RECEIVED" ? Number(value.bidCount ?? bids.length) : void 0;
+        await this.recordEvent({ status: value.status, bidCount, bids: bids.map(bidPreview) });
+        if (bidCount !== void 0) await this.update({ bidCount: Math.max(this.record.bidCount ?? 0, bidCount) });
+        return false;
+      }
+      case "BID_SELECTED":
+        await this.recordEvent({
+          status: "BID_SELECTED",
+          selectedSolver: value.selectedSolver,
+          userOpHash: value.userOpHash,
+          txHash: value.transactionHash
+        });
+        await this.update({ stage: "filling", fillTxHash: value.transactionHash });
+        return false;
+      case "FILLED":
+        await this.recordEvent({
+          status: "FILLED",
+          selectedSolver: value.selectedSolver,
+          userOpHash: value.userOpHash,
+          txHash: value.transactionHash
+        });
+        await this.update({
+          stage: "delivering",
+          fillTxHash: value.transactionHash ?? this.record.fillTxHash,
+          error: void 0
+        });
+        return true;
+      case "EXPIRED":
+      case "FAILED":
+        await this.update({ stage: "unfilled", error: value.error });
+        return true;
+      case "CANCELLED":
+        await this.update({ stage: "reclaimed" });
+        return true;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Recovers an unfilled order's escrow, following the Hyperbridge app's recovery: the SDK
+   * cancel flow from the paying chain (BSC's expiry height finalized, the cancel sent, the
+   * cancellation finalized on the source, verified and finalized on Hyperbridge), then the
+   * refund. A relayer normally delivers that refund; if none has within a few minutes of
+   * Hyperbridge finalizing, the filler submits Hyperbridge's response itself. Each step is
+   * recorded as it lands, and a restart resumes from the SDK's persisted progress.
+   */
+  async driveReclaim() {
+    await this.drive(async (gateway) => {
+      const record = this.record;
+      const order = deserializeOrder(record.order);
+      if (await this.refunded(gateway, order)) return;
+      const sameChain = record.chain === BRIDGE_TOP_UP_CHAIN;
+      const ismp = await this.cancelClient(record.chain);
+      const gen = gateway.cancelOrder(order, ismp);
+      let input;
+      while (true) {
+        const { value, done } = await gen.next(input);
+        input = void 0;
+        if (done) break;
+        switch (value.status) {
+          case "DESTINATION_FINALIZED":
+            await this.recordRecoveryStep("DESTINATION_FINALIZED");
+            break;
+          case "AWAITING_CANCEL_TRANSACTION": {
+            if (this.record.reclaimTxHash && !this.hasRecoveryStep("ORDER_CANCELED")) {
+              input = this.record.reclaimTxHash;
+              break;
+            }
+            const calls = [];
+            const quote = await gateway.quoteCancelOrder(order);
+            if (value.value === 0n && quote.relayerFee > 0n) {
+              const feeToken = await this.feeToken(record.chain);
+              calls.push({
+                target: feeToken,
+                value: 0n,
+                data: encodeFunctionData5({
+                  abi: ERC20_ABI,
+                  functionName: "approve",
+                  args: [value.to, quote.relayerFee]
+                })
+              });
+            }
+            calls.push({ target: value.to, value: value.value, data: value.data });
+            const { txHash } = await this.deps.tokenSender.submitCalls(record.chain, calls);
+            await this.update({ reclaimTxHash: txHash });
+            input = txHash;
+            break;
+          }
+          case "CANCEL_STARTED":
+            await this.recordRecoveryStep("ORDER_CANCELED", value.receipt.transactionHash);
+            break;
+          case "SOURCE_FINALIZED":
+          case "HYPERBRIDGE_DELIVERED":
+          case "HYPERBRIDGE_FINALIZED": {
+            const metadata = value.metadata;
+            await this.recordRecoveryStep(
+              value.status,
+              metadata.transactionHash,
+              metadata.timestamp ? toMs(metadata.timestamp) : void 0
+            );
+            if (value.status === "HYPERBRIDGE_FINALIZED" && metadata.calldata) {
+              await this.update({ claimCalldata: metadata.calldata });
+            }
+            break;
+          }
+          case "CANCELLATION_COMPLETE":
+            await this.recordRecoveryStep("ORDER_CANCELED", value.transactionHash);
+            await this.recordRecoveryStep("FUNDS_CLAIMED", value.transactionHash);
+            break;
+        }
+      }
+      if (sameChain && this.hasRecoveryStep("FUNDS_CLAIMED")) {
+        await this.update({ stage: "reclaimed", error: void 0 });
+        return;
+      }
+      while (!await this.refunded(gateway, order)) {
+        const finalizedAt = this.record.recoverySteps?.find((s) => s.step === "HYPERBRIDGE_FINALIZED")?.timestamp;
+        const claimable = this.record.claimCalldata && finalizedAt && Date.now() - finalizedAt > RELAYER_DELIVERY_WAIT_MS;
+        if (claimable && !this.record.claimTxHash) {
+          await this.claimRefund(record.chain, this.record.claimCalldata);
+          continue;
+        }
+        await sleep(REFUND_POLL_MS);
+      }
+    });
+  }
+  /**
+   * Submits Hyperbridge's finalized response to the source chain's ISMP handler, which
+   * refunds the escrow, as the Hyperbridge app's "Claim funds" does.
+   */
+  async claimRefund(chain, calldata) {
+    const params = await withTimeout(
+      this.deps.clientManager.getPublicClient(chain).readContract({
+        abi: EVM_HOST,
+        address: this.deps.configService.getHostAddress(chain),
+        functionName: "hostParams"
+      }),
+      "the host's handler"
+    );
+    const { txHash } = await this.deps.tokenSender.submitCalls(chain, [
+      { target: params.handler, value: 0n, data: calldata }
+    ]);
+    await this.update({ claimTxHash: txHash });
+  }
+  /**
+   * Whether the escrow is back with the filler, from the source gateway or the indexer's
+   * REFUNDED status; records the refund as the recovery's last step when it is.
+   */
+  async refunded(gateway, order) {
+    const onChain = await withTimeout(gateway.isOrderRefunded(order), "the refund").catch(() => false);
+    const indexed = (await this.indexedOrder().catch(() => void 0))?.find((s) => s.status === "REFUNDED");
+    if (!onChain && !indexed) return false;
+    if (!this.hasRecoveryStep("FUNDS_CLAIMED")) {
+      await this.recordRecoveryStep(
+        "FUNDS_CLAIMED",
+        this.record.claimTxHash ?? indexed?.transactionHash,
+        indexed?.timestamp
+      );
+    }
+    await this.update({ stage: "reclaimed", error: void 0 });
+    return true;
+  }
+  hasRecoveryStep(step) {
+    return !!this.record?.recoverySteps?.some((entry) => entry.step === step);
+  }
+  /** Records a recovery step once, at the time it landed (or now). */
+  async recordRecoveryStep(step, txHash, timestamp) {
+    if (this.hasRecoveryStep(step)) return;
+    const steps = [...this.record.recoverySteps ?? [], { step, txHash, timestamp: timestamp ?? Date.now() }];
+    await this.update({ recoverySteps: steps });
+  }
+  /** Runs one background flow for the record; a failure is recorded rather than thrown. */
+  async drive(flow) {
+    const record = this.record;
+    if (!record || this.driving === record.id) return;
+    this.driving = record.id;
+    try {
+      await flow(await this.gateway(record.chain));
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      this.logger.warn({ err, id: record.id, stage: record.stage }, "BRIDGE top-up step failed");
+      if (record.stage === "placing" && !record.placeTxHash) {
+        await this.update({ stage: "failed", error });
+      } else if (record.stage === "delivering") {
+        await this.update({ error: `Delivery to Hyperbridge is retrying: ${error}` });
+        setTimeout(() => void this.resumeDelivery(), DELIVERY_RETRY_MS);
+      } else if (record.stage === "reclaiming") {
+        await this.update({ error: `Recovery is retrying: ${error}` });
+        setTimeout(() => void this.driveReclaim(), DELIVERY_RETRY_MS);
+      } else if (record.stage === "placing") {
+        await this.update({ stage: "failed", error: `${error} (placement tx ${record.placeTxHash})` });
+      } else {
+        await this.update({ stage: "unfilled", error });
+      }
+    } finally {
+      if (this.driving === record.id) this.driving = void 0;
+      this.logger.info(publicState(record), "BRIDGE top-up step finished");
+    }
+  }
+  /** Keeps what the executor reported, for the timeline's offers and its links. */
+  async recordEvent(event) {
+    const events = [...this.record.events ?? [], { ...event, timestamp: Date.now() }];
+    await this.update({ events: events.slice(-MAX_EVENTS) });
+  }
+  async update(patch) {
+    if (!this.record) return;
+    const now = Date.now();
+    if (patch.stage && patch.stage !== this.record.stage) {
+      patch = { ...patch, stageTimes: { ...this.record.stageTimes, [patch.stage]: now } };
+    }
+    Object.assign(this.record, patch, { updatedAt: now });
+    await this.persist();
+  }
+  persist() {
+    const snapshot = this.record ? { ...this.record } : void 0;
+    const write = this.writes.then(() => patchRuntimeState(this.deps.state, { bridgeTopUp: snapshot }));
+    this.writes = write.catch((err) => this.logger.warn({ err }, "Could not save the BRIDGE top-up"));
+    return write.then(
+      () => void 0,
+      () => void 0
+    );
+  }
+  async buildOrder(chain, tokenIn, amountIn, bridgeOut) {
+    const dispatcher = await this.callDispatcher();
+    const bsc = this.bsc();
+    const [block, blockTime] = await Promise.all([bsc.getBlockNumber(), this.blockTimeSeconds()]);
+    return {
+      user: bytes20ToBytes323(this.deps.solver),
+      source: chain,
+      destination: BRIDGE_TOP_UP_CHAIN,
+      deadline: block + BigInt(Math.ceil(ORDER_WINDOW_SECONDS / blockTime)),
+      nonce: 0n,
+      fees: 0n,
+      session: "0x0000000000000000000000000000000000000000",
+      predispatch: { assets: [], call: "0x" },
+      inputs: [{ token: bytes20ToBytes323(tokenIn), amount: amountIn }],
+      output: {
+        beneficiary: bytes20ToBytes323(dispatcher),
+        assets: [{ token: bytes20ToBytes323(this.bridgeToken), amount: bridgeOut }],
+        call: encodeBridgeTopUpCall(this.bridgeToken, this.deps.substratePublicKey, bridgeOut)
+      }
+    };
+  }
+  /**
+   * Approvals for the gateway to pull the input and the order fee, then `placeOrder`.
+   * The fee token is often the input token itself; one approval then covers both.
+   */
+  placementCalls(order, tokenIn, placement) {
+    const amountIn = order.inputs[0].amount;
+    const approvals = /* @__PURE__ */ new Map([[tokenIn.toLowerCase(), amountIn]]);
+    if (placement.feeTokenAmount > 0n) {
+      const fee = placement.feeTokenAddress.toLowerCase();
+      approvals.set(fee, (approvals.get(fee) ?? 0n) + placement.feeTokenAmount);
+    }
+    const calls = [...approvals].map(([token, amount]) => ({
+      target: token,
+      value: 0n,
+      data: encodeFunctionData5({ abi: ERC20_ABI, functionName: "approve", args: [placement.to, amount] })
+    }));
+    calls.push({ target: placement.to, value: placement.value, data: placement.data });
+    return calls;
+  }
+  payToken(chain, token) {
+    const { configService } = this.deps;
+    const tokenAddress = token === "USDC" ? configService.getUsdcAsset(chain) : configService.getUsdtAsset(chain);
+    if (!tokenAddress || /^0x0+$/.test(tokenAddress)) throw new Error(`${token} is not configured on ${chain}`);
+    const decimals = token === "USDC" ? configService.getUsdcDecimals(chain) : configService.getUsdtDecimals(chain);
+    return { tokenAddress, decimals };
+  }
+  async walletBalance(chain, token) {
+    return await this.deps.clientManager.getPublicClient(chain).readContract({
+      abi: ERC20_ABI,
+      address: token,
+      functionName: "balanceOf",
+      args: [this.deps.solver]
+    });
+  }
+  /** What the paymaster pulls for gas on the sponsored path, which a top-up must leave. */
+  reserve(chain, token) {
+    return paymasterReserveForToken(chain, token.toLowerCase(), this.deps.configService);
+  }
+  /** Spendable wallet balance: the paymaster's gas reserve is held back. */
+  async balanceOf(chain, token) {
+    const balance = await this.walletBalance(chain, token);
+    const reserve = this.reserve(chain, token);
+    return balance > reserve ? balance - reserve : 0n;
+  }
+  async feeToken(chain) {
+    return await this.deps.clientManager.getPublicClient(chain).readContract({
+      abi: [{ type: "function", name: "feeToken", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] }],
+      address: this.deps.configService.getHostAddress(chain),
+      functionName: "feeToken"
+    });
+  }
+  /** The CallDispatcher the BSC gateway runs output calls through, read from the gateway itself. */
+  callDispatcher() {
+    this.dispatcher ?? (this.dispatcher = (async () => {
+      const params = await this.bsc().readContract({
+        abi: INTENT_GATEWAY_V2_ABI,
+        address: this.deps.configService.getIntentGatewayAddress(BRIDGE_TOP_UP_CHAIN),
+        functionName: "params"
+      });
+      return params.dispatcher;
+    })().catch((err) => {
+      this.dispatcher = void 0;
+      throw err;
+    }));
+    return this.dispatcher;
+  }
+  async blockTimeSeconds() {
+    const client = this.bsc();
+    const latest = await client.getBlock();
+    const earlier = await client.getBlock({ blockNumber: latest.number - 100n });
+    const seconds = Number(latest.timestamp - earlier.timestamp) / 100;
+    return seconds > 0 ? seconds : 1;
+  }
+  evmChain(chain, rpcUrl) {
+    const { configService } = this.deps;
+    const bundlerUrl = chain === BRIDGE_TOP_UP_CHAIN ? configService.getBundlerUrl(chain) ?? hyperbridgeBundlerUrl(getChainId4(chain)) : void 0;
+    return EvmChain2.fromParams({
+      chainId: getChainId4(chain),
+      host: configService.getHostAddress(chain),
+      rpcUrl: rpcUrl ?? configService.getRpcUrl(chain),
+      bundlerUrl
+    });
+  }
+  gateway(source) {
+    let gateway = this.gateways.get(source);
+    if (!gateway) {
+      gateway = (async () => IntentGateway2.create(
+        this.evmChain(source),
+        this.evmChain(BRIDGE_TOP_UP_CHAIN),
+        await this.deps.hyperbridge,
+        { storagePath: this.deps.storagePath }
+      ))().catch((err) => {
+        this.gateways.delete(source);
+        throw err;
+      });
+      this.gateways.set(source, gateway);
+    }
+    return gateway;
+  }
+  hyperbridge() {
+    this.hyperbridgeChain ?? (this.hyperbridgeChain = withTimeout(SubstrateChain.connect({
+      wsUrl: this.deps.configService.getHyperbridgeWsUrl() ?? NEXUS_WS_URL,
+      consensusStateId: NEXUS_CONSENSUS_STATE,
+      hasher: "Keccak",
+      stateMachineId: NEXUS_STATE_MACHINE
+    }), "Hyperbridge").catch((err) => {
+      this.hyperbridgeChain = void 0;
+      throw err;
+    }));
+    return this.hyperbridgeChain;
+  }
+  /** Tracks requests from BSC into Hyperbridge, the route the bought BRIDGE takes. */
+  ismpClient(hyperbridge, rpcUrl) {
+    return new IsmpClient({
+      queryClient: createQueryClient({ url: this.deps.indexerUrl }),
+      source: this.evmChain(BRIDGE_TOP_UP_CHAIN, rpcUrl),
+      dest: hyperbridge,
+      hyperbridge
+    });
+  }
+  /** Tracks the reclaim's cancellation, which runs between the paying chain and BSC. */
+  async cancelClient(source) {
+    return new IsmpClient({
+      queryClient: createQueryClient({ url: this.deps.indexerUrl }),
+      source: this.evmChain(source),
+      dest: this.evmChain(BRIDGE_TOP_UP_CHAIN),
+      hyperbridge: await this.hyperbridge()
+    });
+  }
 };
+function publicState(record) {
+  const { order: _order, sessionPrivateKey: _key, ...rest } = record;
+  return { ...rest, pending: isBridgeTopUpPending(record.stage) };
+}
+var DELIVERY_STATUSES = /* @__PURE__ */ new Set(["SOURCE", "SOURCE_FINALIZED", "DESTINATION"]);
+function toMs(timestamp) {
+  const value = Number(timestamp ?? 0);
+  return value > 0 && value < 1e12 ? value * 1e3 : value;
+}
+function withTimeout(promise, what, ms = NETWORK_TIMEOUT_MS) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`Timed out reading ${what}`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
 
 // src/services/bundler-preflight.ts
 var BUNDLER_PREFLIGHT_TIMEOUT_MS = 1e4;
@@ -23976,7 +24916,30 @@ var LimitOrderLifecycle = class {
 
 // src/services/BalanceProvider.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
-import { formatUnits as formatUnits5 } from "viem";
+import { formatUnits as formatUnits6 } from "viem";
+
+// src/services/native-setup.ts
+import { concat, formatEther as formatEther4 } from "viem";
+async function nativeSetupNeed(client, configService, wallet, chain, nativeBalance) {
+  const paymaster = configService.getSimplexPaymasterAddress(chain);
+  if (!paymaster) return null;
+  const gasPrice = await client.getGasPrice();
+  if (nativeBalance >= (DELEGATION_TX_GAS_FLOOR + BATCHED_APPROVE_GAS) * gasPrice) return null;
+  const pending = await resolvePendingPermit2Approval(client, wallet, paymaster, chain, configService);
+  if (!pending || pending.permitCapable) return null;
+  const solverAccount = configService.getSolverAccountContractAddress(chain);
+  const code = await client.getCode({ address: wallet });
+  const delegated = !!solverAccount && code?.toLowerCase() === concat(["0xef0100", solverAccount]).toLowerCase();
+  const cost = (delegated ? APPROVE_TX_GAS : DELEGATION_TX_GAS_FLOOR + BATCHED_APPROVE_GAS) * gasPrice;
+  if (nativeBalance >= cost) return null;
+  const usdc = configService.getUsdcAsset(chain);
+  return {
+    required: Number(formatEther4(cost * 2n)),
+    feeToken: pending.token.toLowerCase() === usdc.toLowerCase() ? "USDC" : "USDT"
+  };
+}
+
+// src/services/BalanceProvider.ts
 var BalanceProvider = class extends EventEmitter2 {
   constructor(options) {
     super();
@@ -24024,8 +24987,14 @@ var BalanceProvider = class extends EventEmitter2 {
         })
       );
     }
+    let tokens = {};
+    try {
+      tokens = await this.options.tokens();
+    } catch (err) {
+      this.logger.warn({ err }, "Could not read the orderbook's books; reading USDC and USDT balances only");
+    }
     const fxExoticByChain = /* @__PURE__ */ new Map();
-    for (const [chainKey, addrs] of Object.entries(this.options.token1)) {
+    for (const [chainKey, addrs] of Object.entries(tokens)) {
       const id = Number.parseInt(chainKey.replace("EVM-", ""), 10);
       if (!isNaN(id)) fxExoticByChain.set(id, addrs);
     }
@@ -24069,7 +25038,14 @@ var BalanceProvider = class extends EventEmitter2 {
     try {
       const native = await client.getBalance({ address: fillerAddr });
       const symbol = nativeTokenSymbol(chainId);
-      row.native = { symbol, amount: Number.parseFloat(formatUnits5(native, 18)) };
+      row.native = { symbol, amount: Number.parseFloat(formatUnits6(native, 18)) };
+      const setup = await nativeSetupNeed(client, this.options.configService, fillerAddr, chain, native).catch(
+        (err) => {
+          this.logger.debug({ err, chainId }, "Could not check whether the chain needs native gas for setup");
+          return null;
+        }
+      );
+      if (setup) row.nativeSetup = setup;
     } catch (err) {
       issues.push({ chainId, source: "native", message: errorMessage(err) });
     }
@@ -24140,7 +25116,7 @@ var BalanceProvider = class extends EventEmitter2 {
               functionName: "balanceOf",
               args: [fillerAddr]
             });
-            wallet = Number.parseFloat(formatUnits5(balance, definition.decimals));
+            wallet = Number.parseFloat(formatUnits6(balance, definition.decimals));
           } catch (err) {
             issues.push({
               chainId,
@@ -24168,8 +25144,8 @@ var BalanceProvider = class extends EventEmitter2 {
           available: wallet !== null && vaultDataAvailable ? Math.max(wallet - walletReserve, 0) + vaultAvailable : null,
           vaults: positions.map((position) => ({
             address: position.vault,
-            position: Number.parseFloat(formatUnits5(position.positionAssets, position.decimals)),
-            available: Number.parseFloat(formatUnits5(position.availableAssets, position.decimals)),
+            position: Number.parseFloat(formatUnits6(position.positionAssets, position.decimals)),
+            available: Number.parseFloat(formatUnits6(position.availableAssets, position.decimals)),
             acceptsDeposits: position.acceptsDeposits
           })),
           status: complete ? "fresh" : wallet !== null || positions.length > 0 ? "partial" : "unavailable"
@@ -24212,8 +25188,8 @@ var BalanceProvider = class extends EventEmitter2 {
         const api = await coprocessor.queryApi();
         const account = await api.query.system.account(address);
         const decimals = api.registry.chainDecimals[0] ?? 12;
-        const free = Number.parseFloat(formatUnits5(BigInt(account.data.free.toString()), decimals));
-        const reserved = Number.parseFloat(formatUnits5(BigInt(account.data.reserved.toString()), decimals));
+        const free = Number.parseFloat(formatUnits6(BigInt(account.data.free.toString()), decimals));
+        const reserved = Number.parseFloat(formatUnits6(BigInt(account.data.reserved.toString()), decimals));
         this.snapshot = { ...this.snapshot, hyperbridge: { address, free, reserved } };
       } catch (err) {
         this.logger.warn({ err }, "Failed to fetch Hyperbridge balance");
@@ -24233,7 +25209,7 @@ function isConfiguredAddress(address) {
 }
 function sumFormatted(positions, field) {
   return positions.reduce(
-    (total, position) => total + Number.parseFloat(formatUnits5(position[field], position.decimals)),
+    (total, position) => total + Number.parseFloat(formatUnits6(position[field], position.decimals)),
     0
   );
 }
@@ -24477,7 +25453,7 @@ var DEFAULT_INDEXER_URLS = {
   mainnet: "https://nexus.indexer.polytope.technology/",
   testnet: "https://gargantua.indexer.polytope.technology/"
 };
-var ORDER_QUERY2 = `
+var ORDER_QUERY3 = `
 query OrderSummary($commitment: String!) {
   iOrderV3s(filter: { commitment: { equalTo: $commitment } }) {
     nodes {
@@ -24570,7 +25546,7 @@ async function fetchOrder(fetchImpl, indexerUrl, commitment) {
   const response = await fetchImpl(indexerUrl, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ query: ORDER_QUERY2, variables: { commitment } }),
+    body: JSON.stringify({ query: ORDER_QUERY3, variables: { commitment } }),
     signal: AbortSignal.timeout(15e3)
   });
   if (!response.ok) throw new Error(`Indexer responded ${response.status}`);
@@ -24676,12 +25652,8 @@ async function bootFiller(config, options) {
       }
     }
   };
-  const retired = retiredPairKeys(config.pairs ?? []);
-  if (retired.length > 0) {
-    logger.warn(
-      { keys: retired },
-      "These [[pairs]] keys are no longer read; prices come from limit orders, and the filler fills nothing until one is posted"
-    );
+  if ("pairs" in config) {
+    logger.warn("[[pairs]] is no longer read and can be deleted from the config");
   }
   logger.info("Resolving chain IDs from RPC endpoints...");
   const resolvedChains = await resolveChainConfigs(config.chains, {
@@ -24786,25 +25758,6 @@ async function bootFiller(config, options) {
   }
   logger.info("Initializing trading engine...");
   const assetRegistry = new AssetRegistry(configService, config.assets);
-  const configuredChainNames = resolvedChains.map((chain) => `EVM-${chain.chainId}`);
-  if (config.pairs?.length) {
-    assertPairSymbolsResolve(config.pairs, assetRegistry, configuredChainNames);
-  }
-  const adminStrategies = [];
-  const tradingPairs = (config.pairs ?? []).map((pair) => ({
-    token0: pair.token0,
-    token1: pair.token1
-  }));
-  tradingPairs.forEach((pair, pairIndex) => {
-    adminStrategies.push({
-      index: pairIndex,
-      pairIndex,
-      exotic: `${pair.token0}/${pair.token1}`,
-      token0: pair.token0,
-      token1: pair.token1,
-      sameToken: normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)
-    });
-  });
   const confirmationPolicy = assertConfirmationCoverage(
     config.confirmationPolicies,
     resolvedChains.map((c) => c.chainId)
@@ -24815,7 +25768,6 @@ async function bootFiller(config, options) {
     configService,
     chainClientManager,
     contractService,
-    tradingPairs,
     assetRegistry,
     { confirmationPolicy, fundingVenues, limitOrders: options.data.limitOrders }
   );
@@ -24923,8 +25875,8 @@ async function bootFiller(config, options) {
   if (vaultVenue) {
     vaultVenue.onTx = ({ chain, kind, txHash, sponsored, movements }) => {
       const rows = movements.length > 0 ? movements.map((move) => {
-        const underlying = { token: move.symbol, amount: formatUnits6(move.amount, move.decimals) };
-        const shares = move.shares === void 0 ? { token: null, amount: null } : { token: move.shareSymbol, amount: formatUnits6(move.shares, move.shareDecimals) };
+        const underlying = { token: move.symbol, amount: formatUnits7(move.amount, move.decimals) };
+        const shares = move.shares === void 0 ? { token: null, amount: null } : { token: move.shareSymbol, amount: formatUnits7(move.shares, move.shareDecimals) };
         const out = kind === "sweep" ? underlying : shares;
         const back = kind === "sweep" ? shares : underlying;
         return { token: out.token, amount: out.amount, to: move.vault, tokenIn: back.token, amountIn: back.amount };
@@ -24934,21 +25886,21 @@ async function bootFiller(config, options) {
       }
     };
   }
-  const token1 = {};
-  for (const pair of config.pairs ?? []) {
-    if (normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)) continue;
-    for (const chainName2 of configuredChainNames) {
-      const address = assetRegistry.getAddress(pair.token1, chainName2);
-      if (!address) continue;
-      const list = token1[chainName2] ?? (token1[chainName2] = []);
-      if (!list.includes(address)) list.push(address);
+  const bookTokens = async () => {
+    const { books } = await limitOrderService.books();
+    const symbols = new Set(books.flatMap((book) => [normalizeSymbol(book.base), normalizeSymbol(book.quote)]));
+    const tokens = {};
+    for (const chainId of configService.getConfiguredChainIds()) {
+      const chainName2 = `EVM-${chainId}`;
+      tokens[chainName2] = [...symbols].flatMap((symbol) => assetRegistry.getAddress(symbol, chainName2) ?? []);
     }
-  }
+    return tokens;
+  };
   const balanceProvider = new BalanceProvider({
     chainClientManager,
     configService,
     fillerAddress: runtimeSigner.address,
-    token1,
+    tokens: bookTokens,
     vaultBalances: vaultVenue,
     hyperbridge: intentFiller.hyperbridgeConnection,
     substratePrivateKey: config.simplex.substratePrivateKey
@@ -24991,7 +25943,6 @@ async function bootFiller(config, options) {
   logger.info(
     {
       chains: resolvedChains.map((c) => c.chainId),
-      pairs: (config.pairs ?? []).map((p) => `${p.token0}/${p.token1}`),
       maxConcurrentOrders: config.simplex.maxConcurrentOrders ?? DEFAULT_MAX_CONCURRENT_ORDERS,
       watchOnlyChains: watchOnlyChains.length > 0 ? watchOnlyChains : void 0
     },
@@ -25009,12 +25960,32 @@ async function bootFiller(config, options) {
     activity.detach();
     if (options.ownsData) await options.data.close?.();
   };
+  const tokenSender = new TokenSender(
+    chainClientManager,
+    runtimeSigner.address,
+    () => config.vault?.vaults ?? [],
+    userOpSender,
+    configService
+  );
+  const bridgeTopUp = config.simplex.substratePrivateKey && network === "mainnet" ? new BridgeTopUp({
+    clientManager: chainClientManager,
+    delegation: new DelegationService(chainClientManager, configService, runtimeSigner),
+    configService,
+    tokenSender,
+    state: options.data.state,
+    storagePath: join(options.data.dataDir ?? process.cwd(), ".hyperbridge-cache"),
+    indexerUrl,
+    solver: runtimeSigner.address,
+    substratePublicKey: toHex5((await deriveSubstrateKeyPair(config.simplex.substratePrivateKey)).publicKey),
+    hyperbridge: intentFiller.hyperbridgeConnection,
+    loggers: options.loggers
+  }) : void 0;
+  void bridgeTopUp?.restore();
   return {
     intentFiller,
     limitOrders: limitOrderService,
     balanceProvider,
     vaultVenue,
-    adminStrategies,
     haltControls,
     activity,
     data: options.data,
@@ -25026,9 +25997,6 @@ async function bootFiller(config, options) {
     confirmationPolicy,
     loggers: options.loggers,
     assetRegistry,
-    engine,
-    tradingPairs,
-    balanceTokens: token1,
     rebalancingService,
     resolvedChains,
     fillerAddress: runtimeSigner.address,
@@ -25038,13 +26006,8 @@ async function bootFiller(config, options) {
     config,
     configPath: options.configPath,
     startedAt: Date.now(),
-    tokenSender: new TokenSender(
-      chainClientManager,
-      runtimeSigner.address,
-      () => config.vault?.vaults ?? [],
-      userOpSender,
-      configService
-    ),
+    tokenSender,
+    bridgeTopUp,
     vaultPreflight: async (vaults) => {
       const byChain = {};
       for (const row of vaults) {
@@ -26057,7 +27020,7 @@ var OrderScanner = class _OrderScanner {
 };
 
 // src/data/indexer-inventory.ts
-import { formatUnits as formatUnits7 } from "viem";
+import { formatUnits as formatUnits8 } from "viem";
 var READ_TIMEOUT_MS = 1e4;
 var SETTLED_AFTER_MS = 10 * 6e4;
 var BATCH = 40;
@@ -26134,7 +27097,7 @@ ${queries.join("\n")}
       if (!token) continue;
       let amount;
       try {
-        amount = Number(formatUnits7(BigInt(row.balance), token.decimals));
+        amount = Number(formatUnits8(BigInt(row.balance), token.decimals));
       } catch {
         continue;
       }
@@ -26249,7 +27212,7 @@ var LimitOrderController = class {
     }));
     return this.indexed;
   }
-  /** The pairs the orderbook lists, the smallest payout each token may carry, and its tokens per chain. */
+  /** The books the orderbook lists, the smallest payout each token may carry, and its tokens per chain. */
   books() {
     return this.service.books();
   }
@@ -26281,85 +27244,6 @@ var LimitOrderController = class {
     return cancelled;
   }
 };
-var PairController = class {
-  constructor(runtime, persist) {
-    this.runtime = runtime;
-    this.persist = persist;
-  }
-  get pairs() {
-    return this.runtime.config.pairs ?? [];
-  }
-  list() {
-    return this.pairs.map((pair, index) => ({
-      index,
-      token0: pair.token0,
-      token1: pair.token1,
-      sameToken: normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)
-    }));
-  }
-  /**
-   * Opens a new market on the running engine.
-   *
-   * Validated against the same rules boot applies, so a pair accepted here is
-   * one a restart would also accept. New `assets` are registered first, because
-   * the pair's symbols have to resolve before the market can be hydrated.
-   */
-  async add(pair, options) {
-    const { engine, assetRegistry, adminStrategies, balanceTokens, config } = this.runtime;
-    const assets = options?.assets;
-    const nextAssets = { ...config.assets ?? {}, ...assets ?? {} };
-    const nextPairs = [...this.pairs, pair];
-    validatePairConfigs(nextPairs, nextAssets);
-    if (assets && Object.keys(assets).length > 0) assetRegistry.addAssets(assets);
-    assertPairSymbolsResolve(
-      [pair],
-      assetRegistry,
-      this.runtime.resolvedChains.map((chain) => formatChainKey(chain.chainId))
-    );
-    const tradingPair = { token0: pair.token0, token1: pair.token1 };
-    engine.addPair(tradingPair);
-    config.pairs = nextPairs;
-    if (assets && Object.keys(assets).length > 0) config.assets = nextAssets;
-    if (normalizeSymbol(pair.token0) !== normalizeSymbol(pair.token1)) {
-      for (const chain of this.runtime.resolvedChains) {
-        const chainName2 = formatChainKey(chain.chainId);
-        const address = assetRegistry.getAddress(pair.token1, chainName2);
-        if (!address) continue;
-        const list = balanceTokens[chainName2] ?? (balanceTokens[chainName2] = []);
-        if (!list.includes(address)) list.push(address);
-      }
-    }
-    const pairIndex = nextPairs.length - 1;
-    adminStrategies.push({
-      index: adminStrategies.reduce((max, s) => Math.max(max, s.index), -1) + 1,
-      pairIndex,
-      exotic: `${pair.token0}/${pair.token1}`,
-      token0: pair.token0,
-      token1: pair.token1,
-      sameToken: normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)
-    });
-    await this.persist();
-    return this.list()[pairIndex];
-  }
-  /** Closes a market. Orders already in flight against it still complete. */
-  async remove(index) {
-    const { engine, tradingPairs, adminStrategies, config } = this.runtime;
-    if (index < 0 || index >= this.pairs.length) throw new Error(`Unknown pair ${index}`);
-    engine.removePair(tradingPairs[index]);
-    config.pairs = this.pairs.filter((_, i) => i !== index);
-    const position = adminStrategies.findIndex((s) => s.pairIndex === index);
-    if (position >= 0) adminStrategies.splice(position, 1);
-    for (const strategy of adminStrategies) {
-      if (strategy.pairIndex > index) strategy.pairIndex -= 1;
-    }
-    await this.persist();
-  }
-  livePair(index) {
-    const pair = this.runtime.tradingPairs[index];
-    if (!pair) throw new Error(`Unknown pair ${index}`);
-    return pair;
-  }
-};
 var ChainController = class {
   constructor(runtime, persist, scanner, ownsScanner) {
     this.runtime = runtime;
@@ -26665,7 +27549,6 @@ var Simplex = class _Simplex extends EventEmitter4 {
     this.stopped = false;
     this.logger = runtime.loggers.get("simplex");
     const persist = () => this.persistConfig();
-    this.pairs = new PairController(runtime, persist);
     this.chains = new ChainController(runtime, persist, runtime.orderScanner, ownedScanners.orders !== void 0);
     this.vaults = new VaultController(runtime, persist);
     this.assets = new AssetController(runtime, persist);
@@ -26815,8 +27698,7 @@ var Simplex = class _Simplex extends EventEmitter4 {
       startedAt: this.runtime.startedAt,
       uptimeSec: (Date.now() - this.runtime.startedAt) / 1e3,
       chains: this.runtime.resolvedChains.map((chain) => chain.chainId),
-      watchOnly: this.runtime.intentFiller.getWatchOnly(),
-      pairs: this.runtime.config.pairs?.length ?? 0
+      watchOnly: this.runtime.intentFiller.getWatchOnly()
     };
   }
   /** Order-activity history, newest first; pass `beforeId` to page backwards. */
@@ -26893,7 +27775,6 @@ export {
   LoggerContext,
   MemoryDataStore,
   OrderScanner,
-  PairController,
   RebalanceController,
   SignerType,
   Simplex,
@@ -26912,14 +27793,12 @@ export {
   mpcVaultSigner,
   normalizeSymbol,
   parseChainKey,
-  pickAnchorStable,
   privateKeySigner,
   registrySymbols,
   secretPhraseSigner,
   turnkeySigner,
   validateAssetDefinitions,
   validateConfig,
-  validatePairConfigs,
   validateSecretPhrase,
   validateSignerConfig,
   validateVaultToml,