@hyperbridge/sdk 2.3.0 → 2.3.1

package/dist/browser/index.d.ts

@@ -57,9 +57,9 @@ declare const _default: {
                     readonly name: "nonce";
                     readonly type: "uint64";
                 }, {
-                    readonly internalType: "address";
+                    readonly internalType: "bytes";
                     readonly name: "from";
-                    readonly type: "address";
+                    readonly type: "bytes";
                 }, {
                     readonly internalType: "uint64";
                     readonly name: "timeoutTimestamp";
@@ -154,9 +154,9 @@ declare const _default: {
                             readonly name: "nonce";
                             readonly type: "uint64";
                         }, {
-                            readonly internalType: "address";
+                            readonly internalType: "bytes";
                             readonly name: "from";
-                            readonly type: "address";
+                            readonly type: "bytes";
                         }, {
                             readonly internalType: "uint64";
                             readonly name: "timeoutTimestamp";
@@ -1142,9 +1142,16 @@ declare class EvmChain implements IChain {
     queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
     /**
      * 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.
      */
     queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
@@ -1638,6 +1645,30 @@ declare class SubstrateChain implements IChain {
      * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
      */
     queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
+    /**
+     * 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: HexString): HexString;
+    /**
+     * 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.
+     */
+    queryResponseReceipt(commitment: HexString): Promise<HexString | undefined>;
+    /**
+     * 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.
+     */
+    queryStateMachineCommitment(height: StateMachineHeight): Promise<HexString | undefined>;
     /**
      * Returns the current timestamp of the chain.
      * @returns {Promise<bigint>} The current timestamp.
@@ -1911,10 +1942,19 @@ declare class IntentsCoprocessor {
      */
     retractBid(commitment: HexString): Promise<BidSubmissionResult>;
     /**
-     * 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)
@@ -3748,6 +3788,20 @@ declare class GetRequestClient {
      */
     getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
     private streamInternal;
+    /**
+     * 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.
+     */
+    private deliverToHyperbridge;
     /**
      * Snapshot helper: returns the `HYPERBRIDGE_FINALIZED` event with source-chain
      * calldata if prerequisites are met, or `undefined` if we're still waiting