@hyperbridge/sdk 2.2.3 → 2.3.1

package/dist/node/index.cjs

@@ -13,6 +13,7 @@ var api = require('@polkadot/api');
 var scaleTs = require('scale-ts');
 var utilCrypto = require('@polkadot/util-crypto');
 var util = require('@polkadot/util');
+var PQueue = require('p-queue');
 var stdEnv = require('std-env');
 var mergeRace = require('@async-generator/merge-race');
 var graphqlRequest = require('graphql-request');
@@ -25,6 +26,7 @@ var Decimal2 = require('decimal.js');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var PQueue__default = /*#__PURE__*/_interopDefault(PQueue);
 var mergeRace__default = /*#__PURE__*/_interopDefault(mergeRace);
 var inMemoryDriver__default = /*#__PURE__*/_interopDefault(inMemoryDriver);
 var fsDriver__default = /*#__PURE__*/_interopDefault(fsDriver);
@@ -524,6 +526,11 @@ var ABI = [
             name: "context",
             type: "bytes",
             internalType: "bytes"
+          },
+          {
+            name: "payer",
+            type: "address",
+            internalType: "address"
           }
         ]
       }
@@ -2104,7 +2111,7 @@ var ABI2 = [
               { internalType: "bytes", name: "source", type: "bytes" },
               { internalType: "bytes", name: "dest", type: "bytes" },
               { internalType: "uint64", name: "nonce", type: "uint64" },
-              { internalType: "address", name: "from", type: "address" },
+              { internalType: "bytes", name: "from", type: "bytes" },
               { internalType: "uint64", name: "timeoutTimestamp", type: "uint64" },
               { internalType: "bytes[]", name: "keys", type: "bytes[]" },
               { internalType: "uint64", name: "height", type: "uint64" },
@@ -2171,7 +2178,7 @@ var ABI2 = [
                       { internalType: "bytes", name: "source", type: "bytes" },
                       { internalType: "bytes", name: "dest", type: "bytes" },
                       { internalType: "uint64", name: "nonce", type: "uint64" },
-                      { internalType: "address", name: "from", type: "address" },
+                      { internalType: "bytes", name: "from", type: "bytes" },
                       { internalType: "uint64", name: "timeoutTimestamp", type: "uint64" },
                       { internalType: "bytes[]", name: "keys", type: "bytes[]" },
                       { internalType: "uint64", name: "height", type: "uint64" },
@@ -2579,9 +2586,9 @@ var chainConfigs = {
       USDT: { balanceSlot: 151, allowanceSlot: 152 }
     },
     addresses: {
-      IntentGateway: "0xE13fB34CAe12505ae51BaC8C405AF8EB27AC8058",
+      IntentGateway: "0x6CF42FA9BecbC5b6a26884964956b113530f7cFA",
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       UniswapRouter02: "0x9639379819420704457B07A0C33B678D9E0F8Df0",
       UniswapV2Factory: "0x12e036669DA18F4A2777853d6e2136b32AceEC86",
       UniswapV3Factory: "0x0000000000000000000000000000000000000000",
@@ -2589,7 +2596,7 @@ var chainConfigs = {
       UniswapV3Quoter: "0x0000000000000000000000000000000000000000",
       UniswapV4Quoter: "0x0000000000000000000000000000000000000000",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-      SolverAccount: "0x0b5cfBc16ef60AD6930ba5A90Bb09475B7BF3815"
+      SolverAccount: "0x07FeC66d967800998060194EaECDd7C66dA4a1B1"
     },
     rpcEnvKey: "BSC_CHAPEL",
     defaultRpcUrl: "https://bnb-testnet.api.onfinality.io/public",
@@ -2620,7 +2627,7 @@ var chainConfigs = {
     addresses: {
       IntentGateway: "0x016b6ffC9f890d1e28f9Fdb9eaDA776b02F89509",
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x58A41B89F4871725E5D898d98eF4BF917601c5eB",
       UniswapRouter02: "0x0000000000000000000000000000000000000000",
       UniswapV2Factory: "0x0000000000000000000000000000000000000000",
       UniswapV3Factory: "0x0000000000000000000000000000000000000000",
@@ -2659,7 +2666,7 @@ var chainConfigs = {
     addresses: {
       IntentGateway: "0x016b6ffC9f890d1e28f9Fdb9eaDA776b02F89509",
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       UniswapRouter02: "0x0000000000000000000000000000000000000000",
       UniswapV2Factory: "0x0000000000000000000000000000000000000000",
       UniswapV3Factory: "0x0000000000000000000000000000000000000000",
@@ -3005,13 +3012,13 @@ var chainConfigs = {
       USDC: { balanceSlot: 1, allowanceSlot: 2 }
     },
     addresses: {
-      IntentGateway: "0xE13fB34CAe12505ae51BaC8C405AF8EB27AC8058",
+      IntentGateway: "0x6CF42FA9BecbC5b6a26884964956b113530f7cFA",
       TokenGateway: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       Calldispatcher: "0x876F1891982E260026630c233A4897160A281Fb8",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-      SolverAccount: "0x0b5cfBc16ef60AD6930ba5A90Bb09475B7BF3815"
+      SolverAccount: "0x07FeC66d967800998060194EaECDd7C66dA4a1B1"
     },
     rpcEnvKey: "POLYGON_AMOY",
     defaultRpcUrl: "https://rpc-amoy.polygon.technology",
@@ -3127,7 +3134,7 @@ var chainConfigs = {
     },
     addresses: {
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
     },
     defaultRpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
@@ -3151,7 +3158,7 @@ var chainConfigs = {
     },
     addresses: {
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
     },
     defaultRpcUrl: "https://sepolia.optimism.io",
@@ -3175,7 +3182,7 @@ var chainConfigs = {
     },
     addresses: {
       TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
     },
     defaultRpcUrl: "https://sepolia.base.org",
@@ -3201,7 +3208,7 @@ var chainConfigs = {
     addresses: {
       IntentGateway: "0x606ba811aa6cb424ce2108e8977c5284686f0d1f",
       TokenGateway: "0x1c1e5be83df4a54c7a2230c337e4a3e8b7354b1c",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
     },
     defaultRpcUrl: "https://testnet-asset-hub-eth-rpc.polkadot.io",
@@ -3251,7 +3258,7 @@ var chainConfigs = {
     wrappedNativeDecimals: 18,
     addresses: {
       TokenGateway: "0x451bDd8273839AD0Ec7F4Fa798E8B3DABb223fD8",
-      Host: "0xEB944071A9Bf22810757C5BcFf7a2aE9663a311D",
+      Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
       IntentGateway: "0xb8039832c6c9266F928d038eA49A8a169300C670"
     },
     consensusStateId: "PHAR",
@@ -4383,6 +4390,11 @@ var ABI3 = [
             name: "context",
             type: "bytes",
             internalType: "bytes"
+          },
+          {
+            name: "payer",
+            type: "address",
+            internalType: "address"
           }
         ]
       }
@@ -6391,28 +6403,60 @@ var EvmChain = class _EvmChain {
   }
   /**
    * Query and return the encoded storage proof for the provided keys at the given height.
+   *
+   * Keys may be either:
+   *  - 32-byte storage slots — read from `address` (or the host contract when omitted), or
+   *  - 52-byte cross-chain GET keys encoded as `address(20) || slot(32)`, where the target
+   *    contract is embedded in the key. These may span multiple contracts.
+   *
    * @param {bigint} at - The block height at which to query the storage proof.
    * @param {HexString[]} keys - The keys for which to query the storage proof.
-   * @param {HexString} address - Optional contract address to fetch storage proof else default to host contract
+   * @param {HexString} address - Optional contract address; forces all keys to be read as slots
+   *   of this contract. Omit to let 52-byte keys carry their own contract address.
    * @returns {Promise<HexString>} The encoded storage proof.
    */
   async queryStateProof(at, keys, address) {
-    const config = {
-      address: address ?? this.params.host,
-      storageKeys: keys
-    };
-    if (!at) {
-      config.blockTag = "latest";
-    } else {
-      config.blockNumber = at;
-    }
-    const proof = await this.publicClient.getProof(config);
-    const flattenedProof = Array.from(new Set(lodashEs.flatten(proof.storageProof.map((item) => item.proof))));
+    const slotsByContract = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      let contract;
+      let slot;
+      if (address) {
+        contract = address.toLowerCase();
+        slot = key;
+      } else if ((key.length - 2) / 2 === 52) {
+        contract = key.slice(0, 42).toLowerCase();
+        slot = `0x${key.slice(42)}`;
+      } else {
+        contract = this.params.host.toLowerCase();
+        slot = key;
+      }
+      const slots = slotsByContract.get(contract) ?? [];
+      slots.push(slot);
+      slotsByContract.set(contract, slots);
+    }
+    const contracts = Array.from(slotsByContract.entries());
+    const proofs = await Promise.all(
+      contracts.map(([contract, slots]) => {
+        const config = { address: contract, storageKeys: slots };
+        if (!at) {
+          config.blockTag = "latest";
+        } else {
+          config.blockNumber = at;
+        }
+        return this.publicClient.getProof(config);
+      })
+    );
+    const contractProof = Array.from(new Set(lodashEs.flatten(proofs.map((proof) => proof.accountProof))));
+    const storageProof = contracts.map(([contract], i) => {
+      const flattened = Array.from(new Set(lodashEs.flatten(proofs[i].storageProof.map((item) => item.proof))));
+      return [
+        Array.from(viem.hexToBytes(contract)),
+        flattened.map((item) => Array.from(viem.hexToBytes(item)))
+      ];
+    });
     const encoded = EvmStateProof.enc({
-      contractProof: proof.accountProof.map((item) => Array.from(viem.hexToBytes(item))),
-      storageProof: [
-        [Array.from(viem.hexToBytes(config.address)), flattenedProof.map((item) => Array.from(viem.hexToBytes(item)))]
-      ]
+      contractProof: contractProof.map((item) => Array.from(viem.hexToBytes(item))),
+      storageProof
     });
     return viem.toHex(encoded);
   }
@@ -7134,6 +7178,49 @@ var SubstrateChain = class _SubstrateChain {
     const item = await this.rpcClient.call("childstate_getStorage", [prefix, key]);
     return item;
   }
+  /**
+   * Returns the storage key for a response receipt in the child trie.
+   * A response receipt is keyed by the originating *request* commitment.
+   * @param {HexString} key - The request commitment (0x-prefixed H256 hex string)
+   * @returns {HexString} The storage key as a hex string
+   */
+  responseReceiptKey(key) {
+    const prefix = new TextEncoder().encode("ResponseReceipts");
+    const keyBytes = viem.hexToBytes(key);
+    return viem.bytesToHex(new Uint8Array([...prefix, ...keyBytes]));
+  }
+  /**
+   * Queries the response receipt for a request commitment. For a GET, Hyperbridge
+   * produces the response as it processes the request, so the presence of a response
+   * receipt indicates the request has already been delivered and handled.
+   * @param {HexString} commitment - The originating request commitment to query.
+   * @returns {Promise<HexString | undefined>} The receipt data if present, otherwise undefined.
+   */
+  async queryResponseReceipt(commitment) {
+    const prefix = viem.toHex(":child_storage:default:ISMP");
+    const key = this.responseReceiptKey(commitment);
+    const item = await this.rpcClient.call("childstate_getStorage", [prefix, key]);
+    return item;
+  }
+  /**
+   * Queries the state-machine commitment Hyperbridge holds for a counterparty chain at an
+   * exact height — the `BoundedStateCommitments` map that `state_machine_commitment` (and thus
+   * proof verification) reads. Returns the committed `stateRoot`, or undefined if Hyperbridge
+   * has not finalized that chain at exactly that height.
+   * @param {StateMachineHeight} height - The counterparty state machine id + height.
+   * @returns {Promise<HexString | undefined>} The committed state root, or undefined if absent.
+   */
+  async queryStateMachineCommitment(height) {
+    if (!this.api) throw new Error("API not initialized");
+    const id = {
+      stateId: height.id.stateId,
+      // on-chain StateMachineId encodes consensusStateId as [u8; 4]
+      consensusStateId: viem.toHex(viem.toBytes(height.id.consensusStateId))
+    };
+    const commitment = await this.api.query.ismp.boundedStateCommitments(id, Number(height.height));
+    if (commitment.isNone) return void 0;
+    return commitment.toJSON()?.stateRoot;
+  }
   /**
    * Returns the current timestamp of the chain.
    * @returns {Promise<bigint>} The current timestamp.
@@ -7543,6 +7630,7 @@ function encodeISMPMessage(message) {
   }
 }
 var OFFCHAIN_BID_PREFIX = new TextEncoder().encode("intents::bid::");
+var OFFCHAIN_PHANTOM_PREFIX = new TextEncoder().encode("intents::phantom::order::");
 var BidCodec = scaleTs.Struct({ filler: scaleTs.Bytes(32), user_op: scaleTs.Vector(scaleTs.u8) });
 var PackedUserOperationCodec = scaleTs.Struct({
   sender: scaleTs.Bytes(20),
@@ -7603,6 +7691,11 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   ownsConnection;
   /** Cached result of whether the node exposes intents_* RPC methods */
   hasIntentsRpc = 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
+  // the same nonce and all but one would fail. Concurrency 1 sequences them.
+  submissionQueue = new PQueue__default.default({ concurrency: 1 });
   /**
    * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
    * This creates and manages its own API connection.
@@ -7655,14 +7748,17 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     }
   }
   /**
-   * Creates a Substrate keypair from the configured private key
-   * Supports both hex seed (without 0x prefix) and mnemonic phrases
+   * Creates a Substrate keypair from the configured private key.
+   * Supports hex seed (with or without 0x), mnemonic phrases, and URI derivation paths (//Alice).
    */
   getKeyPair() {
     if (!this.substratePrivateKey) {
       throw new Error("Substrate PrivateKey Required");
     }
     const keyring = new api.Keyring({ type: "sr25519" });
+    if (this.substratePrivateKey.startsWith("//")) {
+      return keyring.addFromUri(this.substratePrivateKey);
+    }
     if (this.substratePrivateKey.includes(" ")) {
       return keyring.addFromMnemonic(this.substratePrivateKey);
     }
@@ -7671,10 +7767,19 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     return keyring.addFromSeed(seedBytes);
   }
   /**
-   * Signs and sends an extrinsic, handling status updates and errors
-   * Implements retry logic with progressive tip increases for stuck transactions
+   * 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.
    */
   async signAndSendExtrinsic(extrinsic, maxRetries = 3, timeoutMs = 3e4) {
+    const result = await this.submissionQueue.add(() => this.sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs));
+    return result ?? { success: false, error: "Submission queue returned no result" };
+  }
+  /**
+   * Signs and sends an extrinsic, handling status updates and errors.
+   * Implements retry logic with progressive tip increases for stuck transactions.
+   */
+  async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
     const keyPair = this.getKeyPair();
     let baseTip = 500000000000n;
     let attempt = 0;
@@ -7719,20 +7824,51 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       }, timeoutMs);
       extrinsic.signAndSend(keyPair, { tip }, (result) => {
         if (resolved) return;
-        if (result.status.isInBlock || result.status.isFinalized) {
+        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: true,
-            blockHash: result.status.asInBlock.toHex(),
-            extrinsicHash: extrinsic.hash.toHex()
+            success: false,
+            error: errorMsg
           });
-        } else if (result.dispatchError) {
+        } else if (result.status.isDropped || result.status.isInvalid || result.status.isUsurped || result.status.isFinalityTimeout) {
           resolved = true;
           clearTimeout(timeoutId);
           resolve({
             success: false,
-            error: `Dispatch error: ${result.dispatchError.toString()}`
+            error: `Transaction ${result.status.type.toLowerCase()}`
+          });
+        } else if (result.status.isInBlock || result.status.isFinalized) {
+          resolved = true;
+          clearTimeout(timeoutId);
+          const interrupted = result.events.find(
+            ({ event }) => event.section === "utility" && event.method === "BatchInterrupted"
+          );
+          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 });
+              return;
+            }
+          }
+          resolve({
+            success: true,
+            blockHash: (result.status.isInBlock ? result.status.asInBlock : result.status.asFinalized).toHex(),
+            extrinsicHash: extrinsic.hash.toHex()
           });
         }
       }).then((unsub) => {
@@ -7787,6 +7923,40 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
       };
     }
   }
