@hyperbridge/sdk 2.3.0 → 2.3.1

package/dist/node/index.js

@@ -2100,7 +2100,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" },
@@ -2167,7 +2167,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" },
@@ -6392,28 +6392,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(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(flatten(proofs.map((proof) => proof.accountProof))));
+    const storageProof = contracts.map(([contract], i) => {
+      const flattened = Array.from(new Set(flatten(proofs[i].storageProof.map((item) => item.proof))));
+      return [
+        Array.from(hexToBytes(contract)),
+        flattened.map((item) => Array.from(hexToBytes(item)))
+      ];
+    });
     const encoded = EvmStateProof.enc({
-      contractProof: proof.accountProof.map((item) => Array.from(hexToBytes(item))),
-      storageProof: [
-        [Array.from(hexToBytes(config.address)), flattenedProof.map((item) => Array.from(hexToBytes(item)))]
-      ]
+      contractProof: contractProof.map((item) => Array.from(hexToBytes(item))),
+      storageProof
     });
     return toHex(encoded);
   }
@@ -7135,6 +7167,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 = hexToBytes(key);
+    return 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 = 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: toHex(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.
@@ -7762,6 +7837,23 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
         } 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(),
@@ -7821,10 +7913,19 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     }
   }
   /**
-   * Retracts a previous bid and places a new one in a single transaction via utility.batch.
-   * The retraction runs first, so the old deposit is reclaimed even if the new bid then fails
-   * (batch is non-atomic — a failing call interrupts the batch without reverting the calls that
-   * already succeeded, unlike batchAll which would roll the retraction back too).
+   * 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)
@@ -7834,8 +7935,8 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   async submitBidWithRetraction(retractCommitment, bidCommitment, userOp) {
     try {
       const batch = this.api.tx.utility.batch([
-        this.api.tx.intentsCoprocessor.retractBid(retractCommitment),
-        this.api.tx.intentsCoprocessor.placeBid(bidCommitment, userOp)
+        this.api.tx.intentsCoprocessor.placeBid(bidCommitment, userOp),
+        this.api.tx.intentsCoprocessor.retractBid(retractCommitment)
       ]);
       return await this.signAndSendExtrinsic(batch);
     } catch (error) {
@@ -9941,6 +10042,7 @@ var GetRequestClient = class {
     const latestMetadata = request.statuses[request.statuses.length - 1];
     status = maxBy([status, latestMetadata.status], (item) => REQUEST_STATUS_WEIGHTS[item]);
     if (!status) return;
+    let sourceFinalizedHeight;
     while (true) {
       switch (status) {
         case RequestStatus.SOURCE: {
@@ -9952,6 +10054,7 @@ var GetRequestClient = class {
               chain: this.ctx.config.hyperbridge.config.stateMachineId
             })
           });
+          sourceFinalizedHeight = BigInt(sourceUpdate.height);
           yield {
             status: RequestStatus.SOURCE_FINALIZED,
             metadata: {
@@ -9965,6 +10068,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),
@@ -9985,7 +10097,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;
@@ -10015,6 +10130,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: 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
@@ -10028,7 +10239,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(
@@ -10099,14 +10310,19 @@ var GetRequestClient = class {
         ],
         signer: 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
         }
       };
@@ -10126,12 +10342,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: 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, {
@@ -10143,12 +10391,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
         },
@@ -10163,20 +10411,7 @@ var GetRequestClient = class {
         ],
         signer: 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,
@@ -10184,31 +10419,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: pad("0x")
-    });
     return {
       status: RequestStatus.HYPERBRIDGE_FINALIZED,
       metadata: {
@@ -10216,7 +10450,7 @@ var GetRequestClient = class {
         blockNumber: finality.height,
         transactionHash: finality.transactionHash,
         timestamp: finality.timestamp,
-        calldata
+        calldata: encodeGetResponse(BigInt(finality.height), proof)
       }
     };
   }
@@ -10719,7 +10953,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(
@@ -10774,14 +11008,19 @@ var PostRequestClient = class {
         requests: [request],
         signer: 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
         }
       };
@@ -10804,7 +11043,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;
@@ -10832,14 +11071,21 @@ var PostRequestClient = class {
         requests: [request],
         signer: 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
         }
       };
@@ -10850,7 +11096,7 @@ var PostRequestClient = class {
         promise: () => this.queries.queryStateMachineUpdateByHeight({
           statemachineId: stateMachineId,
           height: Number(neededHeight),
-          chain: stateMachineId
+          chain: request.dest
         })
       });
     }