@hyperbridge/sdk 2.8.0 → 2.8.3

package/dist/node/index.cjs

@@ -2699,13 +2699,26 @@ var chainConfigs = {
     tokenDecimals: {
       USDC: 6,
       USDT: 6,
-      cNGN: 6
+      cNGN: 6,
+      ZARP: 18,
+      EURC: 6,
+      XSGD: 6,
+      TRYB: 6,
+      USDR: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 2, allowanceSlot: 5 },
       USDC: { balanceSlot: 9, allowanceSlot: 10 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 },
+      // custom upgradeable layout
+      ZARP: { balanceSlot: 51, allowanceSlot: 52 },
+      EURC: { balanceSlot: 9, allowanceSlot: 10 },
+      // Circle FiatToken layout
+      XSGD: { balanceSlot: 7, allowanceSlot: 8 },
+      TRYB: { balanceSlot: 9, allowanceSlot: 10 },
+      USDR: { balanceSlot: 51, allowanceSlot: 52 }
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -2754,18 +2767,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",
@@ -2885,13 +2905,22 @@ var chainConfigs = {
       USDC: 6,
       USDT: 6,
       cNGN: 6,
-      EXT: 18
+      EXT: 18,
+      ZARP: 18,
+      EURC: 6,
+      USDR: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 0, allowanceSlot: 1 },
       USDC: { balanceSlot: 9, allowanceSlot: 10 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 },
+      // custom upgradeable layout
+      ZARP: { balanceSlot: 51, allowanceSlot: 52 },
+      EURC: { balanceSlot: 9, allowanceSlot: 10 },
+      // Circle FiatToken layout
+      USDR: { balanceSlot: 51, allowanceSlot: 52 }
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -2952,13 +2981,21 @@ var chainConfigs = {
       USDC: 6,
       USDT: 6,
       EXT: 18,
-      cNGN: 6
+      cNGN: 6,
+      ZARP: 18,
+      XSGD: 6,
+      USDR: 6
     },
     tokenStorageSlots: {
       USDT: { balanceSlot: 0, allowanceSlot: 1 },
       USDC: { balanceSlot: 9, allowanceSlot: 10 },
       WETH: { balanceSlot: 3, allowanceSlot: 4 },
-      DAI: { balanceSlot: 0, allowanceSlot: 0 }
+      DAI: { balanceSlot: 0, allowanceSlot: 0 },
+      cNGN: { balanceSlot: 201, allowanceSlot: 202 },
+      // custom upgradeable layout
+      ZARP: { balanceSlot: 51, allowanceSlot: 52 },
+      XSGD: { balanceSlot: 7, allowanceSlot: 8 },
+      USDR: { balanceSlot: 51, allowanceSlot: 52 }
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
@@ -3259,8 +3296,9 @@ var chainConfigs = {
     assets: {
       WETH: "0x0000000000000000000000000000000000000000",
       DAI: "0x0000000000000000000000000000000000000000",
+      // Asset Hub assets at their asset-id precompile addresses: 0x539 = 1337, 0x7c0 = 1984.
       USDC: "0x0000053900000000000000000000000001200000",
-      USDT: "0x0000000000000000000000000000000000000000"
+      USDT: "0x000007c000000000000000000000000001200000"
     },
     tokenDecimals: {
       USDC: 6,
@@ -7779,6 +7817,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: utilCrypto.keccakAsU8a },
+    gargantua: { hasher: utilCrypto.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 = scaleTs.Struct({ filler: scaleTs.Bytes(32), user_op: scaleTs.Vector(scaleTs.u8) });
 var PackedUserOperationCodec = scaleTs.Struct({
   sender: scaleTs.Bytes(20),
@@ -7839,6 +7898,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
@@ -7855,12 +7916,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   static async connect(wsUrl, substratePrivateKey) {
     const api$1 = await api.ApiPromise.create({
       provider: new api.WsProvider(wsUrl),
-      typesBundle: {
-        spec: {
-          nexus: { hasher: utilCrypto.keccakAsU8a },
-          gargantua: { hasher: utilCrypto.keccakAsU8a }
-        }
-      }
+      typesBundle: HYPERBRIDGE_TYPES_BUNDLE
     });
     return new _IntentsCoprocessor(api$1, substratePrivateKey, true);
   }
@@ -7886,15 +7942,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$1 = new api.ApiPromise({
+        provider: new api.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$1.isReadyOrError,
+        rejectAfter(HTTP_CONNECT_TIMEOUT_MS, `HTTP RPC ${httpUrl} did not become ready`)
+      ]).catch(async (err) => {
+        await api$1.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).
@@ -7917,26 +8043,67 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   /**
    * Signs and sends an extrinsic. Submissions are serialised through {@link submissionQueue} so
    * concurrent calls never collide on the substrate account nonce — each extrinsic reaches a block
-   * before the next is signed.
+   * (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.
+   *
+   * A retry only happens when the previous attempt verifiably went nowhere. Once an attempt's
+   * extrinsic is known to be pooled (`pending`), re-signing the same call would race our own
+   * submission: the copy either bounces off the pool (1014, same nonce below the replacement
+   * priority bump) or — if the original lands first, freeing the nonce — executes as a duplicate
+   * and fails on-chain (e.g. `BidNotFound` for a retraction). Neither can succeed, so the pending
+   * result is returned for the caller to confirm later.
    */
   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);
-        if (result.success || result.error?.includes("Dispatch error")) {
+        if (result.success || result.pending || result.error?.includes("Dispatch error")) {
           return result;
         }
       } catch (err) {
@@ -7952,12 +8119,30 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     };
   }
   /**
-   * Sends an extrinsic with a timeout
+   * Classifies a submission rejection. Codes 1013 ("already imported") and 1014 ("priority is
+   * too low") both mean a copy of this account+nonce is already in the pool — almost always our
+   * own earlier attempt whose watch handle didn't confirm cleanly. That extrinsic is in flight;
+   * resubmitting can only bounce again or land a duplicate, so these are surfaced as `pending`
+   * rather than failure.
+   */
+  classifySubmissionError(err) {
+    const code = err.code;
+    const inFlight = code === 1013 || code === 1014 || /already imported|already in the pool|priority is too low/i.test(err.message);
+    return { success: false, pending: inFlight || void 0, error: err.message };
+  }
+  /**
+   * Sends an extrinsic with a timeout.
+   *
+   * A timeout is only a failure when the extrinsic never made it into the transaction pool.
+   * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
+   * in flight and may well execute after the watch is abandoned — the result is then `pending`,
+   * telling the caller to confirm the outcome later instead of re-signing the same call.
    */
   async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs) {
     return new Promise((resolve) => {
       let resolved = false;
       let unsubscribe = null;
+      let enteredPool = false;
       const timeoutId = setTimeout(() => {
         if (!resolved) {
           resolved = true;
@@ -7966,25 +8151,23 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
           }
           resolve({
             success: false,
-            error: `Transaction timed out after ${timeoutMs}ms`
+            pending: enteredPool || void 0,
+            extrinsicHash: enteredPool ? extrinsic.hash.toHex() : void 0,
+            error: `Transaction timed out after ${timeoutMs}ms${enteredPool ? " while in the transaction pool" : ""}`
           });
         }
       }, timeoutMs);
       extrinsic.signAndSend(keyPair, { tip }, (result) => {
         if (resolved) return;
+        if (result.status.isFuture || result.status.isReady || result.status.isBroadcast || result.status.isRetracted) {
+          enteredPool = true;
+        }
         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;
@@ -8002,21 +8185,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) => {
@@ -8029,7 +8210,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeoutId);
-          resolve({ success: false, error: err.message });
+          resolve(this.classifySubmissionError(err));
         }
       });
     });
@@ -8043,8 +8224,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,
@@ -8062,8 +8242,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,
@@ -8093,11 +8272,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,
@@ -8105,6 +8285,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).
@@ -8113,7 +8385,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(),
@@ -8143,9 +8416,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$1 = await this.http();
+    const result = await api$1._rpcCore.provider.send("intents_getBidsForOrder", [commitment]);
     return result.map((entry) => {
       const userOp = decodeUserOpScale(entry.user_op);
       const filler = new api.Keyring({ type: "sr25519" }).encodeAddress(util.hexToU8a(entry.filler));
@@ -8157,7 +8429,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 {
@@ -8165,7 +8438,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         const deposit = BigInt(depositValue.toString());
         const offchainKey = this.buildOffchainBidKey(commitment, filler);
         const offchainKeyHex = util.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);
@@ -8199,13 +8472,12 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async fetchPhantomOrder(commitment) {
     const key = util.u8aConcat(OFFCHAIN_PHANTOM_PREFIX, util.hexToU8a(commitment));
-    const result = await this.api.rpc.offchain.localStorageGet("PERSISTENT", util.u8aToHex(key));
+    const api = await this.http();
+    const result = await api.rpc.offchain.localStorageGet("PERSISTENT", util.u8aToHex(key));
     if (!result || result.isNone) return null;
     const rawHex = result.unwrap().toHex();
     if (rawHex === "0x" || rawHex === "0x00") return null;
-    const placeOrderAbi = IntentGatewayV2_default.ABI.find(
-      (item) => item.type === "function" && item.name === "placeOrder"
-    );
+    const placeOrderAbi = IntentGatewayV2_default.ABI.find((item) => item.type === "function" && item.name === "placeOrder");
     const orderType = placeOrderAbi?.inputs?.[0];
     if (!orderType) return null;
     const [decoded] = viem.decodeAbiParameters([orderType], rawHex);
@@ -8245,8 +8517,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) {
@@ -8267,7 +8540,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
@@ -8280,10 +8559,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;
@@ -8291,7 +8576,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);
         }
@@ -8300,7 +8585,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) {
@@ -8310,12 +8595,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) {
@@ -15117,6 +15421,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.
@@ -15127,10 +15437,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" },
@@ -16994,14 +17316,14 @@ var BidManager = class {
   }
   /**
    * Autopilot bid selection: sorts the given bids by output value, simulates
-   * each in order until one passes, then executes that bid. For consumers that
-   * do not need custom selection logic.
+   * each in order and attempts execution. Any bid that fails simulation or
+   * execution is skipped once so the next ranked bid can be attempted in the
+   * same round. For consumers that do not need custom selection logic.
    *
    * @param order - The placed order to fill.
    * @param bids - Candidate bids (from {@link buildBids}).
    * @returns A {@link SelectBidResult} for the executed bid.
-   * @throws If no valid bids exist, all simulations fail, or the bundler rejects
-   *   the UserOperation.
+   * @throws If no valid bids exist or every bid fails simulation/execution.
    */
   async selectAndExecuteBest(order, bids) {
     const commitment = order.id;
@@ -17018,22 +17340,34 @@ var BidManager = class {
       throw new Error("No valid bids found");
     }
     console.log(`[BidManager] Simulating ${sortedBids.length} sorted bid(s) to find a valid one`);
+    let simulationFailures = 0;
+    let executionFailures = 0;
     for (let idx = 0; idx < sortedBids.length; idx++) {
       const bid = sortedBids[idx];
       console.log(`[BidManager] Simulating bid ${idx + 1}/${sortedBids.length} from solver=${bid.solverAddress}`);
       try {
         await bid.simulate();
       } catch (err) {
+        simulationFailures += 1;
         console.warn(
           `[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: simulation FAILED: ${err instanceof Error ? err.message : String(err)}`
         );
         continue;
       }
       console.log(`[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: simulation PASSED`);
-      return bid.execute();
+      try {
+        return await bid.execute();
+      } catch (err) {
+        executionFailures += 1;
+        console.warn(
+          `[BidManager] Bid ${idx + 1} from solver=${bid.solverAddress}: execution FAILED: ${err instanceof Error ? err.message : String(err)}; trying next bid`
+        );
+      }
     }
-    console.error(`[BidManager] All ${sortedBids.length} bid(s) failed simulation for commitment=${commitment}`);
-    throw new Error("No bids passed simulation");
+    console.error(
+      `[BidManager] No executable bids for commitment=${commitment}: ${simulationFailures} simulation failure(s), ${executionFailures} execution failure(s)`
+    );
+    throw new Error("No bids passed simulation and execution");
   }
   /**
    * Sorts a list of bids for the given order by output value.
@@ -17373,6 +17707,10 @@ var BidManager = class {
   }
 };
 var RELAYER_MESSAGE_GAS = 1000000n;
+var NO_BUNDLER_FILL_GAS_BASE = 700000n;
+var NO_BUNDLER_FILL_GAS_PER_OUTPUT = 150000n;
+var NO_BUNDLER_PAYMASTER_VERIFICATION_GAS = 250000n;
+var NO_BUNDLER_PAYMASTER_POST_OP_GAS = 100000n;
 var GasEstimator = class {
   /**
    * @param ctx - Shared IntentsV2 context providing the source and destination
@@ -17406,8 +17744,10 @@ var GasEstimator = class {
    * headroom. If the bundler is Pimlico, gas prices are refined with
    * `pimlico_getUserOperationGasPrice`.
    *
-   * **Fallback path (no bundler):** calls `estimateContractGas` directly on
-   * `fillOrder` with state overrides.
+   * **Fallback path (no bundler):** uses a fixed budget
+   * ({@link NO_BUNDLER_FILL_GAS_BASE} plus {@link NO_BUNDLER_FILL_GAS_PER_OUTPUT}
+   * per output leg) — public RPCs don't reliably support estimation with
+   * state overrides.
    *
    * @param params - Parameters including the order to estimate and optional
    *   percentage bumps for `maxPriorityFeePerGas` and `maxFeePerGas`.
@@ -17442,14 +17782,14 @@ var GasEstimator = class {
     }
     const isSameChain = souceStateMachineId === destStateMachineId;
     const [stateOverridesResult, crossChainFees] = await Promise.all([
-      this.buildStateOverride({
+      this.ctx.bundlerUrl ? this.buildStateOverride({
         accountAddress: solverAccountAddress,
         chain: destStateMachineId,
         outputAssets: assetsForOverrides,
         spenderAddress: intentGatewayV2Address,
         intentGatewayV2Address,
         entryPointAddress
-      }),
+      }) : Promise.resolve({ viem: [], bundler: {} }),
       isSameChain ? Promise.resolve({ postRequestFee: 0n, relayerFeeInSourceFeeToken: 0n }) : this.estimateCrossChainFees(
         sourceFeeToken,
         destFeeToken,
@@ -17457,7 +17797,7 @@ var GasEstimator = class {
         orderFeeGasPriceBumpPercent
       )
     ]);
-    const { viem: stateOverrides, bundler: bundlerStateOverrides } = stateOverridesResult;
+    const { bundler: bundlerStateOverrides } = stateOverridesResult;
     const fillOptions = {
       relayerFee: crossChainFees.postRequestFee,
       // Always dispatch with the fee token (see the method docs).
@@ -17598,20 +17938,9 @@ var GasEstimator = class {
         console.warn("Bundler gas estimation failed, using fallback values:", e);
       }
     } else {
-      try {
-        const estimatedGas = await this.ctx.dest.client.estimateContractGas({
-          abi: ABI3,
-          address: intentGatewayV2Address,
-          functionName: "fillOrder",
-          args: [transformOrderForContract(order), fillOptions],
-          account: solverAccountAddress,
-          value: totalNativeValue,
-          stateOverride: stateOverrides
-        });
-        callGasLimit = estimatedGas * 105n / 100n;
-      } catch (e) {
-        console.warn("fillOrder gas estimation failed, using fallback:", e);
-      }
+      callGasLimit = NO_BUNDLER_FILL_GAS_BASE + NO_BUNDLER_FILL_GAS_PER_OUTPUT * BigInt(order.output.assets.length);
+      paymasterVerificationGasLimit = NO_BUNDLER_PAYMASTER_VERIFICATION_GAS;
+      paymasterPostOpGasLimit = NO_BUNDLER_PAYMASTER_POST_OP_GAS;
     }
     const totalGas = callGasLimit + verificationGasLimit + preVerificationGas + paymasterVerificationGasLimit + paymasterPostOpGasLimit;
     const rawTotalGasCostWei = totalGas * maxFeePerGas;
@@ -19141,14 +19470,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`);
   }
-  const bytes = [DECLARATION_VERSION, chains2.length];
+  if (positions.length > MAX_DECLARED_ENTRIES) {
+    throw new Error(`Cannot declare more than ${MAX_DECLARED_ENTRIES} Uniswap V4 positions`);
+  }
+  const version = positions.length > 0 ? DECLARATION_V2 : DECLARATION_V1;
+  const bytes = [version, chains2.length];
   for (const chain of chains2) {
     const encoded = util.stringToU8a(chain);
     if (encoded.length === 0 || encoded.length > 255) {
@@ -19156,25 +19505,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 util.u8aToHex(new Uint8Array(bytes));
 }
-function decodeAcceptedSourceChains(paymasterAndData) {
-  if (!paymasterAndData || !util.isHex(paymasterAndData)) return null;
+function decodePhantomBidDeclaration(paymasterAndData) {
+  const absent = { acceptedSources: null, uniswapV4Positions: [] };
+  if (!paymasterAndData || !util.isHex(paymasterAndData)) return absent;
   const bytes = util.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(util.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"
@@ -23720,10 +24103,13 @@ exports.createEvmChain = createEvmChain;
 exports.createQueryClient = createQueryClient;
 exports.decodeAcceptedSourceChains = decodeAcceptedSourceChains;
 exports.decodeERC7821ExecuteBatch = decodeERC7821ExecuteBatch;
+exports.decodePhantomBidDeclaration = decodePhantomBidDeclaration;
 exports.decodeUserOpScale = decodeUserOpScale;
+exports.deriveHttpUrl = deriveHttpUrl;
 exports.encodeAcceptedSourceChains = encodeAcceptedSourceChains;
 exports.encodeERC7821ExecuteBatch = encodeERC7821ExecuteBatch;
 exports.encodeISMPMessage = encodeISMPMessage;
+exports.encodePhantomBidDeclaration = encodePhantomBidDeclaration;
 exports.encodeStateMachineId = encodeStateMachineId;
 exports.encodeUserOpScale = encodeUserOpScale;
 exports.encodeWithdrawalRequest = encodeWithdrawalRequest;