+  /**
+   * Places a new bid and retracts a previous one in a single transaction via utility.batch.
+   *
+   * The new bid is the primary operation, so `placeBid` MUST run first. `utility.batch` is
+   * non-atomic: a failing call interrupts the batch (via a BatchInterrupted event) without
+   * reverting the calls that already succeeded. Placing first guarantees the new bid lands even
+   * when the retraction then fails — which it routinely does, because a previous commitment's bid
+   * may already be gone (or was itself never placed), making `retractBid` return `BidNotFound`.
+   *
+   * Ordering retraction first (the previous behaviour) caused a self-sustaining cascade: a
+   * `BidNotFound` on the leading retract skipped the trailing `placeBid`, so the current bid never
+   * landed, so the *next* interval's retract of that never-placed commitment also failed, and so
+   * on — silently, because the batch extrinsic itself reports success. The deposit reclaim is
+   * best-effort; landing the bid is not.
+   *
+   * @param retractCommitment - The order commitment of the bid to retract (bytes32)
+   * @param bidCommitment - The order commitment of the new bid (bytes32)
+   * @param userOp - The encoded PackedUserOperation as hex string
+   * @returns BidSubmissionResult with success status and block/extrinsic hash
+   */
+  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);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
   /**
    * Fetches all bid storage entries for a given order commitment.
    * Returns the on-chain data only (filler addresses and deposits).
@@ -7871,6 +8041,80 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   buildOffchainBidKey(commitment, filler) {
     return util.u8aConcat(OFFCHAIN_BID_PREFIX, util.hexToU8a(commitment), utilCrypto.decodeAddress(filler));
   }
+  /**
+   * Fetches the ABI-encoded phantom order from offchain storage and decodes it
+   * into an `Order` object. The pallet writes the order bytes under the key
+   * `intents::phantom::order::<commitment>` when it calls `on_initialize`.
+   *
+   * Returns `null` if the key is absent (e.g. the node is not an offchain worker
+   * or the commitment has expired and been cleared).
+   */
+  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));
+    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 orderType = placeOrderAbi?.inputs?.[0];
+    if (!orderType) return null;
+    const [decoded] = viem.decodeAbiParameters([orderType], rawHex);
+    const d = decoded;
+    const textDecoder = new TextDecoder();
+    return {
+      id: commitment,
+      user: d.user,
+      source: textDecoder.decode(viem.hexToBytes(d.source)),
+      destination: textDecoder.decode(viem.hexToBytes(d.destination)),
+      deadline: d.deadline,
+      nonce: d.nonce,
+      fees: d.fees,
+      session: d.session,
+      predispatch: {
+        assets: d.predispatch.assets.map((a) => ({
+          token: a.token,
+          amount: a.amount
+        })),
+        call: d.predispatch.call
+      },
+      inputs: d.inputs.map((i) => ({
+        token: i.token,
+        amount: i.amount
+      })),
+      output: {
+        beneficiary: d.output.beneficiary,
+        assets: d.output.assets.map((a) => ({
+          token: a.token,
+          amount: a.amount
+        })),
+        call: d.output.call
+      }
+    };
+  }
+  /**
+   * Subscribes to PhantomOrderRegistered events from the intents coprocessor pallet.
+   * Calls the callback for each new phantom order as blocks arrive.
+   * Returns an unsubscribe function to stop the subscription.
+   */
+  async subscribePhantomOrders(callback) {
+    const unsub = await this.api.query.system.events((records) => {
+      for (const { event } of records) {
+        if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
+        const [commitment, chain, createdAt, tokenA, tokenB, standardAmount] = event.data;
+        callback({
+          commitment: commitment.toHex(),
+          chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
+          createdAt: createdAt.toNumber(),
+          tokenA: tokenA.toHex(),
+          tokenB: tokenB.toHex(),
+          standardAmount: BigInt(standardAmount.toString())
+        });
+      }
+    });
+    return unsub;
+  }
 };
 var TronChain = class _TronChain {
   constructor(params, evm) {
@@ -9809,6 +10053,7 @@ var GetRequestClient = class {
     const latestMetadata = request.statuses[request.statuses.length - 1];
     status = lodashEs.maxBy([status, latestMetadata.status], (item) => REQUEST_STATUS_WEIGHTS[item]);
     if (!status) return;
+    let sourceFinalizedHeight;
     while (true) {
       switch (status) {
         case RequestStatus.SOURCE: {
@@ -9820,6 +10065,7 @@ var GetRequestClient = class {
               chain: this.ctx.config.hyperbridge.config.stateMachineId
             })
           });
+          sourceFinalizedHeight = BigInt(sourceUpdate.height);
           yield {
             status: RequestStatus.SOURCE_FINALIZED,
             metadata: {
@@ -9833,6 +10079,15 @@ var GetRequestClient = class {
           break;
         }
         case RequestStatus.SOURCE_FINALIZED: {
+          if (request.source !== this.ctx.config.hyperbridge.config.stateMachineId && sourceFinalizedHeight !== void 0) {
+            try {
+              await this.deliverToHyperbridge(request, sourceFinalizedHeight);
+            } catch (error) {
+              this.logger.warn(
+                `Self-delivery to Hyperbridge failed; waiting for a relayer instead: ${error instanceof Error ? error.message : error}`
+              );
+            }
+          }
           request = await waitOrAbort(this.ctx, {
             signal,
             promise: () => this.queries.queryGetRequest(hash),
@@ -9853,7 +10108,10 @@ var GetRequestClient = class {
         }
         case RequestStatus.HYPERBRIDGE_DELIVERED: {
           if (request.source === this.ctx.config.hyperbridge.config.stateMachineId) return;
-          const response = await this.queries.queryResponseByRequestId(hash);
+          const response = await waitOrAbort(this.ctx, {
+            signal,
+            promise: () => this.queries.queryResponseByRequestId(hash)
+          });
           yield await this.streamFinalized(signal, request, 1, response);
           status = RequestStatus.HYPERBRIDGE_FINALIZED;
           break;
@@ -9883,6 +10141,102 @@ var GetRequestClient = class {
       }
     }
   }
+  /**
+   * Self-delivers a GET request to Hyperbridge — the request→Hyperbridge hop that would
+   * otherwise require an external relayer.
+   *
+   * Mirrors the relayer path (and {@link OrderCanceller}): prove the request commitment on
+   * the source chain at the Hyperbridge-finalized source height, prove the requested keys on
+   * the destination chain at the request's height, wait out the source challenge period, then
+   * submit an unsigned `GetRequest` message. Source and destination may each be EVM or
+   * substrate — proofs are built via the chain-agnostic {@link IChain} methods.
+   *
+   * Idempotent: returns early if Hyperbridge already holds the response receipt. The caller
+   * wraps this best-effort, so a failure leaves the stream observing as before.
+   */
+  async deliverToHyperbridge(request, sourceFinalizedHeight) {
+    const sourceChain = this.ctx.config.source;
+    const destChain = this.ctx.config.dest;
+    const hyperbridge = this.ctx.config.hyperbridge;
+    const commitment = getRequestCommitment({ ...request, keys: [...request.keys] });
+    const retry = { maxRetries: 5, backoffMs: 2e3 };
+    if (await withRetry(this.ctx, () => hyperbridge.queryResponseReceipt(commitment), retry)) return;
+    this.logger.info(
+      `Delivering GET ${commitment} to Hyperbridge (${request.source}@${sourceFinalizedHeight} \u2192 ${request.dest}@${request.height})`
+    );
+    const sourceProof = {
+      height: sourceFinalizedHeight,
+      stateMachine: request.source,
+      consensusStateId: sourceChain.config.consensusStateId,
+      proof: await withRetry(
+        this.ctx,
+        () => sourceChain.queryProof(
+          { Requests: [commitment] },
+          this.ctx.config.hyperbridge.config.stateMachineId,
+          sourceFinalizedHeight
+        ),
+        retry
+      )
+    };
+    this.logger.info(`  \u2713 built source proof: ${(sourceProof.proof.length - 2) / 2} bytes @ ${request.source}#${sourceFinalizedHeight}`);
+    const destCommitment = await withRetry(
+      this.ctx,
+      () => hyperbridge.queryStateMachineCommitment({
+        id: {
+          stateId: parseStateMachineId(request.dest).stateId,
+          consensusStateId: destChain.config.consensusStateId
+        },
+        height: request.height
+      }),
+      retry
+    );
+    if (!destCommitment) {
+      throw new Error(`Hyperbridge has no state commitment for ${request.dest} at height ${request.height}`);
+    }
+    const responseProof = {
+      height: request.height,
+      stateMachine: request.dest,
+      consensusStateId: destChain.config.consensusStateId,
+      proof: await withRetry(this.ctx, () => destChain.queryStateProof(request.height, [...request.keys]), retry)
+    };
+    this.logger.info(
+      `  \u2713 built response proof: ${(responseProof.proof.length - 2) / 2} bytes (${request.keys.length} key(s) @ ${request.dest}#${request.height})`
+    );
+    await withRetry(
+      this.ctx,
+      () => waitForChallengePeriod(hyperbridge, {
+        height: sourceFinalizedHeight,
+        id: {
+          stateId: parseStateMachineId(request.source).stateId,
+          consensusStateId: sourceChain.config.consensusStateId
+        }
+      }),
+      retry
+    );
+    const message = {
+      kind: "GetRequest",
+      requests: [
+        {
+          source: request.source,
+          dest: request.dest,
+          nonce: request.nonce,
+          from: request.from,
+          timeoutTimestamp: request.timeoutTimestamp,
+          keys: [...request.keys],
+          height: request.height,
+          context: request.context
+        }
+      ],
+      source: sourceProof,
+      response: responseProof,
+      signer: viem.pad("0x")
+    };
+    this.logger.info("  \u2192 submitting GetRequest message (source + response proofs) to Hyperbridge\u2026");
+    const result = await withRetry(this.ctx, () => hyperbridge.submitUnsigned(message), retry);
+    this.logger.info(
+      `  \u2713 delivered GET ${commitment} in Hyperbridge block #${result.blockNumber} (tx ${result.transactionHash})`
+    );
+  }
   /**
    * Snapshot helper: returns the `HYPERBRIDGE_FINALIZED` event with source-chain
    * calldata if prerequisites are met, or `undefined` if we're still waiting
@@ -9896,7 +10250,7 @@ var GetRequestClient = class {
     const finality = await this.queries.queryStateMachineUpdateByHeight({
       statemachineId: config.stateMachineId,
       height: hyperbridgeDelivered.metadata.blockNumber,
-      chain: config.stateMachineId
+      chain: request.source
     });
     if (finality) {
       const proof = await hyperbridge.queryProof(
@@ -9967,14 +10321,19 @@ var GetRequestClient = class {
         ],
         signer: viem.pad("0x")
       });
+      const hyperbridgeFinality = await this.queries.queryStateMachineUpdateByHeight({
+        statemachineId: config.stateMachineId,
+        height: hyperbridgeDelivered.metadata.blockNumber,
+        chain: config.stateMachineId
+      });
+      if (!hyperbridgeFinality) return void 0;
       return {
         status: RequestStatus.HYPERBRIDGE_FINALIZED,
         metadata: {
-          blockHash: hyperbridgeDelivered.metadata.blockHash,
-          blockNumber: Number(consensusResult.provenHeight),
-          transactionHash: hyperbridgeDelivered.metadata.transactionHash,
-          // @ts-ignore
-          timestamp: hyperbridgeDelivered.metadata.timestamp,
+          blockHash: hyperbridgeFinality.blockHash,
+          blockNumber: hyperbridgeFinality.height,
+          transactionHash: hyperbridgeFinality.transactionHash,
+          timestamp: hyperbridgeFinality.timestamp,
           calldata
         }
       };
@@ -9994,12 +10353,44 @@ var GetRequestClient = class {
     const hyperbridge = this.ctx.config.hyperbridge;
     const stateMachineId = this.ctx.config.hyperbridge.config.stateMachineId;
     const neededHeight = BigInt(request.statuses[hyperbridgeDeliveredIndex].metadata.blockNumber);
+    const consensusStateId = this.ctx.config.hyperbridge.config.consensusStateId;
+    const encodeGetResponse = (height, proof2) => sourceChain.encode({
+      kind: "GetResponse",
+      proof: { stateMachine: stateMachineId, consensusStateId, proof: proof2, height },
+      responses: [
+        {
+          get: request,
+          values: request.keys.map((key, index) => ({
+            key,
+            value: response?.values[index] || "0x"
+          }))
+        }
+      ],
+      signer: viem.pad("0x")
+    });
     let finality = await this.queries.queryStateMachineUpdateByHeight({
       statemachineId: stateMachineId,
       height: Number(neededHeight),
-      chain: stateMachineId
+      chain: request.source
     });
-    if (!finality && sourceChain instanceof EvmChain) {
+    if (finality) {
+      const proof2 = await hyperbridge.queryProof(
+        { Responses: [response?.commitment] },
+        request.source,
+        BigInt(finality.height)
+      );
+      return {
+        status: RequestStatus.HYPERBRIDGE_FINALIZED,
+        metadata: {
+          blockHash: finality.blockHash,
+          blockNumber: finality.height,
+          transactionHash: finality.transactionHash,
+          timestamp: finality.timestamp,
+          calldata: encodeGetResponse(BigInt(finality.height), proof2)
+        }
+      };
+    }
+    if (sourceChain instanceof EvmChain) {
       const hyperbridgeSubstrate = hyperbridge;
       const currentEpoch = await sourceChain.currentEpoch();
       const consensusResult = await waitOrAbort(this.ctx, {
@@ -10011,12 +10402,12 @@ var GetRequestClient = class {
         request.source,
         consensusResult.provenHeight
       );
-      const calldata2 = sourceChain.encode({
+      const calldata = sourceChain.encode({
         kind: "BatchConsensusAndGetResponse",
         consensusProofs: consensusResult.proofs,
         proof: {
           stateMachine: stateMachineId,
-          consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
+          consensusStateId,
           proof: proof2,
           height: consensusResult.provenHeight
         },
@@ -10031,20 +10422,7 @@ var GetRequestClient = class {
         ],
         signer: viem.pad("0x")
       });
-      return {
-        status: RequestStatus.HYPERBRIDGE_FINALIZED,
-        metadata: {
-          blockHash: request.statuses[hyperbridgeDeliveredIndex].metadata.blockHash,
-          blockNumber: Number(consensusResult.provenHeight),
-          transactionHash: request.statuses[hyperbridgeDeliveredIndex].metadata.transactionHash,
-          // @ts-ignore
-          timestamp: request.statuses[hyperbridgeDeliveredIndex].metadata.timestamp,
-          calldata: calldata2
-        }
-      };
-    }
-    if (!finality) {
-      finality = await waitOrAbort(this.ctx, {
+      const hyperbridgeFinality = await waitOrAbort(this.ctx, {
         signal,
         promise: () => this.queries.queryStateMachineUpdateByHeight({
           statemachineId: stateMachineId,
@@ -10052,31 +10430,30 @@ var GetRequestClient = class {
           chain: stateMachineId
         })
       });
+      return {
+        status: RequestStatus.HYPERBRIDGE_FINALIZED,
+        metadata: {
+          blockHash: hyperbridgeFinality.blockHash,
+          blockNumber: hyperbridgeFinality.height,
+          transactionHash: hyperbridgeFinality.transactionHash,
+          timestamp: hyperbridgeFinality.timestamp,
+          calldata
+        }
+      };
     }
+    finality = await waitOrAbort(this.ctx, {
+      signal,
+      promise: () => this.queries.queryStateMachineUpdateByHeight({
+        statemachineId: stateMachineId,
+        height: Number(neededHeight),
+        chain: request.source
+      })
+    });
     const proof = await hyperbridge.queryProof(
       { Responses: [response?.commitment] },
       request.source,
       BigInt(finality.height)
     );
-    const calldata = sourceChain.encode({
-      kind: "GetResponse",
-      proof: {
-        stateMachine: stateMachineId,
-        consensusStateId: this.ctx.config.hyperbridge.config.consensusStateId,
-        proof,
-        height: BigInt(finality.height)
-      },
-      responses: [
-        {
-          get: request,
-          values: request.keys.map((key, index) => ({
-            key,
-            value: response?.values[index] || "0x"
-          }))
-        }
-      ],
-      signer: viem.pad("0x")
-    });
     return {
       status: RequestStatus.HYPERBRIDGE_FINALIZED,
       metadata: {
@@ -10084,7 +10461,7 @@ var GetRequestClient = class {
         blockNumber: finality.height,
         transactionHash: finality.transactionHash,
         timestamp: finality.timestamp,
-        calldata
+        calldata: encodeGetResponse(BigInt(finality.height), proof)
       }
     };
   }
@@ -10587,7 +10964,7 @@ var PostRequestClient = class {
     const finality = await this.queries.queryStateMachineUpdateByHeight({
       statemachineId: config.stateMachineId,
       height: hyperbridgeDelivered.metadata.blockNumber,
-      chain: config.stateMachineId
+      chain: request.dest
     });
     if (finality) {
       const proof = await hyperbridge.queryProof(
@@ -10642,14 +11019,19 @@ var PostRequestClient = class {
         requests: [request],
         signer: viem.pad("0x")
       });
+      const hyperbridgeFinality = await this.queries.queryStateMachineUpdateByHeight({
+        statemachineId: config.stateMachineId,
+        height: hyperbridgeDelivered.metadata.blockNumber,
+        chain: config.stateMachineId
+      });
+      if (!hyperbridgeFinality) return void 0;
       return {
         status: RequestStatus.HYPERBRIDGE_FINALIZED,
         metadata: {
-          blockHash: hyperbridgeDelivered.metadata.blockHash,
-          blockNumber: Number(consensusResult.provenHeight),
-          transactionHash: hyperbridgeDelivered.metadata.transactionHash,
-          // @ts-ignore
-          timestamp: hyperbridgeDelivered.metadata.timestamp,
+          blockHash: hyperbridgeFinality.blockHash,
+          blockNumber: hyperbridgeFinality.height,
+          transactionHash: hyperbridgeFinality.transactionHash,
+          timestamp: hyperbridgeFinality.timestamp,
           calldata
         }
       };
@@ -10672,7 +11054,7 @@ var PostRequestClient = class {
     let finality = await this.queries.queryStateMachineUpdateByHeight({
       statemachineId: stateMachineId,
       height: Number(neededHeight),
-      chain: stateMachineId
+      chain: request.dest
     });
     if (!finality && destChain instanceof EvmChain) {
       const hyperbridgeSubstrate = hyperbridge;
@@ -10700,14 +11082,21 @@ var PostRequestClient = class {
         requests: [request],
         signer: viem.pad("0x")
       });
+      const hyperbridgeFinality = await waitOrAbort(this.ctx, {
+        signal,
+        promise: () => this.queries.queryStateMachineUpdateByHeight({
+          statemachineId: stateMachineId,
+          height: Number(neededHeight),
+          chain: stateMachineId
+        })
+      });
       return {
         status: RequestStatus.HYPERBRIDGE_FINALIZED,
         metadata: {
-          blockHash: request.statuses[hyperbridgeDeliveredIndex].metadata.blockHash,
-          blockNumber: Number(consensusResult.provenHeight),
-          transactionHash: request.statuses[hyperbridgeDeliveredIndex].metadata.transactionHash,
-          // @ts-ignore
-          timestamp: request.statuses[hyperbridgeDeliveredIndex].metadata.timestamp,
+          blockHash: hyperbridgeFinality.blockHash,
+          blockNumber: hyperbridgeFinality.height,
+          transactionHash: hyperbridgeFinality.transactionHash,
+          timestamp: hyperbridgeFinality.timestamp,
           calldata: calldata2
         }
       };
@@ -10718,7 +11107,7 @@ var PostRequestClient = class {
         promise: () => this.queries.queryStateMachineUpdateByHeight({
           statemachineId: stateMachineId,
           height: Number(neededHeight),
-          chain: stateMachineId
+          chain: request.dest
         })
       });
     }
@@ -14613,16 +15002,6 @@ var CryptoUtils = class _CryptoUtils {
     }
   }
 };
-var FEE_TOKEN_CACHE_TTL_MS = 5 * 60 * 1e3;
-async function getFeeToken(ctx, chainId, chain) {
-  const cached = ctx.feeTokenCache.get(chainId);
-  if (cached && Date.now() - cached.cachedAt < FEE_TOKEN_CACHE_TTL_MS) {
-    return cached;
-  }
-  const fresh = await chain.getFeeTokenWithDecimals();
-  ctx.feeTokenCache.set(chainId, { ...fresh, cachedAt: Date.now() });
-  return fresh;
-}
 function encodeERC7821ExecuteBatch(calls) {
   const executionData = viem.encodeAbiParameters(
     [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
@@ -14634,6 +15013,36 @@ function encodeERC7821ExecuteBatch(calls) {
     args: [ERC7821_BATCH_MODE, executionData]
   });
 }
+function decodeERC7821ExecuteBatch(callData) {
+  try {
+    const decoded = viem.decodeFunctionData({ abi: erc7281_default.ABI, data: callData });
+    if (decoded.functionName !== "execute" || !decoded.args || decoded.args.length < 2) return null;
+    const executionData = decoded.args[1];
+    const [calls] = viem.decodeAbiParameters(
+      [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
+      executionData
+    );
+    return calls.map((call) => ({
+      target: call.target,
+      value: call.value,
+      data: call.data
+    }));
+  } catch {
+    return null;
+  }
+}
+
+// src/protocols/intents/utils.ts
+var FEE_TOKEN_CACHE_TTL_MS = 5 * 60 * 1e3;
+async function getFeeToken(ctx, chainId, chain) {
+  const cached = ctx.feeTokenCache.get(chainId);
+  if (cached && Date.now() - cached.cachedAt < FEE_TOKEN_CACHE_TTL_MS) {
+    return cached;
+  }
+  const fresh = await chain.getFeeTokenWithDecimals();
+  ctx.feeTokenCache.set(chainId, { ...fresh, cachedAt: Date.now() });
+  return fresh;
+}
 async function fetchSourceProof(commitment, source, sourceStateMachine, sourceConsensusStateId, sourceHeight) {
   const { slot1, slot2 } = requestCommitmentKey(commitment);
   const proofHex = await source.queryStateProof(sourceHeight, [slot1, slot2]);
@@ -18513,6 +18922,11 @@ var HyperFungibleTokenABI = [
             name: "context",
             type: "bytes",
             internalType: "bytes"
+          },
+          {
+            name: "payer",
+            type: "address",
+            internalType: "address"
           }
         ]
       }
@@ -19634,6 +20048,11 @@ var WrappedHyperFungibleTokenABI = [
             name: "context",
             type: "bytes",
             internalType: "bytes"
+          },
+          {
+            name: "payer",
+            type: "address",
+            internalType: "address"
           }
         ]
       }
@@ -21471,6 +21890,11 @@ var ABI8 = [
             internalType: "bytes",
             name: "context",
             type: "bytes"
+          },
+          {
+            internalType: "address",
+            name: "payer",
+            type: "address"
           }
         ],
         internalType: "struct DispatchGet",
@@ -21739,6 +22163,11 @@ var ABI8 = [
             internalType: "bytes",
             name: "context",
             type: "bytes"
+          },
+          {
+            internalType: "address",
+            name: "payer",
+            type: "address"
           }
         ],
         internalType: "struct DispatchGet",
@@ -22168,6 +22597,7 @@ exports.convertStateMachineEnumToString = convertStateMachineEnumToString;
 exports.convertStateMachineIdToEnum = convertStateMachineIdToEnum;
 exports.createEvmChain = createEvmChain;
 exports.createQueryClient = createQueryClient;
+exports.decodeERC7821ExecuteBatch = decodeERC7821ExecuteBatch;
 exports.decodeUserOpScale = decodeUserOpScale;
 exports.encodeERC7821ExecuteBatch = encodeERC7821ExecuteBatch;
 exports.encodeISMPMessage = encodeISMPMessage;