@hyperbridge/sdk 2.8.2 → 2.8.4

package/dist/node/index.cjs

@@ -2767,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",
@@ -5243,11 +5250,21 @@ var ChainConfigService = class {
    * it, so a new asset is added once in `chain.ts` and nowhere else.
    */
   getAssetBySymbol(chain, symbol) {
-    const assets = this.getConfig(chain)?.assets;
+    return this.getAssetMetadataBySymbol(chain, symbol)?.address;
+  }
+  /** Resolves a configured token symbol case-insensitively on a specific chain. */
+  getAssetMetadataBySymbol(chain, symbol) {
+    const config = this.getConfig(chain);
+    const assets = config?.assets;
     if (!assets) return void 0;
     const target = symbol.trim().toUpperCase();
     for (const [key, address] of Object.entries(assets)) {
-      if (key.toUpperCase() === target) return address;
+      if (key.toUpperCase() !== target) continue;
+      return {
+        symbol: key,
+        address,
+        decimals: config.tokenDecimals?.[key]
+      };
     }
     return void 0;
   }
@@ -7810,6 +7827,28 @@ 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 INCLUSION_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),
@@ -7870,6 +7909,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
@@ -7886,12 +7927,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);
   }
@@ -7917,15 +7953,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).
@@ -7948,50 +8054,119 @@ 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
-   * (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.
+   * (or is confirmed still pooled and returned as `pending`) before the next is signed. The
+   * auto-nonce is the account's on-chain nonce, so a still-pooled extrinsic does not advance it: a
+   * submission signed behind a pending one bounces off it (1013/1014) and is reported as pending
+   * too, rather than landing as a second copy.
+   *
+   * 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 = INCLUSION_TIMEOUT_MS) {
+    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.
+   * Two kinds of failure are retried, and the difference is the nonce.
+   *
+   * An attempt that verifiably went nowhere (rejected before the pool, dropped, invalid) leaves
+   * the account nonce free, so the next attempt simply re-signs with the auto-nonce.
+   *
+   * An attempt that reached the pool and was still there when the watch timed out (`stalled`) is
+   * retried as a *replacement*: the same nonce it was signed with, and double the tip. Substrate's
+   * pool evicts a pooled extrinsic in favour of a higher-priority one at the same (account, nonce),
+   * so exactly one of the two can ever execute. This matters for a bid, which is worth nothing once
+   * its window closes — waiting out a stalled extrinsic usually means not bidding at all.
+   *
+   * Re-signing without pinning the nonce is what must never happen here. The auto-nonce is read
+   * from on-chain state, so it is only the stalled extrinsic's nonce for as long as that extrinsic
+   * stays out of a block — and a stall is precisely the case where it may land at any moment. Once
+   * it does, an unpinned retry takes the *next* nonce and both execute: a duplicate `placeBid` that
+   * fails on-chain, and a second `retractBid` that pulls the bid just placed. When the signed nonce
+   * cannot be read, the stalled result is returned rather than guessed at.
+   *
+   * A rejection that bounced off a copy already pooled (1013/1014) is likewise left alone: that
+   * copy is in flight and its outcome is unknown here, so the `pending` result goes back to the
+   * caller to confirm later.
    */
   async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
     const keyPair = this.getKeyPair();
-    const baseTip = 1000000000n;
     let attempt = 0;
+    let nonce;
+    let stalled;
     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.pending || result.error?.includes("Dispatch error")) {
+        const result = await this.sendWithTimeout(extrinsic, keyPair, currentTip, timeoutMs, nonce);
+        if (result.success || result.error?.includes("Dispatch error")) {
           return result;
         }
+        if (result.stalled) {
+          stalled = result;
+          nonce ??= this.signedNonce(extrinsic);
+          if (nonce === void 0) return result;
+          continue;
+        }
+        if (result.pending) return stalled ?? result;
       } catch (err) {
-        return {
+        return stalled ?? {
           success: false,
           error: err instanceof Error ? err.message : "Unknown error"
         };
       }
     }
-    return {
+    return stalled ?? {
       success: false,
       error: `Transaction failed after ${maxRetries} attempts`
     };
   }
