@hyperbridge/sdk 2.8.2 → 2.8.3

package/dist/node/index.js

@@ -7,7 +7,7 @@ import { baseSepolia, optimismSepolia, arbitrumSepolia, soneium, gnosis, optimis
 import { TronWeb } from 'tronweb';
 import { flatten, zip, capitalize, maxBy, isNil } from 'lodash-es';
 import { match } from 'ts-pattern';
-import { WsProvider, ApiPromise, Keyring } from '@polkadot/api';
+import { WsProvider, ApiPromise, HttpProvider, Keyring } from '@polkadot/api';
 import { Struct, Vector, u8, Bytes, Enum, Tuple, _void, u64, u32, Option, bool, u128 } from 'scale-ts';
 import { keccakAsU8a, decodeAddress, keccakAsHex, xxhashAsU8a, blake2AsU8a } from '@polkadot/util-crypto';
 import { hexToU8a, u8aToHex, u8aConcat, stringToU8a, isHex as isHex$1, u8aToString } from '@polkadot/util';
@@ -2756,18 +2756,25 @@ var chainConfigs = {
       DAI: "0x1af3f329e8be154074d8769d1ffa4ee058b1dbc3",
       USDC: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
       USDT: "0x55d398326f99059ff775485246999027b3197955",
-      EXT: "0x7C8c11ADb8EF7cd3CFa718008Ea048445C6E7209"
+      EXT: "0x7C8c11ADb8EF7cd3CFa718008Ea048445C6E7209",
+      cNGN: "0xa8AEA66B361a8d53e8865c62D142167Af28Af058"
     },
     tokenDecimals: {
       USDC: 18,
       USDT: 18,
+      // 6, not 18 — cNGN keeps the same decimals it has on every other chain, unlike the
+      // Binance-pegged stables above. Every phantom standard_amount and pool rate divides
+      // by this, so the divergence from its neighbours here is load-bearing, not a typo.
+      cNGN: 6,
       EXT: 18
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 1, allowanceSlot: 2 },
       USDC: { balanceSlot: 1, allowanceSlot: 2 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 }
+      // custom upgradeable layout, as on Base
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -7799,6 +7806,27 @@ function encodeISMPMessage(message) {
 }
 var OFFCHAIN_BID_PREFIX = new TextEncoder().encode("intents::bid::");
 var OFFCHAIN_PHANTOM_PREFIX = new TextEncoder().encode("intents::phantom::order::");
+var HYPERBRIDGE_TYPES_BUNDLE = {
+  spec: {
+    nexus: { hasher: keccakAsU8a },
+    gargantua: { hasher: keccakAsU8a }
+  }
+};
+var BASE_TIP = 1000000000n;
+var HTTP_CONNECT_TIMEOUT_MS = 2e4;
+var PHANTOM_POLL_INTERVAL_MS = 15e3;
+var GARGANTUA_PHANTOM_POLL_INTERVAL_MS = 6e3;
+function rejectAfter(ms, message) {
+  return new Promise((_resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms);
+    timer.unref?.();
+  });
+}
+function deriveHttpUrl(wsUrl) {
+  if (wsUrl.startsWith("wss://")) return `https://${wsUrl.slice("wss://".length)}`;
+  if (wsUrl.startsWith("ws://")) return `http://${wsUrl.slice("ws://".length)}`;
+  throw new Error(`Cannot derive an HTTP endpoint from a non-websocket url: ${wsUrl}`);
+}
 var BidCodec = Struct({ filler: Bytes(32), user_op: Vector(u8) });
 var PackedUserOperationCodec = Struct({
   sender: Bytes(20),
@@ -7859,6 +7887,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   ownsConnection;
   /** Cached result of whether the node exposes intents_* RPC methods */
   hasIntentsRpc = null;
+  /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
+  httpApi = null;
   // 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
@@ -7875,12 +7905,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   static async connect(wsUrl, substratePrivateKey) {
     const api = await ApiPromise.create({
       provider: new WsProvider(wsUrl),
-      typesBundle: {
-        spec: {
-          nexus: { hasher: keccakAsU8a },
-          gargantua: { hasher: keccakAsU8a }
-        }
-      }
+      typesBundle: HYPERBRIDGE_TYPES_BUNDLE
     });
     return new _IntentsCoprocessor(api, substratePrivateKey, true);
   }
@@ -7906,15 +7931,85 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   static fromApi(api, substratePrivateKey) {
     return new _IntentsCoprocessor(api, substratePrivateKey, false);
   }
+  /**
+   * The API every RPC query runs on: HTTP, connected to the same node as the websocket. Exposed so
+   * callers query through this connection rather than opening one of their own.
+   *
+   * The split is by what each transport is for. Queries are one-shot request/response, which HTTP
+   * serves without holding any state that can silently rot between calls. The websocket earns its
+   * keep only where subscriptions do — watching a submitted extrinsic to inclusion.
+   */
+  async queryApi() {
+    return await this.http();
+  }
+  /**
+   * The websocket API, exposed so callers share this one connection instead of opening a second
+   * socket to the same node. Only needed for subscriptions; use {@link queryApi} to read.
+   */
+  get apiConnection() {
+    return this.api;
+  }
   /**
    * Disconnects the underlying API connection if this instance owns it.
-   * Only disconnects if created via `connect()`, not when using shared connections.
+   * Only disconnects the websocket if created via `connect()`, not when using shared connections.
+   * The HTTP api is always created here, so it is always ours to close.
    */
   async disconnect() {
+    const http4 = this.httpApi;
+    this.httpApi = null;
+    if (http4) {
+      await http4.then((api) => api.disconnect()).catch(() => {
+      });
+    }
     if (this.ownsConnection) {
       await this.api.disconnect();
     }
   }
+  /**
+   * The HTTP api for this node, connected on first use. Every coprocessor has one — the endpoint
+   * is derived from the websocket's own endpoint, so there is nothing to configure and nothing to
+   * be absent.
+   *
+   * The connection attempt is bounded on both sides. `isReadyOrError` rejects on a failed
+   * handshake, where plain `isReady` would simply never resolve, and the timeout covers an
+   * endpoint that accepts the request and then goes quiet. An unbounded wait here would hang the
+   * poll tick awaiting it, which is precisely the silent stall that polling exists to avoid. A
+   * failed attempt is not cached, so the next call tries again.
+   */
+  async http() {
+    if (!this.httpApi) {
+      const httpUrl = deriveHttpUrl(this.wsEndpoint());
+      const api = new ApiPromise({
+        provider: new HttpProvider(httpUrl),
+        typesBundle: HYPERBRIDGE_TYPES_BUNDLE,
+        // A second connection to the node the ws api already reported on; its init warnings
+        // would just be duplicates.
+        noInitWarn: true
+      });
+      this.httpApi = Promise.race([
+        api.isReadyOrError,
+        rejectAfter(HTTP_CONNECT_TIMEOUT_MS, `HTTP RPC ${httpUrl} did not become ready`)
+      ]).catch(async (err) => {
+        await api.disconnect().catch(() => {
+        });
+        this.httpApi = null;
+        throw new Error(`HTTP RPC ${httpUrl} is unavailable: ${err instanceof Error ? err.message : err}`);
+      });
+    }
+    return await this.httpApi;
+  }
+  /**
+   * The endpoint the websocket provider is connected to. Read from the provider rather than
+   * remembered from a constructor argument, so it is the one endpoint in use no matter which
+   * factory built this instance.
+   */
+  wsEndpoint() {
+    const endpoint = this.api._rpcCore?.provider?.endpoint;
+    if (!endpoint) {
+      throw new Error("Cannot determine the Hyperbridge websocket endpoint to derive an HTTP endpoint from");
+    }
+    return endpoint;
+  }
   /**
    * Creates a Substrate keypair from the configured private key.
    * Supports hex seed (with or without 0x), mnemonic phrases, and URI derivation paths (//Alice).
@@ -7939,13 +8034,45 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * concurrent calls never collide on the substrate account nonce — each extrinsic reaches a block
    * (or is confirmed still pooled and returned as `pending`) before the next is signed; auto-nonce
    * via `system.accountNextIndex` counts pooled extrinsics, so a pending one is never re-used.
+   *
+   * The extrinsic is built rather than passed in because the api it is built on decides where it
+   * is signed and sent: a websocket that is down when the queue reaches this submission diverts it
+   * to {@link sendViaHttp}, which needs the call bound to the HTTP api instead.
    */
-  async signAndSendExtrinsic(extrinsic, maxRetries = 3, timeoutMs = 3e4) {
-    const result = await this.submissionQueue.add(
-      () => this.sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs)
-    );
+  async signAndSendExtrinsic(build, maxRetries = 3, timeoutMs = 3e4) {
+    const result = await this.submissionQueue.add(async () => {
+      if (!this.api.isConnected) {
+        try {
+          return await this.sendViaHttp(await this.http(), build);
+        } catch (err) {
+          return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+      }
+      return await this.sendExtrinsicWithRetries(build(this.api), maxRetries, timeoutMs);
+    });
     return result ?? { success: false, error: "Submission queue returned no result" };
   }
+  /**
+   * Last-resort submission for when the websocket is down at signing time. A bid is only worth
+   * anything inside its window, so waiting for a reconnect usually means not bidding at all.
+   *
+   * HTTP has no subscriptions, so this is `author_submitExtrinsic`: the node accepts the extrinsic
+   * into its pool and returns its hash, and nothing further is observable from here. That is
+   * exactly the `pending` contract — in flight, outcome unknown, do not re-sign — so the result
+   * says so rather than claiming a success it cannot see.
+   *
+   * Only reached when the socket was already down before signing. A submission that got as far as
+   * the pool over the websocket is never retried here: that is the duplicate-nonce race the
+   * `pending` result exists to prevent.
+   */
+  async sendViaHttp(api, build) {
+    try {
+      const hash = await build(api).signAndSend(this.getKeyPair(), { tip: BASE_TIP });
+      return { success: false, pending: true, extrinsicHash: hash.toHex() };
+    } catch (err) {
+      return this.classifySubmissionError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
   /**
    * Signs and sends an extrinsic, handling status updates and errors.
    * Implements retry logic with progressive tip increases for stuck transactions.
@@ -7959,10 +8086,9 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
     const keyPair = this.getKeyPair();
-    const baseTip = 1000000000n;
     let attempt = 0;
     while (attempt < maxRetries) {
-      const currentTip = baseTip * BigInt(2 ** attempt);
+      const currentTip = BASE_TIP * BigInt(2 ** attempt);
       attempt++;
       try {
         const result = await this.sendWithTimeout(extrinsic, keyPair, currentTip, timeoutMs);
@@ -8028,16 +8154,9 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         if (result.dispatchError && (result.status.isInBlock || result.status.isFinalized)) {
           resolved = true;
           clearTimeout(timeoutId);
-          let errorMsg;
-          if (result.dispatchError.isModule) {
-            const decoded = this.api.registry.findMetaError(result.dispatchError.asModule);
-            errorMsg = `Dispatch error: ${decoded.section}::${decoded.name}`;
-          } else {
-            errorMsg = `Dispatch error: ${result.dispatchError.toString()}`;
-          }
           resolve({
             success: false,
-            error: errorMsg
+            error: `Dispatch error: ${this.describeDispatchError(result.dispatchError)}`
           });
         } else if (result.status.isDropped || result.status.isInvalid || result.status.isUsurped || result.status.isFinalityTimeout) {
           resolved = true;
@@ -8055,21 +8174,19 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
           if (interrupted) {
             const [indexCodec, dispatchError] = interrupted.event.data;
             if (Number(indexCodec.toString()) === 0) {
-              let errorMsg;
-              if (dispatchError?.isModule) {
-                const decoded = this.api.registry.findMetaError(dispatchError.asModule);
-                errorMsg = `Dispatch error: ${decoded.section}::${decoded.name}`;
-              } else {
-                errorMsg = `Dispatch error: batch interrupted (${dispatchError?.toString()})`;
-              }
-              resolve({ success: false, error: errorMsg });
+              resolve({
+                success: false,
+                error: `Dispatch error: ${this.describeDispatchError(dispatchError)}`
+              });
               return;
             }
           }
           resolve({
             success: true,
             blockHash: (result.status.isInBlock ? result.status.asInBlock : result.status.asFinalized).toHex(),
-            extrinsicHash: extrinsic.hash.toHex()
+            extrinsicHash: extrinsic.hash.toHex(),
+            // Carried so a batch caller can attribute each item's outcome.
+            events: result.events
           });
         }
       }).then((unsub) => {
@@ -8096,8 +8213,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async submitBid(commitment, userOp) {
     try {
-      const extrinsic = this.api.tx.intentsCoprocessor.placeBid(commitment, userOp);
-      return await this.signAndSendExtrinsic(extrinsic);
+      return await this.signAndSendExtrinsic((api) => api.tx.intentsCoprocessor.placeBid(commitment, userOp));
     } catch (error) {
       return {
         success: false,
@@ -8115,8 +8231,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async retractBid(commitment) {
     try {
-      const extrinsic = this.api.tx.intentsCoprocessor.retractBid(commitment);
-      return await this.signAndSendExtrinsic(extrinsic);
+      return await this.signAndSendExtrinsic((api) => api.tx.intentsCoprocessor.retractBid(commitment));
     } catch (error) {
       return {
         success: false,
@@ -8146,11 +8261,12 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async submitBidWithRetraction(retractCommitment, bidCommitment, userOp) {
     try {
-      const batch = this.api.tx.utility.batch([
-        this.api.tx.intentsCoprocessor.placeBid(bidCommitment, userOp),
-        this.api.tx.intentsCoprocessor.retractBid(retractCommitment)
-      ]);
-      return await this.signAndSendExtrinsic(batch);
+      return await this.signAndSendExtrinsic(
+        (api) => api.tx.utility.batch([
+          api.tx.intentsCoprocessor.placeBid(bidCommitment, userOp),
+          api.tx.intentsCoprocessor.retractBid(retractCommitment)
+        ])
+      );
     } catch (error) {
       return {
         success: false,
@@ -8158,6 +8274,98 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       };
     }
   }
+  /**
+   * Places every phantom bid of one interval in a single extrinsic, retracting each chain's
+   * previous bid alongside it.
+   *
+   * The pallet registers one phantom order per configured chain in the same block, so this is the
+   * whole interval's set. Submitting them one at a time costs a block per chain: submissions are
+   * serialised on the account nonce and each waits for inclusion, so the last chain's bid is many
+   * blocks behind the first, against a bid window measured in tens of blocks. Batched, every bid
+   * lands in the same block.
+   *
+   * Uses `utility.force_batch`, not `utility.batch`. `batch` stops at the first failing call, so
+   * one rejected bid — a closed window, a duplicate, an insufficient deposit — would silently
+   * drop every bid after it. `force_batch` runs them all and reports each outcome. It needs no
+   * special origin: any signed account may call it, exactly like `batch`.
+   *
+   * @param bids - The bids to place; an empty list is a no-op
+   * @returns Per-bid outcomes, in the order given
+   */
+  async submitPhantomBids(bids) {
+    if (bids.length === 0) return { bids: [] };
+    const placeIndexByBid = [];
+    let callCount = 0;
+    for (const bid of bids) {
+      placeIndexByBid.push(callCount);
+      callCount += bid.retractCommitment ? 2 : 1;
+    }
+    const outcome = await this.signAndSendExtrinsic(
+      (api) => api.tx.utility.forceBatch(
+        bids.flatMap((bid) => {
+          const calls = [api.tx.intentsCoprocessor.placeBid(bid.commitment, bid.userOp)];
+          if (bid.retractCommitment) {
+            calls.push(api.tx.intentsCoprocessor.retractBid(bid.retractCommitment));
+          }
+          return calls;
+        })
+      )
+    );
+    if (!outcome.success) {
+      return {
+        bids: bids.map((bid) => ({ commitment: bid.commitment, success: false, error: outcome.error })),
+        pending: outcome.pending,
+        extrinsicHash: outcome.extrinsicHash,
+        error: outcome.error
+      };
+    }
+    const items = this.readForceBatchItems(outcome.events ?? [], callCount);
+    return {
+      bids: bids.map((bid, index) => {
+        const error = items.errors[placeIndexByBid[index]];
+        return { commitment: bid.commitment, success: !error, error };
+      }),
+      blockHash: outcome.blockHash,
+      extrinsicHash: outcome.extrinsicHash,
+      error: items.error
+    };
+  }
+  /**
+   * Reads one outcome per call out of a force_batch's events.
+   *
+   * `ItemFailed` carries no index — pallet-utility emits exactly one `ItemCompleted` or
+   * `ItemFailed` per call, in call order, so the k-th item event belongs to call k.
+   *
+   * A count that does not match the calls submitted means the events are not the ones assumed
+   * here, and every attribution after the discrepancy would be off by one. The bids are then
+   * reported as placed: a bid wrongly recorded as landed is retracted next interval and the
+   * retraction harmlessly fails with `BidNotFound`, whereas one wrongly recorded as failed is
+   * never retracted at all and leaves its deposit reserved.
+   */
+  readForceBatchItems(events, callCount) {
+    const errors = [];
+    for (const { event } of events) {
+      if (event.section !== "utility") continue;
+      if (event.method === "ItemCompleted") errors.push(void 0);
+      else if (event.method === "ItemFailed") errors.push(this.describeDispatchError(event.data[0]));
+    }
+    if (errors.length !== callCount) {
+      return {
+        errors: new Array(callCount).fill(void 0),
+        error: `force_batch reported ${errors.length} item events for ${callCount} calls; outcomes not attributed`
+      };
+    }
+    return { errors };
+  }
+  /** Renders a DispatchError as `pallet::Error`, falling back to its raw form. */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  describeDispatchError(dispatchError) {
+    if (dispatchError?.isModule) {
+      const decoded = this.api.registry.findMetaError(dispatchError.asModule);
+      return `${decoded.section}::${decoded.name}`;
+    }
+    return dispatchError?.toString() ?? "unknown dispatch error";
+  }
   /**
    * Fetches all bid storage entries for a given order commitment.
    * Returns the on-chain data only (filler addresses and deposits).
@@ -8166,7 +8374,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * @returns Array of BidStorageEntry objects
    */
   async getBidStorageEntries(commitment) {
-    const entries = await this.api.query.intentsCoprocessor.bids.entries(commitment);
+    const api = await this.http();
+    const entries = await api.query.intentsCoprocessor.bids.entries(commitment);
     return entries.map(([storageKey, depositValue]) => ({
       commitment,
       filler: storageKey.args[1].toString(),
@@ -8196,9 +8405,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * Single round-trip but does not include deposit amounts.
    */
   async getBidsViaRpc(commitment) {
-    const result = await this.api._rpcCore.provider.send("intents_getBidsForOrder", [
-      commitment
-    ]);
+    const api = await this.http();
+    const result = await api._rpcCore.provider.send("intents_getBidsForOrder", [commitment]);
     return result.map((entry) => {
       const userOp = decodeUserOpScale(entry.user_op);
       const filler = new Keyring({ type: "sr25519" }).encodeAddress(hexToU8a(entry.filler));
@@ -8210,7 +8418,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * Slower but works on all nodes and includes deposit amounts.
    */
   async getBidsViaStorage(commitment) {
-    const entries = await this.api.query.intentsCoprocessor.bids.entries(commitment);
+    const api = await this.http();
+    const entries = await api.query.intentsCoprocessor.bids.entries(commitment);
     if (entries.length === 0) return [];
     const bidPromises = entries.map(async ([storageKey, depositValue]) => {
       try {
@@ -8218,7 +8427,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         const deposit = BigInt(depositValue.toString());
         const offchainKey = this.buildOffchainBidKey(commitment, filler);
         const offchainKeyHex = u8aToHex(offchainKey);
-        const offchainResult = await this.api.rpc.offchain.localStorageGet("PERSISTENT", offchainKeyHex);
+        const offchainResult = await api.rpc.offchain.localStorageGet("PERSISTENT", offchainKeyHex);
         if (!offchainResult || offchainResult.isNone) return null;
         const bidData = offchainResult.unwrap().toHex();
         const decoded = this.decodeBid(bidData);
@@ -8252,7 +8461,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async fetchPhantomOrder(commitment) {
     const key = u8aConcat(OFFCHAIN_PHANTOM_PREFIX, hexToU8a(commitment));
-    const result = await this.api.rpc.offchain.localStorageGet("PERSISTENT", u8aToHex(key));
+    const api = await this.http();
+    const result = await api.rpc.offchain.localStorageGet("PERSISTENT", u8aToHex(key));
     if (!result || result.isNone) return null;
     const rawHex = result.unwrap().toHex();
     if (rawHex === "0x" || rawHex === "0x00") return null;
@@ -8296,8 +8506,9 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * Reads the PhantomOrderRegistered events emitted in a single block.
    */
   async getPhantomOrdersInBlock(blockNumber) {
-    const blockHash = await this.api.rpc.chain.getBlockHash(blockNumber);
-    const apiAt = await this.api.at(blockHash);
+    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) {
@@ -8318,7 +8529,13 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     return orders;
   }
   /**
-   * Polls for newly registered phantom orders, invoking the callback once per order.
+   * Polls for newly registered phantom orders, invoking the callback once per block that carries
+   * any, with all of that block's orders.
+   *
+   * Per block rather than per order because that is how the pallet writes them: one order per
+   * configured chain, all registered in the same `on_initialize`. Delivering them together lets a
+   * caller bid on the whole interval in one extrinsic (see {@link submitPhantomBids}) instead of
+   * one per chain.
    *
    * Each tick reads the current head and scans every block between the last one processed and that
    * head, so the block cursor — not the connection — determines what has been seen. This replaced a
@@ -8331,10 +8548,16 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * cannot drop them, because the cursor only advances past a block whose events were actually
    * read. Recovery replays the backlog.
    *
+   * Every read here goes over HTTP, never the websocket. Polling is a sequence of independent
+   * one-shot requests with no state to lose between them, which is exactly what a stateless
+   * transport does well: a request either answers or fails loudly on this tick, instead of a
+   * 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.
+   *
    * Returns a function that stops polling.
    */
   pollPhantomOrders(callback, options = {}) {
-    const { intervalMs = 6e3, maxBlocksPerPoll = 500, lookbackBlocks = 0, onError } = options;
+    const { intervalMs, maxBlocksPerPoll = 500, lookbackBlocks = 0, onError } = options;
     let cursor = null;
     let inFlight = false;
     let stopped = false;
@@ -8342,7 +8565,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       if (inFlight || stopped) return;
       inFlight = true;
       try {
-        const head = (await this.api.rpc.chain.getHeader()).number.toNumber();
+        const head = (await (await this.http()).rpc.chain.getHeader()).number.toNumber();
         if (cursor === null) {
           cursor = Math.max(head - 1 - lookbackBlocks, -1);
         }
@@ -8351,7 +8574,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         for (let blockNumber = cursor + 1; blockNumber <= to; blockNumber++) {
           if (stopped) return;
           const orders = await this.getPhantomOrdersInBlock(blockNumber);
-          for (const order of orders) callback(order);
+          if (orders.length > 0) callback(orders);
           cursor = blockNumber;
         }
       } catch (err) {
@@ -8361,12 +8584,31 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       }
     };
     void tick();
-    const timer = setInterval(() => void tick(), intervalMs);
+    let timer = null;
+    const startTimer = (ms) => {
+      if (stopped) return;
+      timer = setInterval(() => void tick(), ms);
+    };
+    if (intervalMs !== void 0) startTimer(intervalMs);
+    else void this.phantomPollIntervalMs().then(startTimer);
     return () => {
       stopped = true;
-      clearInterval(timer);
+      if (timer) clearInterval(timer);
     };
   }
+  /**
+   * 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,
+   * since an unreachable node is the poll's problem to report, not the cadence lookup's.
+   */
+  async phantomPollIntervalMs() {
+    try {
+      const specName = (await this.http()).runtimeVersion.specName.toString();
+      return specName === "gargantua" ? GARGANTUA_PHANTOM_POLL_INTERVAL_MS : PHANTOM_POLL_INTERVAL_MS;
+    } catch {
+      return PHANTOM_POLL_INTERVAL_MS;
+    }
+  }
 };
 var TronChain = class _TronChain {
   constructor(params, evm) {
@@ -15168,6 +15410,12 @@ var CryptoUtils = class _CryptoUtils {
    * signing infrastructure (hardware wallets, MPC/TEE policy engines) instead
    * of an opaque 32-byte digest.
    *
+   * The payload must be a standard self-describing `eth_signTypedData_v4`
+   * payload — `EIP712Domain` listed in `types`, `chainId` as a JSON number —
+   * because some signing backends (e.g. MPC Vault) hash it server-side from
+   * the JSON rather than locally via viem. viem ignores both details when
+   * hashing, so the digest is unchanged for local signers.
+   *
    * @param userOp - The packed UserOperation to sign (signature field ignored).
    * @param entryPoint - Address of the EntryPoint v0.8 contract.
    * @param chainId - Chain ID of the network on which the operation will execute.
@@ -15178,10 +15426,22 @@ var CryptoUtils = class _CryptoUtils {
       domain: {
         name: "ERC4337",
         version: "1",
-        chainId,
+        // Runtime number so JSON.stringify emits a canonical v4 numeric chainId for
+        // server-side hashers; viem's uint256 type mapping wants bigint but its
+        // runtime accepts numbers, hence the cast.
+        chainId: Number(chainId),
         verifyingContract: entryPoint
       },
+      // `as const`: viem derives the domain's TYPE from `types.EIP712Domain`, so the
+      // entries must stay string literals — widened `string` fields make viem's
+      // typed-data generics reject the payload at every call site.
       types: {
+        EIP712Domain: [
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" }
+        ],
         PackedUserOperation: [
           { name: "sender", type: "address" },
           { name: "nonce", type: "uint256" },
@@ -19199,14 +19459,34 @@ var IntentGateway = class _IntentGateway {
     }
   }
 };
+
+// src/protocols/intents/phantom-aggregation.ts
 var FILL_ORDER_ABI = IntentGatewayV2_default.ABI;
-var DECLARATION_VERSION = 1;
-var MAX_DECLARED_CHAINS = 255;
-function encodeAcceptedSourceChains(chains2) {
-  if (chains2.length > MAX_DECLARED_CHAINS) {
-    throw new Error(`Cannot declare more than ${MAX_DECLARED_CHAINS} source chains`);
+var DECLARATION_V1 = 1;
+var DECLARATION_V2 = 2;
+var MAX_DECLARED_ENTRIES = 255;
+var MAX_TOKEN_ID_BYTES = 32;
+function tokenIdToBytes(tokenId) {
+  if (tokenId < 0n) throw new Error(`Uniswap V4 tokenId cannot be negative: ${tokenId}`);
+  const bytes = [];
+  let rest = tokenId;
+  while (rest > 0n) {
+    bytes.unshift(Number(rest & 0xffn));
+    rest >>= 8n;
+  }
+  return bytes.length > 0 ? bytes : [0];
+}
+function encodePhantomBidDeclaration(declaration) {
+  const chains2 = declaration.acceptedSourceChains ?? [];
+  const positions = declaration.uniswapV4Positions ?? [];
+  if (chains2.length > MAX_DECLARED_ENTRIES) {
+    throw new Error(`Cannot declare more than ${MAX_DECLARED_ENTRIES} source chains`);
+  }
+  if (positions.length > MAX_DECLARED_ENTRIES) {
+    throw new Error(`Cannot declare more than ${MAX_DECLARED_ENTRIES} Uniswap V4 positions`);
   }
-  const bytes = [DECLARATION_VERSION, chains2.length];
+  const version = positions.length > 0 ? DECLARATION_V2 : DECLARATION_V1;
+  const bytes = [version, chains2.length];
   for (const chain of chains2) {
     const encoded = stringToU8a(chain);
     if (encoded.length === 0 || encoded.length > 255) {
@@ -19214,25 +19494,59 @@ function encodeAcceptedSourceChains(chains2) {
     }
     bytes.push(encoded.length, ...encoded);
   }
+  if (version === DECLARATION_V2) {
+    bytes.push(positions.length);
+    for (const tokenId of positions) {
+      const encoded = tokenIdToBytes(tokenId);
+      if (encoded.length > MAX_TOKEN_ID_BYTES) {
+        throw new Error(`Uniswap V4 tokenId exceeds uint256: ${tokenId}`);
+      }
+      bytes.push(encoded.length, ...encoded);
+    }
+  }
   return u8aToHex(new Uint8Array(bytes));
 }
-function decodeAcceptedSourceChains(paymasterAndData) {
-  if (!paymasterAndData || !isHex$1(paymasterAndData)) return null;
+function decodePhantomBidDeclaration(paymasterAndData) {
+  const absent = { acceptedSources: null, uniswapV4Positions: [] };
+  if (!paymasterAndData || !isHex$1(paymasterAndData)) return absent;
   const bytes = hexToU8a(paymasterAndData);
-  if (bytes.length < 2 || bytes[0] !== DECLARATION_VERSION) return null;
-  const count = bytes[1];
+  if (bytes.length < 2) return absent;
+  const version = bytes[0];
+  if (version !== DECLARATION_V1 && version !== DECLARATION_V2) return absent;
   const chains2 = [];
   let offset = 2;
-  for (let entry = 0; entry < count; entry++) {
-    if (offset >= bytes.length) return null;
+  for (let entry = 0; entry < bytes[1]; entry++) {
+    if (offset >= bytes.length) return absent;
     const length = bytes[offset];
     offset += 1;
-    if (length === 0 || offset + length > bytes.length) return null;
+    if (length === 0 || offset + length > bytes.length) return absent;
     chains2.push(u8aToString(bytes.subarray(offset, offset + length)));
     offset += length;
   }
-  if (offset !== bytes.length) return null;
-  return chains2;
+  const positions = [];
+  if (version === DECLARATION_V2) {
+    if (offset >= bytes.length) return absent;
+    const count = bytes[offset];
+    offset += 1;
+    for (let entry = 0; entry < count; entry++) {
+      if (offset >= bytes.length) return absent;
+      const length = bytes[offset];
+      offset += 1;
+      if (length === 0 || length > MAX_TOKEN_ID_BYTES || offset + length > bytes.length) return absent;
+      let tokenId = 0n;
+      for (const byte of bytes.subarray(offset, offset + length)) tokenId = tokenId << 8n | BigInt(byte);
+      positions.push(tokenId);
+      offset += length;
+    }
+  }
+  if (offset !== bytes.length) return absent;
+  return { acceptedSources: chains2, uniswapV4Positions: positions };
+}
+function encodeAcceptedSourceChains(chains2) {
+  return encodePhantomBidDeclaration({ acceptedSourceChains: chains2 });
+}
+function decodeAcceptedSourceChains(paymasterAndData) {
+  return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
 }
 FILL_ORDER_ABI.find(
   (item) => item?.type === "function" && item?.name === "fillOrder"
@@ -23707,6 +24021,6 @@ async function teleportDot(param_) {
   return stream;
 }
 
-export { ADDRESS_ZERO2 as ADDRESS_ZERO, BundlerMethod, ChainConfigService, Chains, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, ERC20Method, ERC7821_BATCH_MODE, EvmChain, ABI as EvmHostABI, EvmLanguage, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, IntentGateway, ABI3 as IntentGatewayABI, IntentOrderStatus, IntentsCoprocessor, InvalidPhantomSnapshotError, IsmpClient, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, OrderStatus, OrderStatusChecker, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, PhantomSnapshotUnavailableError, PharosChain, PolkadotHubChain, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SubstrateChain, Swap, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, TronChain, USE_ETHERSCAN_CHAINS, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, WrappedHyperFungibleTokenABI, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
+export { ADDRESS_ZERO2 as ADDRESS_ZERO, BundlerMethod, ChainConfigService, Chains, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, ERC20Method, ERC7821_BATCH_MODE, EvmChain, ABI as EvmHostABI, EvmLanguage, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, IntentGateway, ABI3 as IntentGatewayABI, IntentOrderStatus, IntentsCoprocessor, InvalidPhantomSnapshotError, IsmpClient, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, OrderStatus, OrderStatusChecker, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, PhantomSnapshotUnavailableError, PharosChain, PolkadotHubChain, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SubstrateChain, Swap, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, TronChain, USE_ETHERSCAN_CHAINS, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, WrappedHyperFungibleTokenABI, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodePhantomBidDeclaration, decodeUserOpScale, deriveHttpUrl, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeISMPMessage, encodePhantomBidDeclaration, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map