@hyperbridge/sdk 2.8.8 → 2.8.10

package/dist/node/index.cjs

@@ -3858,6 +3858,11 @@ var ABI3 = [
             type: "uint256",
             internalType: "uint256"
           },
+          {
+            name: "validUntil",
+            type: "uint256",
+            internalType: "uint256"
+          },
           {
             name: "outputs",
             type: "tuple[]",
@@ -7825,6 +7830,255 @@ function encodeISMPMessage(message) {
     throw new Error("Failed to encode ISMP message", { cause: error });
   }
 }
+
+// src/utils/rateLimiter.ts
+var TokenBucket = class {
+  /**
+   * @param ratePerSecond - sustained requests per second.
+   * @param burst - how many requests may go out back-to-back before pacing starts. Defaults to
+   *   one second's worth, which is the shape most limiters police.
+   */
+  constructor(ratePerSecond, burst = ratePerSecond) {
+    this.ratePerSecond = ratePerSecond;
+    this.burst = burst;
+    if (ratePerSecond <= 0) throw new Error(`TokenBucket rate must be positive, got ${ratePerSecond}`);
+    this.tokens = burst;
+    this.lastRefill = Date.now();
+  }
+  ratePerSecond;
+  burst;
+  /** Fractional on purpose: a partial token is real capacity, just not yet a whole request. */
+  tokens;
+  lastRefill;
+  waiting = [];
+  drainTimer = null;
+  /** Resolves once this caller may send. */
+  async acquire() {
+    if (this.waiting.length === 0 && this.take()) return;
+    return new Promise((resolve) => {
+      this.waiting.push(resolve);
+      this.scheduleDrain();
+    });
+  }
+  /** Requests currently waiting on a token. Exposed for tests and diagnostics. */
+  get queued() {
+    return this.waiting.length;
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    if (elapsed <= 0) {
+      if (elapsed < 0) this.lastRefill = now;
+      return;
+    }
+    this.tokens = Math.min(this.burst, this.tokens + elapsed * this.ratePerSecond / 1e3);
+    this.lastRefill = now;
+  }
+  take() {
+    this.refill();
+    if (this.tokens < 1) return false;
+    this.tokens -= 1;
+    return true;
+  }
+  scheduleDrain() {
+    if (this.drainTimer) return;
+    this.refill();
+    const deficit = 1 - this.tokens;
+    const waitMs = deficit <= 0 ? 0 : Math.ceil(deficit * 1e3 / this.ratePerSecond);
+    const timer = setTimeout(() => {
+      this.drainTimer = null;
+      this.drain();
+    }, waitMs);
+    timer.unref?.();
+    this.drainTimer = timer;
+  }
+  drain() {
+    while (this.waiting.length > 0 && this.take()) {
+      this.waiting.shift()?.();
+    }
+    if (this.waiting.length > 0) this.scheduleDrain();
+  }
+};
+var BATCHES_NOT_SUPPORTED_CODE = -32005;
+var TOO_BIG_BATCH_REQUEST_CODE = -32010;
+var DEFAULT_MAX_BATCH_SIZE = 32;
+function rpcError({ code, message, data }) {
+  const suffix = data === void 0 ? "" : `: ${typeof data === "string" ? data : JSON.stringify(data)}`;
+  const error = new Error(`${code}: ${message}${suffix}`);
+  error.code = code;
+  error.data = data;
+  return error;
+}
+var BatchingHttpProvider = class _BatchingHttpProvider extends api.HttpProvider {
+  #endpoint;
+  #headers;
+  #limiter;
+  #maxBatchSize;
+  #batchingSupported = true;
+  #pending = [];
+  #flushTimer = null;
+  #flushing = false;
+  #nextId = 1;
+  constructor(endpoint, headers, limiter, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
+    super(endpoint, headers, 0);
+    this.#endpoint = endpoint;
+    this.#headers = headers;
+    this.#limiter = limiter;
+    this.#maxBatchSize = maxBatchSize;
+  }
+  /**
+   * `isCacheable` is accepted for interface compatibility and ignored: this provider has no
+   * response cache, which is deliberate — see the note in `IntentsCoprocessor.http`.
+   */
+  async send(method, params, _isCacheable) {
+    return new Promise((resolve, reject) => {
+      this.#pending.push({
+        id: this.#nextId++,
+        method,
+        params,
+        resolve,
+        reject
+      });
+      if (this.#pending.length >= this.#maxBatchSize) this.#flushNow();
+      else this.#scheduleFlush();
+    });
+  }
+  clone() {
+    return new _BatchingHttpProvider(this.#endpoint, this.#headers, this.#limiter, this.#maxBatchSize);
+  }
+  /** Calls waiting for a flush. Exposed for tests and diagnostics. */
+  get queued() {
+    return this.#pending.length;
+  }
+  /**
+   * Collect for the rest of this macrotask, then send.
+   *
+   * A macrotask rather than a microtask because the bursts worth catching are not synchronous:
+   * `Promise.all` over a set of reads starts them in one synchronous run, but each then advances
+   * through several microtask turns of its own before reaching the provider. A microtask flush
+   * would fire between those turns and split one burst across several requests.
+   */
+  #scheduleFlush() {
+    if (this.#flushTimer || this.#flushing) return;
+    const timer = setTimeout(() => {
+      this.#flushTimer = null;
+      void this.#flush();
+    }, 0);
+    timer.unref?.();
+    this.#flushTimer = timer;
+  }
+  #flushNow() {
+    if (this.#flushing) return;
+    if (this.#flushTimer) {
+      clearTimeout(this.#flushTimer);
+      this.#flushTimer = null;
+    }
+    void this.#flush();
+  }
+  async #flush() {
+    if (this.#flushing) return;
+    const calls = this.#pending.splice(0, this.#maxBatchSize);
+    if (calls.length === 0) return;
+    this.#flushing = true;
+    try {
+      await this.#limiter.acquire();
+      await this.#post(calls);
+    } finally {
+      this.#flushing = false;
+      if (this.#pending.length > 0) this.#scheduleFlush();
+    }
+  }
+  async #post(calls) {
+    const single = calls.length === 1;
+    const payload = calls.map(({ id, method, params }) => ({ id, jsonrpc: "2.0", method, params }));
+    const body = JSON.stringify(single ? payload[0] : payload);
+    let parsed;
+    try {
+      const response = await fetch(this.#endpoint, {
+        body,
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...this.#headers
+        },
+        method: "POST"
+      });
+      if (!response.ok) throw new Error(`[${response.status}]: ${response.statusText}`);
+      parsed = JSON.parse(await response.text());
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      error.message = `${error.message}
+Failed HTTP Request: ${JSON.stringify(
+        calls.map(({ method, params }) => ({ method, params }))
+      )}`;
+      for (const call of calls) call.reject(error);
+      return;
+    }
+    if (Array.isArray(parsed)) {
+      this.#settleBatch(calls, parsed);
+      return;
+    }
+    if (!single) {
+      this.#handleBatchRefusal(calls, parsed);
+      return;
+    }
+    this.#settle(calls[0], parsed);
+  }
+  #settleBatch(calls, responses) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const response of responses) {
+      if (typeof response?.id === "number") byId.set(response.id, response);
+    }
+    for (const call of calls) {
+      const response = byId.get(call.id);
+      if (response) this.#settle(call, response);
+      else call.reject(new Error(`No response for ${call.method} in batch reply`));
+    }
+  }
+  #settle(call, response) {
+    if (response?.error) {
+      call.reject(rpcError(response.error));
+      return;
+    }
+    if (!response || response.result === void 0) {
+      call.reject(new Error("No result found in jsonrpc response"));
+      return;
+    }
+    call.resolve(response.result);
+  }
+  /**
+   * The server rejected the batch itself rather than any call in it. Both forms are recoverable
+   * without losing a call, and neither should ever surface to a caller as a failure.
+   */
+  #handleBatchRefusal(calls, response) {
+    const code = response?.error?.code;
+    if (code === BATCHES_NOT_SUPPORTED_CODE) {
+      this.#batchingSupported = false;
+      this.#maxBatchSize = 1;
+      this.#requeue(calls);
+      return;
+    }
+    if (code === TOO_BIG_BATCH_REQUEST_CODE) {
+      this.#maxBatchSize = Math.max(1, Math.floor(this.#maxBatchSize / 2));
+      this.#requeue(calls);
+      return;
+    }
+    const error = response?.error ? rpcError(response.error) : new Error("Malformed batch reply: neither an array nor an error");
+    for (const call of calls) call.reject(error);
+  }
+  /** Puts calls back at the head of the queue, so a refused batch keeps its place in line. */
+  #requeue(calls) {
+    this.#pending.unshift(...calls);
+    this.#scheduleFlush();
+  }
+  /** Whether batches are still being attempted. Exposed for tests and diagnostics. */
+  get batchingSupported() {
+    return this.#batchingSupported;
+  }
+};
+
+// src/chains/intentsCoprocessor.ts
+var SYSTEM_EVENTS_KEY = util.u8aToHex(util.u8aConcat(utilCrypto.xxhashAsU8a("System", 128), utilCrypto.xxhashAsU8a("Events", 128)));
 var OFFCHAIN_BID_PREFIX = new TextEncoder().encode("intents::bid::");
 var OFFCHAIN_PHANTOM_PREFIX = new TextEncoder().encode("intents::phantom::order::");
 var HYPERBRIDGE_TYPES_BUNDLE = {
@@ -7838,6 +8092,63 @@ var HTTP_CONNECT_TIMEOUT_MS = 2e4;
 var INCLUSION_TIMEOUT_MS = 2e4;
 var PHANTOM_POLL_INTERVAL_MS = 15e3;
 var GARGANTUA_PHANTOM_POLL_INTERVAL_MS = 6e3;
+var DEFAULT_RPC_MAX_RPS = 8;
+var DEFAULT_MAX_BLOCKS_PER_POLL = 10;
+var MAX_RATE_LIMIT_BACKOFF_TICKS = 8;
+var rpcLimiters = /* @__PURE__ */ new Map();
+function limiterFor(httpUrl) {
+  const key = new URL(httpUrl).origin;
+  let limiter = rpcLimiters.get(key);
+  if (!limiter) {
+    limiter = new TokenBucket(configuredRpcMaxRps());
+    rpcLimiters.set(key, limiter);
+  }
+  return limiter;
+}
+function configuredRpcMaxRps() {
+  const raw = typeof process !== "undefined" ? process.env?.HYPERBRIDGE_RPC_MAX_RPS : void 0;
+  const parsed = raw === void 0 ? Number.NaN : Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_RPC_MAX_RPS;
+}
+function isRateLimited(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.includes("[429]") || /too many requests/i.test(message);
+}
+function isMethodUnavailable(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err?.code;
+  return code === -32601 || /method not found|unsafe to be called externally/i.test(message);
+}
+var EventDecodeError = class extends Error {
+};
+function phantomOrdersFrom(records) {
+  if (records == null || typeof records[Symbol.iterator] !== "function") {
+    throw new EventDecodeError(`Expected a decoded event vector, got ${typeof records}`);
+  }
+  const orders = [];
+  for (const record of records) {
+    if (typeof record !== "object" || record === null || !("event" in record)) {
+      throw new EventDecodeError(
+        "system.events did not decode to event records \u2014 the storage entry's metadata was probably not carried through, leaving the value as raw bytes"
+      );
+    }
+    const { event } = record;
+    if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
+    const [commitment, chain, createdAt, legs] = event.data;
+    orders.push({
+      commitment: commitment.toHex(),
+      chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
+      createdAt: createdAt.toNumber(),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      legs: legs.map((leg) => ({
+        tokenA: leg.tokenA.toHex(),
+        tokenB: leg.tokenB.toHex(),
+        standardAmount: BigInt(leg.standardAmount.toString())
+      }))
+    });
+  }
+  return orders;
+}
 function rejectAfter(ms, message) {
   return new Promise((_resolve, reject) => {
     const timer = setTimeout(() => reject(new Error(message)), ms);
@@ -7909,8 +8220,14 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   ownsConnection;
   /** Cached result of whether the node exposes intents_* RPC methods */
   hasIntentsRpc = null;
+  /** The pallet's phantom timings, read once. Cleared on failure so the read retries. */
+  phantomTimingsRead = null;
   /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
   httpApi = null;
+  /** Last runtime version read from the node, for {@link confirmedRuntimeVersion} to compare against. */
+  lastRuntimeVersion;
+  /** Set once the node refuses `state_queryStorage`, so the poll stops asking for it. */
+  rangeQueryUnavailable = false;
   // Serialises every extrinsic submission on this instance's substrate account. All submit/retract
   // methods funnel through signAndSendExtrinsic, each using the API's auto-nonce; fired in parallel
   // (bids for orders on different chains, or several phantom orders in one interval) they would grab
@@ -8010,7 +8327,11 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         // replayed from memory on every tick, faster than the TTL could lapse, and the node never
         // saw a second request. The cache bought nothing here anyway: the poll reads each block
         // once, and `api.at(hash)` reuses registries at the api layer regardless.
-        provider: new api.HttpProvider(httpUrl, {}, 0),
+        // Concurrent calls are coalesced into one JSON-RPC batch request, and every request
+        // to this endpoint is paced by a bucket shared with any other coprocessor in this
+        // process pointed at the same host — the limit is the server's, and it counts
+        // requests per address rather than per connection.
+        provider: new BatchingHttpProvider(httpUrl, {}, limiterFor(httpUrl)),
         typesBundle: HYPERBRIDGE_TYPES_BUNDLE,
         // A second connection to the node the ws api already reported on; its init warnings
         // would just be duplicates.
@@ -8578,29 +8899,77 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   }
   /**
    * Reads the PhantomOrderRegistered events emitted in a single block.
+   *
+   * Costs two RPCs per block when `knownVersion` is supplied and four without it, which is why the
+   * poll goes to the trouble of establishing one. `api.at(hash)` has to work out which metadata to
+   * decode the block against, and with nothing to go on it fetches the header and then the runtime
+   * version at its parent — every block, forever. Its cheaper paths are a registry already pinned
+   * to this exact hash (only ever the previous block's) or one matching a version the caller
+   * names, so naming the version is the only way out. See `getBlockRegistry` in
+   * `@polkadot/api/base/Init`; the `getUpgradeVersion` shortcut that would otherwise skip the
+   * lookup only covers chains hardcoded in `@polkadot/types-known`, which Hyperbridge is not.
+   *
+   * @param knownVersion - the runtime version this block is known to run, if the caller has
+   *   established one. Passing a version the block does not actually run decodes it against the
+   *   wrong metadata, so this is for callers that have checked, not a place to pass a guess.
    */
-  async getPhantomOrdersInBlock(blockNumber) {
+  async getPhantomOrdersInBlock(blockNumber, knownVersion) {
     const api = await this.http();
     const blockHash = await api.rpc.chain.getBlockHash(blockNumber);
-    const apiAt = await api.at(blockHash);
-    const records = await apiAt.query.system.events();
-    const orders = [];
-    for (const { event } of records) {
-      if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
-      const [commitment, chain, createdAt, legs] = event.data;
-      orders.push({
-        commitment: commitment.toHex(),
-        chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
-        createdAt: createdAt.toNumber(),
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        legs: legs.map((leg) => ({
-          tokenA: leg.tokenA.toHex(),
-          tokenB: leg.tokenB.toHex(),
-          standardAmount: BigInt(leg.standardAmount.toString())
-        }))
-      });
-    }
-    return orders;
+    return await this.getPhantomOrdersAtHash(blockHash.toHex(), knownVersion);
+  }
+  /**
+   * The same read, for a caller that already holds the block's hash.
+   *
+   * Split out so the poll can fetch a whole range's hashes in one concurrent wave — which the
+   * provider coalesces into a single batched request — and then read each block's events knowing
+   * its hash. `chain_getBlockHash` is the half of the pair that parallelises safely: it takes no
+   * historic block hash, so it never triggers polkadot-js's per-hash registry resolution, and
+   * concurrent calls cannot race each other's registry state.
+   */
+  async getPhantomOrdersAtHash(blockHash, knownVersion) {
+    const api = await this.http();
+    const apiAt = await api.at(blockHash, knownVersion);
+    return phantomOrdersFrom(await apiAt.query.system.events());
+  }
+  /**
+   * Every block's phantom orders across a whole range, in one `state_queryStorage` call.
+   *
+   * This is the cheap path: the request cost of a scan stops depending on how many blocks it
+   * covers. The events key is the only key queried, and both bounds are block hashes the caller
+   * already holds.
+   *
+   * Two properties of the RPC shape the result.
+   *
+   * It returns *diffs*: `query_storage_unfiltered` in `sc-rpc` pushes a change set for a block only
+   * when the value differs from the previous block in the range (`has_changed`, and the set is
+   * dropped when empty), so a block whose events encode byte-for-byte identically to its
+   * predecessor's is simply absent. That happens on a quiet chain, where consecutive blocks carry
+   * nothing but the timestamp inherent's `ExtrinsicSuccess`. It is safe here because an absent
+   * block provably carries no phantom orders: a `PhantomOrderRegistered` commitment is derived from
+   * the block number (`phantom_order_commitment`), so a block that registered orders can never
+   * encode identically to any other block. Absent therefore means "same as the previous block",
+   * and the previous block having orders would contradict that.
+   *
+   * And it is gated by `--rpc-methods` (`check_if_safe` in `sc-rpc`), which answers a denied call
+   * with `Method not found`. The node this reads from must already run unsafe RPC to serve
+   * `offchain_localStorageGet` for the orders themselves, so this is normally available; the poll
+   * falls back to reading block by block when it is not.
+   *
+   * @returns one entry per block the node reported a change for, in ascending block order.
+   */
+  async getPhantomOrdersInRange(fromBlockHash, toBlockHash) {
+    const api = await this.http();
+    const changeSets = await api.rpc.state.queryStorage.raw(
+      [SYSTEM_EVENTS_KEY],
+      fromBlockHash,
+      toBlockHash
+    );
+    return changeSets.map((changeSet) => {
+      const value = changeSet?.changes?.find(([key]) => key === SYSTEM_EVENTS_KEY)?.[1];
+      if (!value) return [];
+      return phantomOrdersFrom(api.registry.createType("Vec<EventRecord>", value));
+    });
   }
   /**
    * Polls for newly registered phantom orders, invoking the callback once per block that carries
@@ -8628,30 +8997,85 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * socket that looks alive while delivering nothing. It also means a websocket outage does not
    * pause phantom bidding at all — the two transports fail independently.
    *
+   * What the cadence does *not* describe is the request rate, which is what rate limiters police.
+   * A tick costs four requests whatever the range covers — the head, the runtime version, the two
+   * bounding block hashes as one batched request, and one `state_queryStorage` for every block's
+   * events — and they go out back-to-back, so an interval well under any per-second limit could
+   * still arrive as a burst over it. Three things keep that in bounds: the provider coalesces
+   * concurrent calls into one request and paces requests through the endpoint's token bucket (see
+   * `http`), and `maxBlocksPerPoll` bounds the range. A 429 that gets through anyway backs the
+   * poll off for a doubling number of ticks, so a limiter that is already shedding load is not
+   * handed the next window's budget in rejections too.
+   *
+   * Where the node will not serve `state_queryStorage` the poll reads block by block instead, at
+   * three requests plus one per block; see {@link scanRangeAtOnce}.
+   *
    * Returns a function that stops polling.
    */
   pollPhantomOrders(callback, options = {}) {
-    const { intervalMs, maxBlocksPerPoll = 500, lookbackBlocks = 0, onError } = options;
+    const {
+      intervalMs,
+      maxBlocksPerPoll = DEFAULT_MAX_BLOCKS_PER_POLL,
+      onError,
+      onSkip
+    } = options;
     let cursor = null;
     let inFlight = false;
     let stopped = false;
+    let backoffTicks = 0;
+    let backoffLength = 0;
     const tick = async () => {
       if (inFlight || stopped) return;
+      if (backoffTicks > 0) {
+        backoffTicks -= 1;
+        return;
+      }
       inFlight = true;
       try {
-        const head = (await (await this.http()).rpc.chain.getHeader()).number.toNumber();
+        const api = await this.http();
+        const head = (await api.rpc.chain.getHeader()).number.toNumber();
         if (cursor === null) {
-          cursor = Math.max(head - 1 - lookbackBlocks, -1);
+          cursor = Math.max(head - 1, -1);
+        } else {
+          const { bidWindowBlocks, intervalBlocks } = await this.phantomTimings();
+          if (head - cursor > bidWindowBlocks + Math.max(intervalBlocks, bidWindowBlocks)) {
+            const from = cursor + 1;
+            cursor = Math.max(head - 1 - bidWindowBlocks, -1);
+            onSkip?.({ from, to: cursor, head });
+          }
         }
         if (head <= cursor) return;
+        const knownVersion = await this.confirmedRuntimeVersion();
         const to = Math.min(head, cursor + maxBlocksPerPoll);
-        for (let blockNumber = cursor + 1; blockNumber <= to; blockNumber++) {
+        const ranged = await this.scanRangeAtOnce(api, cursor + 1, to, knownVersion, onError);
+        if (ranged) {
+          for (const orders of ranged) {
+            if (stopped) return;
+            if (orders.length > 0) callback(orders);
+          }
+          cursor = to;
+          backoffLength = 0;
+          return;
+        }
+        const numbers = [];
+        for (let blockNumber = cursor + 1; blockNumber <= to; blockNumber++) numbers.push(blockNumber);
+        const hashes = await Promise.allSettled(
+          numbers.map((blockNumber) => api.rpc.chain.getBlockHash(blockNumber))
+        );
+        for (let index = 0; index < numbers.length; index++) {
           if (stopped) return;
-          const orders = await this.getPhantomOrdersInBlock(blockNumber);
+          const hash = hashes[index];
+          if (hash.status === "rejected") throw hash.reason;
+          const orders = await this.getPhantomOrdersAtHash(hash.value.toHex(), knownVersion);
           if (orders.length > 0) callback(orders);
-          cursor = blockNumber;
+          cursor = numbers[index];
         }
+        backoffLength = 0;
       } catch (err) {
+        if (isRateLimited(err)) {
+          backoffLength = Math.min(backoffLength === 0 ? 1 : backoffLength * 2, MAX_RATE_LIMIT_BACKOFF_TICKS);
+          backoffTicks = backoffLength;
+        }
         onError?.(err);
       } finally {
         inFlight = false;
@@ -8670,6 +9094,125 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       if (timer) clearInterval(timer);
     };
   }
+  /**
+   * The Hyperbridge head, over HTTP like every other read here.
+   *
+   * Exposed for callers that have to know how old something is: a phantom order carries the block
+   * it was registered at, and only against the head does that become "still biddable" or "long
+   * expired".
+   */
+  async latestBlockNumber() {
+    const api = await this.http();
+    return (await api.rpc.chain.getHeader()).number.toNumber();
+  }
+  /**
+   * The pallet's phantom timings, read from chain state.
+   *
+   * Both are governance-settable and neither is derivable: on Nexus today the window is 15 while
+   * the runtime constant behind it is 25, so anything hard-coded is wrong in one direction or the
+   * other — too tight and live orders are dropped, too loose and bids are sent into a closed
+   * window for the pallet to reject.
+   *
+   * Read once per instance and cached, because a governance change to either is rare and a read
+   * per poll tick would be a request per tick forever. The cost is that a change is picked up on
+   * the next restart rather than immediately. A failed read is not cached, so it retries.
+   */
+  async phantomTimings() {
+    if (!this.phantomTimingsRead) {
+      this.phantomTimingsRead = this.readPhantomTimings().catch((err) => {
+        this.phantomTimingsRead = null;
+        throw err;
+      });
+    }
+    return this.phantomTimingsRead;
+  }
+  async readPhantomTimings() {
+    const api = await this.http();
+    const [window, interval] = await Promise.all([
+      api.query.intentsCoprocessor.phantomBidWindow(),
+      api.query.intentsCoprocessor.phantomOrderInterval()
+    ]);
+    const stored = Number(window.toString());
+    return {
+      bidWindowBlocks: stored === 0 ? Number(api.consts.intentsCoprocessor.phantomOrderBidWindowBlocks.toString()) : stored,
+      intervalBlocks: Number(interval.toString())
+    };
+  }
+  /**
+   * A whole range of blocks in one `state_queryStorage` call, or `null` when that is not available
+   * and the caller should read block by block.
+   *
+   * Two conditions have to hold, and both are about decoding rather than the range itself.
+   *
+   * The version must be confirmed for this tick — an upgrade inside the range means blocks decode
+   * against different metadata, and one call cannot do that.
+   *
+   * And that confirmed version must still be the one the api's own registry was built for.
+   * `state_queryStorage` declares no historic block hash, so rpc-core skips its registry swap and
+   * decodes the reply against the default registry — fixed at connect, with no
+   * `subscribeRuntimeVersion` on an HTTP api to refresh it. After an upgrade the two diverge, and
+   * the per-block path takes over for good: `api.at(hash, version)` resolves, and builds, the right
+   * registry. That costs a restart to get the cheap path back, which is the correct direction to
+   * fail in.
+   */
+  async scanRangeAtOnce(api, from, to, knownVersion, onError) {
+    if (this.rangeQueryUnavailable || !knownVersion) return null;
+    const registryVersion = api.runtimeVersion?.specVersion;
+    if (!registryVersion || !knownVersion.specVersion.eq(registryVersion)) return null;
+    const [fromHash, toHash] = from === to ? await Promise.all([api.rpc.chain.getBlockHash(from)]).then(([only]) => [only, only]) : await Promise.all([api.rpc.chain.getBlockHash(from), api.rpc.chain.getBlockHash(to)]);
+    try {
+      return await this.getPhantomOrdersInRange(fromHash.toHex(), toHash.toHex());
+    } catch (err) {
+      if (isMethodUnavailable(err)) {
+        this.rangeQueryUnavailable = true;
+        return null;
+      }
+      if (err instanceof EventDecodeError) {
+        this.rangeQueryUnavailable = true;
+        onError?.(err);
+        return null;
+      }
+      throw err;
+    }
+  }
+  /**
+   * The runtime version this tick's blocks may be decoded against, or `undefined` when that cannot
+   * be established and each block must resolve its own.
+   *
+   * Naming a version to `api.at` is what removes two of the four RPCs a block scan costs, and it
+   * is only sound while the version is actually the block's. Getting that wrong is not a loud
+   * failure: events decoded against the wrong metadata come back as a shape the scan does not
+   * recognise, so the block reads as carrying no phantom orders and the cursor advances past it —
+   * exactly the silent miss the block cursor exists to rule out.
+   *
+   * So the version is read fresh each tick and only used when it matches the previous reading.
+   * `specVersion` only ever increases, and this read happens *after* the head read, so two equal
+   * readings mean no upgrade landed anywhere in between — and therefore none in the range about to
+   * be scanned. A reading that differs means an upgrade landed inside the range: that tick falls
+   * back to per-block resolution, which is exact, and the version is used from the next tick on
+   * once it has been seen twice.
+   *
+   * The gap this leaves is a backlog reaching back past an upgrade, whose oldest blocks predate
+   * even the previous reading. Recovering from an outage that long means those bid windows closed
+   * many upgrades ago, so nothing is lost that was still winnable.
+   *
+   * A version that cannot be read at all yields `undefined` rather than an error: the scan is
+   * about to make the same request against the same endpoint and is the better place to report it.
+   */
+  async confirmedRuntimeVersion() {
+    let api;
+    let current;
+    try {
+      api = await this.http();
+      current = await api.rpc.state.getRuntimeVersion();
+    } catch {
+      return void 0;
+    }
+    const previous = this.lastRuntimeVersion ?? api.runtimeVersion;
+    this.lastRuntimeVersion = current;
+    if (!previous?.specVersion || !previous?.specName) return void 0;
+    return current.specVersion.eq(previous.specVersion) && current.specName.eq(previous.specName) ? current : void 0;
+  }
   /**
    * The poll cadence for the runtime this instance is connected to: Gargantua polls every block,
    * everything else every 15s. Falls back to the slower cadence if the runtime cannot be read,
@@ -17047,6 +17590,115 @@ var OrderCanceller = class _OrderCanceller {
     return feeInDestFeeToken * 1005n / 1000n;
   }
 };
+var FILL_ORDER_V1_ABI = [
+  {
+    type: "function",
+    name: "fillOrder",
+    stateMutability: "payable",
+    outputs: [],
+    inputs: [
+      ABI3.find((e) => e.type === "function" && e.name === "fillOrder").inputs[0],
+      {
+        name: "options",
+        type: "tuple",
+        internalType: "struct FillOptions",
+        components: [
+          { name: "relayerFee", type: "uint256", internalType: "uint256" },
+          { name: "nativeDispatchFee", type: "uint256", internalType: "uint256" },
+          {
+            name: "outputs",
+            type: "tuple[]",
+            internalType: "struct TokenInfo[]",
+            components: [
+              { name: "token", type: "bytes32", internalType: "bytes32" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+];
+var ERC1967_IMPLEMENTATION_SLOT = "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
+var LEGACY_FILL_OPTIONS_IMPLEMENTATIONS = /* @__PURE__ */ new Set([
+  // The pre-validUntil IntentGatewayV2 implementation. One entry covers every chain: the
+  // protocol contracts are CREATE2-deployed, so this is the implementation address on all
+  // of them (confirmed with the maintainers).
+  "0x976b268b06f545c4a2bf44866aa2465bd8b3c67d"
+]);
+var CHAINS_WITHOUT_VALID_UNTIL = /* @__PURE__ */ new Set([
+  97,
+  // BNB testnet
+  10200,
+  // Gnosis Chiado
+  80002,
+  // Polygon Amoy
+  84532,
+  // Base Sepolia
+  421614,
+  // Arbitrum Sepolia
+  688689,
+  // Pharos testnet
+  11155111,
+  // Sepolia
+  11155420,
+  // Optimism Sepolia
+  420420417
+  // Polkadot Hub Paseo
+]);
+var knownV2Gateways = /* @__PURE__ */ new Set();
+function resetFillOptionsVersionCache() {
+  knownV2Gateways.clear();
+}
+async function resolveImplementation(client, gateway) {
+  const slot = await client.getStorageAt({ address: gateway, slot: ERC1967_IMPLEMENTATION_SLOT });
+  if (!slot || slot.length < 66) return gateway;
+  const addr = `0x${slot.slice(-40)}`;
+  return /^0x0{40}$/.test(addr) ? gateway : addr;
+}
+async function getFillOptionsVersion(client, gateway) {
+  const chainId = client.chain?.id;
+  if (chainId !== void 0 && CHAINS_WITHOUT_VALID_UNTIL.has(chainId)) return 1;
+  const key = gateway.toLowerCase();
+  if (knownV2Gateways.has(key)) return 2;
+  const implementation = await resolveImplementation(client, gateway);
+  if (LEGACY_FILL_OPTIONS_IMPLEMENTATIONS.has(implementation.toLowerCase())) return 1;
+  knownV2Gateways.add(key);
+  return 2;
+}
+function encodeFillOrder(order, options, version) {
+  if (version === 2) {
+    return viem.encodeFunctionData({
+      abi: ABI3,
+      functionName: "fillOrder",
+      args: [order, options]
+    });
+  }
+  const { relayerFee, nativeDispatchFee, outputs } = options;
+  return viem.encodeFunctionData({
+    abi: FILL_ORDER_V1_ABI,
+    functionName: "fillOrder",
+    args: [order, { relayerFee, nativeDispatchFee, outputs }]
+  });
+}
+function decodeFillOrder(data) {
+  try {
+    const decoded = viem.decodeFunctionData({ abi: ABI3, data });
+    if (decoded.functionName === "fillOrder" && decoded.args && decoded.args.length >= 2) {
+      return { order: decoded.args[0], options: decoded.args[1] };
+    }
+  } catch {
+  }
+  try {
+    const decoded = viem.decodeFunctionData({ abi: FILL_ORDER_V1_ABI, data });
+    if (decoded.functionName === "fillOrder" && decoded.args && decoded.args.length >= 2) {
+      const legacy = decoded.args[1];
+      return { order: decoded.args[0], options: { ...legacy, validUntil: 0n } };
+    }
+  } catch {
+  }
+  return null;
+}
 var BidImpl = class {
   solverAddress;
   outputs;
@@ -17477,19 +18129,9 @@ var BidManager = class {
       const innerCalls = this.crypto.decodeERC7821Execute(bid.userOp.callData);
       if (!innerCalls || innerCalls.length === 0) return null;
       for (const call of innerCalls) {
-        try {
-          const decoded = viem.decodeFunctionData({
-            abi: ABI3,
-            data: call.data
-          });
-          if (decoded?.functionName === "fillOrder" && decoded.args && decoded.args.length >= 2) {
-            const fillOptions = decoded.args[1];
-            if (fillOptions?.outputs?.length > 0) {
-              return fillOptions;
-            }
-          }
-        } catch {
-          continue;
+        const decoded = decodeFillOrder(call.data);
+        if (decoded && decoded.options?.outputs?.length > 0) {
+          return decoded.options;
         }
       }
     } catch {
@@ -17867,6 +18509,10 @@ var GasEstimator = class {
       relayerFee: crossChainFees.postRequestFee,
       // Always dispatch with the fee token (see the method docs).
       nativeDispatchFee: 0n,
+      // Unbounded for estimation: this call is simulated, never submitted, and a real
+      // bound here would only risk the estimate reverting on a slow bundler round trip.
+      // The caller sets the real one on the options it actually signs.
+      validUntil: 0n,
       outputs: order.output.assets.map((asset) => ({
         ...asset,
         token: normalizeAddressForEvmBytes32(asset.token)
@@ -17879,11 +18525,12 @@ var GasEstimator = class {
     let maxFeePerGas = gasPrice + gasPrice * BigInt(maxFeeBumpPercent) / 100n;
     const orderForEstimation = { ...order, session: solverAccountAddress };
     const commitment = orderCommitment(orderForEstimation);
-    const fillOrderCalldata = viem.encodeFunctionData({
-      abi: ABI3,
-      functionName: "fillOrder",
-      args: [transformOrderForContract(orderForEstimation), fillOptions]
-    });
+    const fillOptionsVersion = await getFillOptionsVersion(this.ctx.dest.client, intentGatewayV2Address);
+    const fillOrderCalldata = encodeFillOrder(
+      transformOrderForContract(orderForEstimation),
+      fillOptions,
+      fillOptionsVersion
+    );
     let callGasLimit = 500000n;
     let verificationGasLimit = 100000n;
     let preVerificationGas = 100000n;
@@ -18971,7 +19618,18 @@ function buildResult(tradeType, amountIn, amountOut, selectedRate, rates, protoc
 }
 
 // src/protocols/intents/IntentGateway.ts
-var CROSS_CHAIN_ORDER_FEE_GAS_PRICE_BUMP_PERCENT = 10n;
+var ORDER_FEE_GAS_PRICE_BUMP_POLICY = {
+  defaultPercent: 10n,
+  bySourceStateMachineId: {
+    ["EVM-1" /* MAINNET */]: 50n
+  }
+};
+function resolveOrderFeeGasPriceBump(sourceStateMachineId, isSameChain) {
+  if (isSameChain) {
+    return 0n;
+  }
+  return ORDER_FEE_GAS_PRICE_BUMP_POLICY.bySourceStateMachineId[sourceStateMachineId] ?? ORDER_FEE_GAS_PRICE_BUMP_POLICY.defaultPercent;
+}
 var IntentGateway = class _IntentGateway {
   /** EVM chain on which orders are placed and escrowed. */
   source;
@@ -19190,8 +19848,9 @@ var IntentGateway = class _IntentGateway {
    * **Yield/receive protocol:**
    * 1. If `order.fees` is unset or zero, prices the fee on an internal copy
    *    via {@link quoteOrderFees}: same-chain fees are twice the fill-gas
-   *    estimate without a gas-price bump; cross-chain gas is priced 10% above
-   *    the live price before attaching (fill gas + the settlement relayer fee)
+   *    estimate without a gas-price bump; cross-chain order fees originating on
+   *    Ethereum price gas 50% above the live price, while other source chains use
+   *    10%, before attaching (fill gas + the settlement relayer fee)
    *    with a further 5% buffer over the whole sum — strictly above the solver's
    *    unpadded requirement. Direct solver estimates remain unbumped. The wei
    *    cost used for the `value` field receives a 2% buffer.
@@ -19561,7 +20220,8 @@ var IntentGateway = class _IntentGateway {
    * transaction (check the native balance).
    *
    * @param order - The order to quote. `order.fees` is ignored and not mutated.
-   * Gas prices used to derive cross-chain `fees` receive 10% SDK-only headroom.
+   * Gas prices used to derive cross-chain `fees` receive 50% SDK-only headroom
+   * when the source chain is Ethereum mainnet and 10% for other source chains.
    * Same-chain quotes and direct calls to {@link estimateFillOrder}, including
    * Simplex solver estimates, remain unbumped.
    *
@@ -19572,15 +20232,14 @@ var IntentGateway = class _IntentGateway {
    */
   async quoteOrderFees(order, options) {
     const isSameChain = this.source.config.stateMachineId === this.dest.config.stateMachineId;
+    const orderFeeGasPriceBumpPercent = resolveOrderFeeGasPriceBump(this.source.config.stateMachineId, isSameChain);
     const estimate = await this.gasEstimator.estimateFillOrder(
       {
         order,
         maxPriorityFeePerGasBumpPercent: options?.maxPriorityFeePerGasBumpPercent,
         maxFeePerGasBumpPercent: options?.maxFeePerGasBumpPercent
       },
-      {
-        orderFeeGasPriceBumpPercent: isSameChain ? 0n : CROSS_CHAIN_ORDER_FEE_GAS_PRICE_BUMP_PERCENT
-      }
+      { orderFeeGasPriceBumpPercent }
     );
     if (estimate.totalGasCostWei === 0n || estimate.totalGasInFeeToken === 0n) {
       throw new Error("Gas estimation failed");
@@ -19809,9 +20468,16 @@ function encodeAcceptedSourceChains(chains2) {
 function decodeAcceptedSourceChains(paymasterAndData) {
   return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
 }
-var UNISWAP_QUOTE_HAIRCUT_BPS = 30n;
+var UNISWAP_QUOTE_HAIRCUT_BPS = 10n;
+var PHANTOM_QUOTE_HAIRCUT_BPS = 5n;
+function haircut(amount, bps) {
+  return amount * (10000n - bps) / 10000n;
+}
 function applyUniswapQuoteHaircut(amount) {
-  return amount * (10000n - UNISWAP_QUOTE_HAIRCUT_BPS) / 10000n;
+  return haircut(amount, UNISWAP_QUOTE_HAIRCUT_BPS);
+}
+function applyPhantomQuoteHaircut(amount) {
+  return haircut(amount, PHANTOM_QUOTE_HAIRCUT_BPS);
 }
 FILL_ORDER_ABI.find(
   (item) => item?.type === "function" && item?.name === "fillOrder"
@@ -24288,6 +24954,7 @@ async function teleportDot(param_) {
 
 exports.ADDRESS_ZERO = ADDRESS_ZERO2;
 exports.BundlerMethod = BundlerMethod;
+exports.CHAINS_WITHOUT_VALID_UNTIL = CHAINS_WITHOUT_VALID_UNTIL;
 exports.ChainConfigService = ChainConfigService;
 exports.Chains = Chains;
 exports.CryptoUtils = CryptoUtils;
@@ -24300,6 +24967,7 @@ exports.ERC7821_BATCH_MODE = ERC7821_BATCH_MODE;
 exports.EvmChain = EvmChain;
 exports.EvmHostABI = ABI;
 exports.EvmLanguage = EvmLanguage;
+exports.FILL_ORDER_V1_ABI = FILL_ORDER_V1_ABI;
 exports.HyperClientStatus = HyperClientStatus;
 exports.HyperFungibleToken = HyperFungibleToken;
 exports.HyperFungibleTokenABI = HyperFungibleTokenABI;
@@ -24313,11 +24981,13 @@ exports.InvalidIndexedRateError = InvalidIndexedRateError;
 exports.InvalidLiquidityIndexerResponseError = InvalidLiquidityIndexerResponseError;
 exports.InvalidPhantomSnapshotError = InvalidPhantomSnapshotError;
 exports.IsmpClient = IsmpClient;
+exports.LEGACY_FILL_OPTIONS_IMPLEMENTATIONS = LEGACY_FILL_OPTIONS_IMPLEMENTATIONS;
 exports.MOCK_ADDRESS = MOCK_ADDRESS;
 exports.ORDER_V2_PARAM_TYPE = ORDER_V2_PARAM_TYPE;
 exports.OrderStatus = OrderStatus;
 exports.OrderStatusChecker = OrderStatusChecker;
 exports.PACKED_USEROP_TYPEHASH = PACKED_USEROP_TYPEHASH;
+exports.PHANTOM_QUOTE_HAIRCUT_BPS = PHANTOM_QUOTE_HAIRCUT_BPS;
 exports.PLACE_ORDER_SELECTOR = PLACE_ORDER_SELECTOR;
 exports.PhantomSnapshotUnavailableError = PhantomSnapshotUnavailableError;
 exports.PharosChain = PharosChain;
@@ -24346,6 +25016,7 @@ exports.UnsupportedLiquidityChainError = UnsupportedLiquidityChainError;
 exports.WrappedHyperFungibleTokenABI = WrappedHyperFungibleTokenABI;
 exports.__test = __test;
 exports.adjustDecimals = adjustDecimals;
+exports.applyPhantomQuoteHaircut = applyPhantomQuoteHaircut;
 exports.applyUniswapQuoteHaircut = applyUniswapQuoteHaircut;
 exports.bytes20ToBytes32 = bytes20ToBytes32;
 exports.bytes32ToBytes20 = bytes32ToBytes20;
@@ -24365,11 +25036,13 @@ exports.createEvmChain = createEvmChain;
 exports.createQueryClient = createQueryClient;
 exports.decodeAcceptedSourceChains = decodeAcceptedSourceChains;
 exports.decodeERC7821ExecuteBatch = decodeERC7821ExecuteBatch;
+exports.decodeFillOrder = decodeFillOrder;
 exports.decodePhantomBidDeclaration = decodePhantomBidDeclaration;
 exports.decodeUserOpScale = decodeUserOpScale;
 exports.deriveHttpUrl = deriveHttpUrl;
 exports.encodeAcceptedSourceChains = encodeAcceptedSourceChains;
 exports.encodeERC7821ExecuteBatch = encodeERC7821ExecuteBatch;
+exports.encodeFillOrder = encodeFillOrder;
 exports.encodeISMPMessage = encodeISMPMessage;
 exports.encodePhantomBidDeclaration = encodePhantomBidDeclaration;
 exports.encodeStateMachineId = encodeStateMachineId;
@@ -24383,6 +25056,7 @@ exports.getChainId = getChainId;
 exports.getConfigByStateMachineId = getConfigByStateMachineId;
 exports.getContractCallInput = getContractCallInput;
 exports.getContractCallInputs = getContractCallInputs;
+exports.getFillOptionsVersion = getFillOptionsVersion;
 exports.getGasPriceFromEtherscan = getGasPriceFromEtherscan;
 exports.getOrFetchStorageSlot = getOrFetchStorageSlot;
 exports.getOrderPlacedFromTx = getOrderPlacedFromTx;
@@ -24414,6 +25088,7 @@ exports.queryGetRequest = queryGetRequest;
 exports.queryPostRequest = queryPostRequest;
 exports.quoteUniswap = quoteUniswap;
 exports.requestCommitmentKey = requestCommitmentKey;
+exports.resetFillOptionsVersionCache = resetFillOptionsVersionCache;
 exports.responseCommitmentKey = responseCommitmentKey;
 exports.retryPromise = retryPromise;
 exports.sortPoolSymbols = sortPoolSymbols;