+  /**
+   * The nonce an extrinsic was signed with, or undefined if it carries no readable one — which is
+   * the case before it has ever been signed, and for a stub api in tests.
+   */
+  signedNonce(extrinsic) {
+    try {
+      const nonce = extrinsic.nonce?.toNumber?.();
+      return typeof nonce === "number" && Number.isFinite(nonce) ? nonce : void 0;
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * 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
@@ -8009,10 +8184,15 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    *
    * 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.
+   * in flight and may well execute after the watch is abandoned — the result is then `pending`
+   * and `stalled`, telling the caller to replace it under the same nonce or confirm it later,
+   * never to re-sign the same call under a fresh one.
+   *
+   * `nonce` pins the submission to a specific account nonce, which is what makes a retry a pool
+   * replacement rather than a second extrinsic queued behind the first. Left undefined on the
+   * first attempt, where the api's auto-nonce is correct.
    */
-  async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs) {
+  async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs, nonce) {
     return new Promise((resolve) => {
       let resolved = false;
       let unsubscribe = null;
@@ -8026,12 +8206,13 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
           resolve({
             success: false,
             pending: enteredPool || void 0,
+            stalled: 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) => {
+      extrinsic.signAndSend(keyPair, nonce === void 0 ? { tip } : { tip, nonce }, (result) => {
         if (resolved) return;
         if (result.status.isFuture || result.status.isReady || result.status.isBroadcast || result.status.isRetracted) {
           enteredPool = true;
@@ -8039,16 +8220,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;
@@ -8066,21 +8240,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) => {
@@ -8107,8 +8279,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,
@@ -8126,8 +8297,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,
@@ -8157,11 +8327,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,
@@ -8169,6 +8340,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).
@@ -8177,7 +8440,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(),
@@ -8207,9 +8471,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));
@@ -8221,7 +8484,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 {
@@ -8229,7 +8493,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);
@@ -8263,7 +8527,8 @@ 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;
@@ -8307,8 +8572,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) {
@@ -8329,7 +8595,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
@@ -8342,10 +8614,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;
@@ -8353,7 +8631,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);
         }
@@ -8362,7 +8640,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) {
@@ -8372,12 +8650,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) {
@@ -11752,52 +12049,85 @@ query LatestPhantomOrderPriceSnapshot($tokenA: String!, $tokenB: String!) {
     }
   }
 }`;
-var LATEST_PHANTOM_ORDER_LIQUIDITY_SNAPSHOT = `
-query LatestPhantomOrderLiquiditySnapshot($tokenA: String!, $tokenB: String!) {
-  phantomOrderPriceSnapshots(
+var AVAILABLE_LIQUIDITY = `
+query AvailableLiquidity(
+  $poolId: String!
+  $sourceChain: String!
+  $destinationChain: String!
+  $direction: String!
+) {
+  poolChainLiquidities(
     filter: {
       and: [
-        { tokenA: { equalTo: $tokenA } }
-        { tokenB: { equalTo: $tokenB } }
+        { poolId: { equalToInsensitive: $poolId } }
+        { chain: { equalTo: $destinationChain } }
+        { direction: { equalTo: $direction } }
       ]
     }
-    orderBy: SNAPSHOT_TIME_DESC
     first: 1
   ) {
     nodes {
-      commitment
-      tokenA
-      tokenB
-      snapshotTime
+      depth
+      bidCount
+      unrestrictedDepth
+      unrestrictedBidCount
+      lastUpdatedAt
+    }
+  }
+  poolRoutes(
+    filter: {
+      and: [
+        { poolId: { equalToInsensitive: $poolId } }
+        { sourceChain: { equalTo: $sourceChain } }
+        { chain: { equalTo: $destinationChain } }
+        { direction: { equalTo: $direction } }
+      ]
+    }
+    first: 1
+  ) {
+    nodes {
+      depth
+      bidCount
+      lastUpdatedAt
     }
   }
 }`;
-var LIQUIDITY_PROVIDER_BALANCES = `
-query LiquidityProviderBalanceAggregates($commitment: String!, $tokenAddress: String!) {
-  liquidityProviderBalances(
+var BUY_AND_SELL_RATES = `
+query BuyAndSellRates(
+  $poolId: String!
+  $directChain: String!
+  $directDirection: String!
+  $reverseChain: String!
+  $reverseDirection: String!
+) {
+  direct: poolChainLiquidities(
     filter: {
       and: [
-        { commitment: { equalTo: $commitment } }
-        { tokenAddress: { equalTo: $tokenAddress } }
+        { poolId: { equalToInsensitive: $poolId } }
+        { chain: { equalTo: $directChain } }
+        { direction: { equalTo: $directDirection } }
       ]
     }
+    first: 1
   ) {
-    aggregates {
-      sum {
-        balance
-      }
-      distinctCount {
-        providerId
-      }
+    nodes {
+      rate
+      lastUpdatedAt
     }
-    groupedAggregates(groupBy: [CHAIN, TOKEN_ADDRESS]) {
-      keys
-      sum {
-        balance
-      }
-      distinctCount {
-        providerId
-      }
+  }
+  reverse: poolChainLiquidities(
+    filter: {
+      and: [
+        { poolId: { equalToInsensitive: $poolId } }
+        { chain: { equalTo: $reverseChain } }
+        { direction: { equalTo: $reverseDirection } }
+      ]
+    }
+    first: 1
+  ) {
+    nodes {
+      rate
+      lastUpdatedAt
     }
   }
 }`;
@@ -15179,6 +15509,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.
@@ -15189,10 +15525,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" },
@@ -17923,178 +18271,191 @@ var OrderStatusChecker = class {
     return true;
   }
 };
-var COMMITMENT_PATTERN = /^0x[0-9a-f]{64}$/i;
+
+// src/protocols/intents/liquidity-pool.ts
+function sortPoolSymbols(symbolA, symbolB) {
+  return symbolA.toLowerCase() <= symbolB.toLowerCase() ? [symbolA, symbolB] : [symbolB, symbolA];
+}
+function poolSlug(symbolA, symbolB) {
+  return sortPoolSymbols(symbolA, symbolB).join("-");
+}
+function resolveLiquidityPool(symbolA, symbolB) {
+  const [token0Symbol, token1Symbol] = sortPoolSymbols(symbolA, symbolB);
+  return {
+    poolId: `${token0Symbol}-${token1Symbol}`,
+    token0Symbol,
+    token1Symbol
+  };
+}
+
+// src/protocols/intents/LiquidityEngine.ts
+var INDEXER_FIXED_POINT_DECIMALS = 18;
+var POOL_RATE_SCALE = 10n ** 18n;
+var SELL = "SELL";
+var BUY = "BUY";
+var USD_STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USDT"]);
 var LiquidityEngine = class {
-  /**
-   * @param queryClient - Nexus GraphQL client attached to the gateway.
-   * @param chainConfigService - Resolves token decimals for formatted results.
-   */
-  constructor(queryClient, chainConfigService) {
+  constructor(queryClient) {
     this.queryClient = queryClient;
-    this.chainConfigService = chainConfigService;
   }
   queryClient;
-  chainConfigService;
   /**
-   * Retrieves the newest directional Phantom snapshot for a pair and its
-   * indexed output-token liquidity.
+   * Returns liquidity reachable from one source chain on one destination.
    *
-   * Nexus filters balances to the canonical output token, then aggregates them
-   * overall and by chain. The returned amounts are decimal strings: the total
-   * uses the canonical Base output-token decimals, while each chain group uses
-   * that chain's token decimals. They describe `snapshotTime`, not live
-   * reservations or fill guarantees.
+   * The caller resolves chain-specific token addresses through chain
+   * configuration; this layer only maps those configured symbols onto the
+   * indexer's canonical pool and route fields.
    *
-   * @param params - Canonical Phantom-market input and output token addresses.
-   * @returns The latest snapshot, or `undefined` if Nexus has no snapshot for
-   * the directional pair.
-   * @throws {InvalidAvailableLiquiditySnapshotError} If Nexus returns malformed
-   * or internally inconsistent snapshot data.
-   */
-  async getAvailableLiquiditySnapshot(params) {
-    const tokenIn = normalizeEvmAddress(params.tokenIn, "tokenIn");
-    const tokenOut = normalizeEvmAddress(params.tokenOut, "tokenOut");
-    const response = await this.queryClient.request(
-      LATEST_PHANTOM_ORDER_LIQUIDITY_SNAPSHOT,
-      { tokenA: tokenIn, tokenB: tokenOut }
-    );
-    const node = response?.phantomOrderPriceSnapshots?.nodes?.[0];
-    if (!node) return;
-    const commitment = node.commitment.toLowerCase();
-    if (!COMMITMENT_PATTERN.test(commitment)) {
-      throw new InvalidAvailableLiquiditySnapshotError(commitment || "<missing>", "commitment is not bytes32 hex");
-    }
-    if (node.tokenA.toLowerCase() !== tokenIn || node.tokenB.toLowerCase() !== tokenOut) {
-      throw new InvalidAvailableLiquiditySnapshotError(commitment, "snapshot token pair does not match the query");
-    }
-    const snapshotTime = new Date(dateStringtoTimestamp(node.snapshotTime));
-    if (Number.isNaN(snapshotTime.getTime())) {
-      throw new InvalidAvailableLiquiditySnapshotError(commitment, "snapshotTime is invalid");
+   * Destination, unrestricted, and explicit-route capacity are returned as
+   * separate values so callers can apply their own source-chain policy.
+   *
+   * @returns `undefined` only when the indexer has not published a destination
+   * pool sample yet.
+   */
+  async getAvailableLiquidity(params) {
+    const pool = resolveLiquidityPool(params.source.symbol, params.destination.symbol);
+    const direction = params.source.symbol.toLowerCase() === pool.token0Symbol.toLowerCase() ? SELL : BUY;
+    const variables = {
+      poolId: pool.poolId,
+      sourceChain: params.source.chain,
+      destinationChain: params.destination.chain,
+      direction
+    };
+    const response = await this.queryClient.request(AVAILABLE_LIQUIDITY, variables);
+    if (!response?.poolChainLiquidities?.nodes || !response?.poolRoutes?.nodes) {
+      throw new InvalidLiquidityIndexerResponseError("liquidity connections are missing");
     }
-    const { totalLiquidity, providerCount, liquidityByChain } = await this.querySnapshotLiquidityAggregates({
-      commitment,
-      tokenAddress: tokenOut
-    });
+    const chainLiquidity = response.poolChainLiquidities.nodes[0];
+    if (!chainLiquidity) return void 0;
+    const route = response.poolRoutes.nodes[0];
     return {
-      totalLiquidity: this.formatLiquidity(totalLiquidity, "EVM-8453" /* BASE_MAINNET */, tokenOut, commitment),
-      providerCount,
-      tokenAddress: tokenOut,
-      snapshotTime,
-      liquidityByChain: liquidityByChain.map((group) => ({
-        ...group,
-        totalLiquidity: this.formatLiquidity(group.totalLiquidity, group.chain, group.tokenAddress, commitment)
-      }))
+      sourceChain: params.source.chain,
+      destinationChain: params.destination.chain,
+      tokenAddress: normalizeEvmAddress(params.destination.address, "destination token"),
+      updatedAt: readIndexerDate(chainLiquidity.lastUpdatedAt, "destination lastUpdatedAt"),
+      destination: readLiquiditySlice(chainLiquidity.depth, chainLiquidity.bidCount, "destination"),
+      unrestricted: readLiquiditySlice(
+        chainLiquidity.unrestrictedDepth,
+        chainLiquidity.unrestrictedBidCount,
+        "unrestricted"
+      ),
+      explicitRoute: route ? {
+        ...readLiquiditySlice(route.depth, route.bidCount, "explicit route"),
+        updatedAt: readIndexerDate(route.lastUpdatedAt, "route lastUpdatedAt")
+      } : null
     };
   }
   /**
-   * Requests server-side sums and distinct provider counts for one immutable
-   * snapshot/output-token pair, including chain-level aggregate groups.
+   * Returns chain-specific buy and sell rates in less-valued quote-token units
+   * per one base token.
    *
-   * `commitment` uniquely identifies the selected snapshot
-   */
-  async querySnapshotLiquidityAggregates(params) {
-    const response = await this.queryClient.request(
-      LIQUIDITY_PROVIDER_BALANCES,
-      { commitment: params.commitment, tokenAddress: params.tokenAddress }
-    );
-    const connection = response?.liquidityProviderBalances;
-    const aggregates = connection?.aggregates;
-    if (!connection || !aggregates) {
-      throw new InvalidAvailableLiquiditySnapshotError(
-        params.commitment,
-        "liquidityProviderBalances aggregates are missing"
-      );
-    }
-    const totalLiquidity = parseSnapshotBigInt(aggregates.sum.balance ?? "0", params.commitment, "total balance");
-    const providerCount = parseProviderCount(aggregates.distinctCount.providerId, params.commitment, "total");
-    const liquidityByChain = connection.groupedAggregates.map((group, index) => {
-      const [chain, tokenAddress] = group.keys;
-      if (!chain?.trim() || !tokenAddress) {
-        throw new InvalidAvailableLiquiditySnapshotError(
-          params.commitment,
-          `liquidity group ${index} has invalid keys`
-        );
-      }
-      const normalizedTokenAddress = normalizeIndexedLiquidityAddress(
-        tokenAddress,
-        params.commitment,
-        `liquidity group ${index} tokenAddress`
-      );
-      if (normalizedTokenAddress !== params.tokenAddress) {
-        throw new InvalidAvailableLiquiditySnapshotError(
-          params.commitment,
-          `liquidity group ${index} tokenAddress does not match the snapshot output token`
-        );
-      }
-      return {
-        chain: chain.trim(),
-        tokenAddress: normalizedTokenAddress,
-        totalLiquidity: parseSnapshotBigInt(
-          group.sum.balance ?? "0",
-          params.commitment,
-          `liquidity group ${index} balance`
-        ),
-        providerCount: parseProviderCount(
-          group.distinctCount.providerId,
-          params.commitment,
-          `liquidity group ${index}`
-        )
-      };
+   * The requested direction is read on the destination chain; its reverse is
+   * read on the source chain. This mirrors where each direction's output token
+   * must be delivered for a cross-chain trade.
+   */
+  async getBuyAndSellRates(params) {
+    const pool = resolveLiquidityPool(params.tokenInSymbol, params.tokenOutSymbol);
+    const directDirection = params.tokenInSymbol.toLowerCase() === pool.token0Symbol.toLowerCase() ? SELL : BUY;
+    const reverseDirection = directDirection === SELL ? BUY : SELL;
+    const response = await this.queryClient.request(BUY_AND_SELL_RATES, {
+      poolId: pool.poolId,
+      directChain: params.destinationChain,
+      directDirection,
+      reverseChain: params.sourceChain,
+      reverseDirection
     });
-    const groupedTotal = liquidityByChain.reduce((sum, group) => sum + group.totalLiquidity, 0n);
-    if (groupedTotal !== totalLiquidity) {
-      throw new InvalidAvailableLiquiditySnapshotError(
-        params.commitment,
-        "grouped liquidity does not match the total liquidity"
-      );
-    }
-    return { totalLiquidity, providerCount, liquidityByChain };
+    if (!response?.direct?.nodes || !response?.reverse?.nodes) {
+      throw new InvalidLiquidityIndexerResponseError("rate connections are missing");
+    }
+    const direct = readIndexedRate(response.direct.nodes[0], "direct rate");
+    const reverse = readIndexedRate(response.reverse.nodes[0], "reverse rate");
+    if (!direct && !reverse) return void 0;
+    const quoteTokenSymbol = resolveQuoteTokenSymbol(
+      params.tokenInSymbol,
+      params.tokenOutSymbol,
+      direct?.scaledRate,
+      reverse?.scaledRate
+    );
+    const quoteIsTokenOut = quoteTokenSymbol === params.tokenOutSymbol;
+    const buy = quoteIsTokenOut ? direct : reverse;
+    const sell = quoteIsTokenOut ? reverse : direct;
+    return {
+      baseTokenSymbol: quoteIsTokenOut ? params.tokenInSymbol : params.tokenOutSymbol,
+      quoteTokenSymbol,
+      sourceChain: params.sourceChain,
+      destinationChain: params.destinationChain,
+      buyRate: buy ? viem.formatUnits(buy.scaledRate, INDEXER_FIXED_POINT_DECIMALS) : null,
+      sellRate: sell ? viem.formatUnits(reciprocalRate(sell.scaledRate, "sell rate"), INDEXER_FIXED_POINT_DECIMALS) : null,
+      buyRateUpdatedAt: buy?.updatedAt ?? null,
+      sellRateUpdatedAt: sell?.updatedAt ?? null
+    };
   }
-  /** Formats a raw amount using the configured decimals for its chain/token. */
-  formatLiquidity(amount, chain, tokenAddress, commitment) {
-    const decimals = this.chainConfigService.getAssetMetadataByAddress(chain, tokenAddress)?.decimals;
-    if (decimals === void 0) {
-      throw new InvalidAvailableLiquiditySnapshotError(
-        commitment,
-        `token decimals are not configured for ${tokenAddress} on ${chain}`
-      );
-    }
-    return viem.formatUnits(amount, decimals);
+};
+var InvalidLiquidityIndexerResponseError = class extends Error {
+  constructor(reason) {
+    super(`Invalid liquidity indexer response: ${reason}`);
+    this.name = "InvalidLiquidityIndexerResponseError";
   }
 };
-var InvalidAvailableLiquiditySnapshotError = class extends Error {
-  /** Creates an error that identifies the invalid snapshot and field/reason. */
-  constructor(commitment, reason) {
-    super(`Invalid available-liquidity snapshot ${commitment}: ${reason}`);
-    this.name = "InvalidAvailableLiquiditySnapshotError";
+var UnsupportedLiquidityAssetError = class extends Error {
+  constructor(chain, asset) {
+    super(`No configured liquidity asset found for ${asset} on ${chain}`);
+    this.name = "UnsupportedLiquidityAssetError";
   }
 };
-function parseSnapshotBigInt(value, commitment, field) {
+var UnsupportedLiquidityChainError = class extends Error {
+  constructor(chainId) {
+    super(`No configured liquidity chain found for chain ID ${chainId}`);
+    this.name = "UnsupportedLiquidityChainError";
+  }
+};
+function readLiquiditySlice(depth, providerCount, label) {
+  if (!Number.isSafeInteger(providerCount) || providerCount < 0) {
+    throw new InvalidLiquidityIndexerResponseError(`${label} provider count is invalid`);
+  }
+  return { totalLiquidity: formatIndexerAmount(depth, `${label} depth`), providerCount };
+}
+function formatIndexerAmount(value, label) {
   try {
     const amount = BigInt(value);
-    if (amount < 0n) {
-      throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} cannot be negative`);
-    }
-    return amount;
-  } catch (error) {
-    if (error instanceof InvalidAvailableLiquiditySnapshotError) throw error;
-    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} is not an integer`);
+    if (amount < 0n) throw new Error();
+    return viem.formatUnits(amount, INDEXER_FIXED_POINT_DECIMALS);
+  } catch {
+    throw new InvalidLiquidityIndexerResponseError(`${label} is not a non-negative integer`);
   }
 }
-function parseProviderCount(value, commitment, field) {
-  const count = Number(value);
-  if (!Number.isSafeInteger(count) || count < 0) {
-    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} provider count is invalid`);
-  }
-  return count;
+function readIndexerDate(value, label) {
+  const date = new Date(dateStringtoTimestamp(value));
+  if (Number.isNaN(date.getTime())) throw new InvalidLiquidityIndexerResponseError(`${label} is invalid`);
+  return date;
 }
-function normalizeIndexedLiquidityAddress(address, commitment, field) {
+function readIndexedRate(node, label) {
+  if (!node) return void 0;
   try {
-    return normalizeEvmAddress(address, field);
-  } catch {
-    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} is not a valid EVM address`);
+    const scaledRate = BigInt(node.rate);
+    if (scaledRate <= 0n) throw new Error();
+    return {
+      scaledRate,
+      updatedAt: readIndexerDate(node.lastUpdatedAt, `${label} lastUpdatedAt`)
+    };
+  } catch (error) {
+    if (error instanceof InvalidLiquidityIndexerResponseError) throw error;
+    throw new InvalidLiquidityIndexerResponseError(`${label} is not a positive integer`);
   }
 }
+function resolveQuoteTokenSymbol(tokenInSymbol, tokenOutSymbol, directRate, reverseRate) {
+  const inputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenInSymbol);
+  const outputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenOutSymbol);
+  if (inputIsUsdStable !== outputIsUsdStable) return inputIsUsdStable ? tokenOutSymbol : tokenInSymbol;
+  if (directRate !== void 0) return directRate >= POOL_RATE_SCALE ? tokenOutSymbol : tokenInSymbol;
+  if (reverseRate !== void 0) return reverseRate >= POOL_RATE_SCALE ? tokenInSymbol : tokenOutSymbol;
+  throw new InvalidLiquidityIndexerResponseError("cannot orient an empty rate pair");
+}
+function reciprocalRate(rate, label) {
+  const reciprocal = POOL_RATE_SCALE * POOL_RATE_SCALE / rate;
+  if (reciprocal <= 0n) throw new InvalidLiquidityIndexerResponseError(`${label} reciprocal underflowed`);
+  return reciprocal;
+}
 
 // src/protocols/intents/quote/types.ts
 var UnsupportedIntentQuoteStrategyError = class extends Error {
@@ -18519,8 +18880,6 @@ var IntentGateway = class _IntentGateway {
   gasEstimator;
   /** Quote strategies for pricing orders before placement, keyed by strategy name. */
   quoteStrategies;
-  /** Resolves order tokens to canonical Phantom snapshot market pairs. */
-  phantomSnapshotPairResolver;
   /**
    * Private constructor — use {@link IntentGateway.create} instead.
    *
@@ -18564,7 +18923,6 @@ var IntentGateway = class _IntentGateway {
     this.bidManager = bidManager;
     this.gasEstimator = gasEstimator;
     this._crypto = crypto;
-    this.phantomSnapshotPairResolver = new PhantomSnapshotPairResolver(dest.configService);
     this.quoteStrategies = {
       phantom_snapshot: new PhantomSnapshotIntentQuoteStrategy(
         dest.configService,
@@ -18644,33 +19002,62 @@ var IntentGateway = class _IntentGateway {
     return handler.quote({ ...params, strategy }, source, destination);
   }
   /**
-   * Returns the output-token liquidity measured in the latest directional
-   * Phantom snapshot for this gateway's source and destination.
+   * Returns indexed destination liquidity and its source-routing slices.
    *
-   * Pair resolution uses the same canonical Base market as {@link quoteIntent}.
-   * The snapshot itself determines the output token and chain to aggregate. The
-   * amount is in the token's smallest unit and reflects the indexer's
-   * `snapshotTime`; it is not a live reservation or fill guarantee.
+   * Destination, unrestricted, and explicit-route capacity come exclusively
+   * from the indexer's pair-centric liquidity entities. The SDK does not decide
+   * whether unrestricted bidders cover the source chain. Amounts reflect the
+   * latest rolling sample; they are not reservations or fill guarantees.
    *
    * Requires a prior call to {@link withQueryClient}.
    */
   async queryAvailableLiquidity(params) {
     const { queryClient } = this.requireIndexer();
-    const sourceStateMachineId = this.source.config.stateMachineId;
-    const destinationStateMachineId = this.dest.config.stateMachineId;
-    const pair = this.phantomSnapshotPairResolver.resolve(params, sourceStateMachineId, destinationStateMachineId);
-    if (!pair) {
-      throw new UnsupportedIntentQuotePairError({
-        source: sourceStateMachineId,
-        destination: destinationStateMachineId,
-        tokenIn: params.tokenIn,
-        tokenOut: params.tokenOut,
-        quoteSource: "Phantom snapshot pair"
-      });
-    }
-    return new LiquidityEngine(queryClient, this.dest.configService).getAvailableLiquiditySnapshot({
-      tokenIn: pair.tokenA,
-      tokenOut: pair.tokenB
+    const sourceStateMachineId = getConfigByStateMachineId(this.source.config.stateMachineId)?.stateMachineId;
+    const destinationStateMachineId = getConfigByStateMachineId(this.dest.config.stateMachineId)?.stateMachineId;
+    if (!sourceStateMachineId) throw new UnsupportedLiquidityChainError(this.source.config.stateMachineId);
+    if (!destinationStateMachineId) throw new UnsupportedLiquidityChainError(this.dest.config.stateMachineId);
+    const sourceToken = this.source.configService.getAssetMetadataByAddress(sourceStateMachineId, params.tokenIn);
+    const destinationToken = this.dest.configService.getAssetMetadataByAddress(
+      destinationStateMachineId,
+      params.tokenOut
+    );
+    if (!sourceToken) throw new UnsupportedLiquidityAssetError(sourceStateMachineId, params.tokenIn);
+    if (!destinationToken) throw new UnsupportedLiquidityAssetError(destinationStateMachineId, params.tokenOut);
+    return new LiquidityEngine(queryClient).getAvailableLiquidity({
+      source: {
+        chain: sourceStateMachineId,
+        ...sourceToken
+      },
+      destination: {
+        chain: destinationStateMachineId,
+        ...destinationToken
+      }
+    });
+  }
+  /**
+   * Returns chain-specific buy and sell rates in less-valued quote-token units
+   * without requiring token addresses. Symbols are matched case-insensitively;
+   * chain IDs are numeric IDs for chains configured in the SDK.
+   */
+  async queryBuyAndSellRates(params) {
+    const { queryClient } = this.requireIndexer();
+    const sourceChain = chainConfigs[params.sourceChainId]?.stateMachineId;
+    const destinationChain = chainConfigs[params.destinationChainId]?.stateMachineId;
+    if (!sourceChain) throw new UnsupportedLiquidityChainError(params.sourceChainId);
+    if (!destinationChain) throw new UnsupportedLiquidityChainError(params.destinationChainId);
+    const sourceToken = this.source.configService.getAssetMetadataBySymbol(sourceChain, params.tokenInSymbol);
+    const destinationToken = this.dest.configService.getAssetMetadataBySymbol(
+      destinationChain,
+      params.tokenOutSymbol
+    );
+    if (!sourceToken) throw new UnsupportedLiquidityAssetError(sourceChain, params.tokenInSymbol);
+    if (!destinationToken) throw new UnsupportedLiquidityAssetError(destinationChain, params.tokenOutSymbol);
+    return new LiquidityEngine(queryClient).getBuyAndSellRates({
+      sourceChain,
+      destinationChain,
+      tokenInSymbol: sourceToken.symbol,
+      tokenOutSymbol: destinationToken.symbol
     });
   }
   /**
@@ -19210,14 +19597,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) {
@@ -19225,25 +19632,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"
@@ -23735,10 +24176,12 @@ exports.EvmLanguage = EvmLanguage;
 exports.HyperClientStatus = HyperClientStatus;
 exports.HyperFungibleToken = HyperFungibleToken;
 exports.HyperFungibleTokenABI = HyperFungibleTokenABI;
+exports.INCLUSION_TIMEOUT_MS = INCLUSION_TIMEOUT_MS;
 exports.IntentGateway = IntentGateway;
 exports.IntentGatewayABI = ABI3;
 exports.IntentOrderStatus = IntentOrderStatus;
 exports.IntentsCoprocessor = IntentsCoprocessor;
+exports.InvalidLiquidityIndexerResponseError = InvalidLiquidityIndexerResponseError;
 exports.InvalidPhantomSnapshotError = InvalidPhantomSnapshotError;
 exports.IsmpClient = IsmpClient;
 exports.MOCK_ADDRESS = MOCK_ADDRESS;
@@ -23768,6 +24211,8 @@ exports.TronChain = TronChain;
 exports.USE_ETHERSCAN_CHAINS = USE_ETHERSCAN_CHAINS;
 exports.UnsupportedIntentQuotePairError = UnsupportedIntentQuotePairError;
 exports.UnsupportedIntentQuoteStrategyError = UnsupportedIntentQuoteStrategyError;
+exports.UnsupportedLiquidityAssetError = UnsupportedLiquidityAssetError;
+exports.UnsupportedLiquidityChainError = UnsupportedLiquidityChainError;
 exports.WrappedHyperFungibleTokenABI = WrappedHyperFungibleTokenABI;
 exports.__test = __test;
 exports.adjustDecimals = adjustDecimals;
@@ -23789,10 +24234,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;
@@ -23828,6 +24276,7 @@ exports.pharosAtlantic = pharosAtlantic;
 exports.pharosMainnet = pharosMainnet;
 exports.polkadotAssetHubPaseo = polkadotAssetHubPaseo;
 exports.polkadotHubMainnet = polkadotHubMainnet;
+exports.poolSlug = poolSlug;
 exports.postRequestCommitment = postRequestCommitment;
 exports.queryAssetTeleported = queryAssetTeleported;
 exports.queryGetRequest = queryGetRequest;
@@ -23836,6 +24285,7 @@ exports.quoteUniswap = quoteUniswap;
 exports.requestCommitmentKey = requestCommitmentKey;
 exports.responseCommitmentKey = responseCommitmentKey;
 exports.retryPromise = retryPromise;
+exports.sortPoolSymbols = sortPoolSymbols;
 exports.teleport = teleport;
 exports.teleportDot = teleportDot;
 exports.transformOrderForContract = transformOrderForContract;