@hyperbridge/sdk 1.3.11 → 1.3.13

package/dist/node/index.d.ts

@@ -1919,6 +1919,7 @@ interface SubstrateChainParams {
 declare class SubstrateChain implements IChain {
     private readonly params;
     api?: ApiPromise;
+    private rpcClient;
     constructor(params: SubstrateChainParams);
     connect(): Promise<void>;
     /**
@@ -2019,6 +2020,17 @@ declare class SubstrateChain implements IChain {
  * @returns {IStateMachine} The corresponding enum value.
  */
 declare function convertStateMachineIdToEnum(id: string): IStateMachine;
+/**
+ * Converts a stateId object back to the state_id format used by the RPC.
+ * @param stateId - The stateId object from StateMachineIdParams
+ * @returns The string representation like "EVM-11155111" or "SUBSTRATE-cere"
+ */
+declare function convertStateIdToStateMachineId(stateId: {
+    Evm?: number;
+    Substrate?: HexString;
+    Polkadot?: number;
+    Kusama?: number;
+}): string;
 declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
 
 /**
@@ -2575,9 +2587,6 @@ declare function queryGetRequest(params: {
 declare class IntentGateway {
     readonly source: EvmChain;
     readonly dest: EvmChain;
-    private destStateproofCache;
-    getCachedProof(id: HexString): IProof | undefined;
-    clearCachedProof(id: HexString): void;
     /**
      * Creates a new IntentGateway instance for cross-chain operations.
      * @param source - The source EVM chain
@@ -2663,7 +2672,8 @@ declare class IntentGateway {
      * @returns True if the order has been filled, false otherwise
      */
     isOrderFilled(order: Order): Promise<boolean>;
-    cancelOrder(order: Order, hyperbridgeConfig: IHyperbridgeConfig, indexerClient: IndexerClient): AsyncGenerator<{
+    submitAndConfirmReceipt(hyperbridge: SubstrateChain, commitment: HexString, message: IGetRequestMessage): Promise<void>;
+    cancelOrder(order: Order, hyperbridgeConfig: IHyperbridgeConfig, indexerClient: IndexerClient, storedData?: StoredCancellationData): AsyncGenerator<{
         status: RequestStatus["SOURCE"];
         metadata: {
             blockHash: string;
@@ -2747,25 +2757,39 @@ declare class IntentGateway {
     } | {
         status: string;
         data: {
+            proof: IProof;
+            failedHeight?: undefined;
+            error?: undefined;
+            deadline?: undefined;
+            height?: undefined;
+        };
+    } | {
+        status: string;
+        data: {
+            lastFailedHeight?: bigint | undefined;
             currentHeight: bigint;
             deadline: bigint;
-            height?: undefined;
             proof?: undefined;
+            failedHeight?: undefined;
+            error?: undefined;
+            height?: undefined;
         };
     } | {
         status: string;
         data: {
-            height: bigint;
-            currentHeight?: undefined;
-            deadline?: undefined;
+            failedHeight: bigint;
+            error: string;
+            deadline: bigint;
             proof?: undefined;
+            height?: undefined;
         };
     } | {
         status: string;
         data: {
             proof: `0x${string}`;
             height: bigint;
-            currentHeight?: undefined;
+            failedHeight?: undefined;
+            error?: undefined;
             deadline?: undefined;
         };
     } | {
@@ -2773,8 +2797,8 @@ declare class IntentGateway {
         data?: undefined;
     } | {
         status: string;
-        data: `0x${string}`;
-    }, void, IGetRequest | undefined>;
+        data: IProof;
+    }, void, IGetRequest>;
     /**
      * Returns the tick spacing for a given fee tier in Uniswap V4
      * @param fee - The fee tier in basis points
@@ -2790,6 +2814,11 @@ declare class IntentGateway {
      */
     private isWithinThreshold;
 }
+interface StoredCancellationData {
+    destIProof?: IProof;
+    getRequest?: IGetRequest;
+    sourceIProof?: IProof;
+}
 
 type HyperbridgeTxEvents = {
     kind: "Ready";
@@ -3073,4 +3102,4 @@ declare const coingeckoIds: {
     "EVM-130": string;
 };
 
-export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BlockMetadata, type CancelOptions, type ChainConfig, ChainConfigService, type ChainId, Chains, type ClientConfig, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DispatchGet, type DispatchPost, ERC20Method, type EstimateGasCallData, EvmChain, type EvmChainParams, type ExecutionResult, type FillOptions, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString, type HostParams, HyperClientStatus, type HyperbridgeTxEvents, type IChain, type IConfig, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, IndexerClient, type IndexerQueryClient, IntentGateway, type IntentGatewayParams, type IsmpRequest, type NewDeployment, type Order, type OrderResponse, OrderStatus, type OrderStatusMetadata, type OrderWithStatus, type Params, type PaymentInfo, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type RetryConfig, STATE_COMMITMENTS_SLOT, type StateMachineHeight, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, SubstrateChain, type SubstrateChainParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type TokenRegistry, type TokenRegistryResponse, WrappedNativeDecimals, type XcmGatewayParams, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, coingeckoIds, consensusStateIds, constructRedeemEscrowRequestBody, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, orderCommitment, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BlockMetadata, type CancelOptions, type ChainConfig, ChainConfigService, type ChainId, Chains, type ClientConfig, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DispatchGet, type DispatchPost, ERC20Method, type EstimateGasCallData, EvmChain, type EvmChainParams, type ExecutionResult, type FillOptions, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString, type HostParams, HyperClientStatus, type HyperbridgeTxEvents, type IChain, type IConfig, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, IndexerClient, type IndexerQueryClient, IntentGateway, type IntentGatewayParams, type IsmpRequest, type NewDeployment, type Order, type OrderResponse, OrderStatus, type OrderStatusMetadata, type OrderWithStatus, type Params, type PaymentInfo, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type RetryConfig, STATE_COMMITMENTS_SLOT, type StateMachineHeight, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, SubstrateChain, type SubstrateChainParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type TokenRegistry, type TokenRegistryResponse, WrappedNativeDecimals, type XcmGatewayParams, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, coingeckoIds, consensusStateIds, constructRedeemEscrowRequestBody, convertStateIdToStateMachineId, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, orderCommitment, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };

package/dist/node/index.js

@@ -10,7 +10,6 @@ import { hasWindow, isNode, env } from 'std-env';
 import { Vector, u8, Struct, Tuple, Enum, _void, u64, u32, Option, bool, u128, Bytes } from 'scale-ts';
 import { match } from 'ts-pattern';
 import { WsProvider, ApiPromise } from '@polkadot/api';
-import { RpcWebSocketClient } from 'rpc-websocket-client';
 import { keccakAsU8a, decodeAddress, keccakAsHex, xxhashAsU8a } from '@polkadot/util-crypto';
 import { GraphQLClient } from 'graphql-request';
 import { Decimal } from 'decimal.js';
@@ -4553,6 +4552,14 @@ function adjustFeeDecimals(feeInFeeToken, fromDecimals, toDecimals) {
     return (feeInFeeToken + scaleFactor - 1n) / scaleFactor;
   }
 }
+function replaceWebsocketWithHttp(url) {
+  if (url.startsWith("ws://")) {
+    return url.replace("ws://", "http://");
+  } else if (url.startsWith("wss://")) {
+    return url.replace("wss://", "https://");
+  }
+  return url;
+}
 
 // src/utils/exceptions.ts
 var AbortSignalInternal = class _AbortSignalInternal extends Error {
@@ -5062,14 +5069,52 @@ function deriveSecondLevelSlot(key, firstLevelSlot) {
   const combined = new Uint8Array([...keyBytes, ...slotBytes]);
   return keccak256(combined);
 }
+var HttpRpcClient = class {
+  constructor(url) {
+    this.url = url;
+  }
+  /**
+   * Make an RPC call over HTTP
+   * @param method - The RPC method name
+   * @param params - The parameters for the RPC call
+   * @returns Promise resolving to the RPC response
+   */
+  async call(method, params = []) {
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method,
+      params
+    });
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(`RPC error: ${result.error.message}`);
+    }
+    return result.result;
+  }
+};
 var SubstrateChain = class {
   constructor(params) {
     this.params = params;
+    const url = this.params.ws;
+    const httpUrl = replaceWebsocketWithHttp(url);
+    this.rpcClient = new HttpRpcClient(httpUrl);
   }
   /*
    * api: The Polkadot API instance for the Substrate chain.
    */
   api;
+  rpcClient;
   /*
    * connect: Connects to the Substrate chain using the provided WebSocket URL.
    */
@@ -5129,9 +5174,7 @@ var SubstrateChain = class {
   async queryRequestCommitment(commitment) {
     const prefix = toHex(":child_storage:default:ISMP");
     const key = this.requestCommitmentKey(commitment);
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
-    const item = await rpc.call("childstate_getStorage", [prefix, key]);
+    const item = await this.rpcClient.call("childstate_getStorage", [prefix, key]);
     return item;
   }
   /**
@@ -5142,9 +5185,7 @@ var SubstrateChain = class {
   async queryRequestReceipt(commitment) {
     const prefix = toHex(":child_storage:default:ISMP");
     const key = this.requestReceiptKey(commitment);
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
-    const item = await rpc.call("childstate_getStorage", [prefix, key]);
+    const item = await this.rpcClient.call("childstate_getStorage", [prefix, key]);
     return item;
   }
   /**
@@ -5164,15 +5205,13 @@ var SubstrateChain = class {
    * @returns {Promise<HexString>} The proof.
    */
   async queryProof(message, counterparty, at) {
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
     if (isEvmChain(counterparty)) {
-      const proof = await rpc.call("mmr_queryProof", [Number(at), message]);
+      const proof = await this.rpcClient.call("mmr_queryProof", [Number(at), message]);
       return toHex(proof.proof);
     }
     if (isSubstrateChain(counterparty)) {
       const childTrieKeys = "Requests" in message ? message.Requests.map(requestCommitmentStorageKey) : message.Responses.map(responseCommitmentStorageKey);
-      const proof = await rpc.call("ismp_queryChildTrieProof", [Number(at), childTrieKeys]);
+      const proof = await this.rpcClient.call("ismp_queryChildTrieProof", [Number(at), childTrieKeys]);
       const basicProof = BasicProof.dec(toHex(proof.proof));
       const encoded = SubstrateStateProof.enc({
         tag: "OverlayProof",
@@ -5236,10 +5275,8 @@ var SubstrateChain = class {
    * @returns The state proof as a hexadecimal string.
    */
   async queryStateProof(at, keys) {
-    const rpc = new RpcWebSocketClient();
-    await rpc.connect(this.params.ws);
     const encodedKeys = keys.map((key) => Array.from(hexToBytes(key)));
-    const proof = await rpc.call("ismp_queryChildTrieProof", [Number(at), encodedKeys]);
+    const proof = await this.rpcClient.call("ismp_queryChildTrieProof", [Number(at), encodedKeys]);
     const basicProof = BasicProof.dec(toHex(proof.proof));
     const encoded = SubstrateStateProof.enc({
       tag: "OverlayProof",
@@ -5259,9 +5296,16 @@ var SubstrateChain = class {
    * @returns {Promise<bigint>} The latest state machine height.
    */
   async latestStateMachineHeight(stateMachineId) {
-    if (!this.api) throw new Error("API not initialized");
-    const latestHeight = await this.api.query.ismp.latestStateMachineHeight(stateMachineId);
-    return BigInt(latestHeight.toString());
+    const state_id = convertStateIdToStateMachineId(stateMachineId.stateId);
+    const consensusStateIdToBytes = hexToBytes(stateMachineId.consensusStateId);
+    const decoder = new TextDecoder("utf-8");
+    const decodedConsensusStateId = decoder.decode(consensusStateIdToBytes);
+    const payload = {
+      state_id,
+      consensus_state_id: decodedConsensusStateId
+    };
+    const latestHeight = await this.rpcClient.call("ismp_queryStateMachineLatestHeight", [payload]);
+    return BigInt(latestHeight);
   }
   /**
    * Get the state machine update time for a given state machine height.
@@ -5269,9 +5313,20 @@ var SubstrateChain = class {
    * @returns {Promise<bigint>} The statemachine update time in seconds.
    */
   async stateMachineUpdateTime(stateMachineHeight) {
-    if (!this.api) throw new Error("API not initialized");
-    const updateTime = await this.api.query.ismp.stateMachineUpdateTime(stateMachineHeight);
-    return BigInt(updateTime.toString());
+    const state_id = convertStateIdToStateMachineId(stateMachineHeight.id.stateId);
+    const consensusStateIdToBytes = hexToBytes(stateMachineHeight.id.consensusStateId);
+    const decoder = new TextDecoder("utf-8");
+    const decodedConsensusStateId = decoder.decode(consensusStateIdToBytes);
+    const stateMachineId = {
+      state_id,
+      consensus_state_id: decodedConsensusStateId
+    };
+    const payload = {
+      id: stateMachineId,
+      height: Number(stateMachineHeight.height)
+    };
+    const updateTime = await this.rpcClient.call("ismp_queryStateMachineUpdateTime", [payload]);
+    return BigInt(updateTime);
   }
   /**
    * Get the challenge period for a given state machine id.
@@ -5279,9 +5334,16 @@ var SubstrateChain = class {
    * @returns {Promise<bigint>} The challenge period in seconds.
    */
   async challengePeriod(stateMachineId) {
-    if (!this.api) throw new Error("API not initialized");
-    const challengePeriod = await this.api.query.ismp.challengePeriod(stateMachineId);
-    return BigInt(challengePeriod.toString());
+    const state_id = convertStateIdToStateMachineId(stateMachineId.stateId);
+    const consensusStateIdToBytes = hexToBytes(stateMachineId.consensusStateId);
+    const decoder = new TextDecoder("utf-8");
+    const decodedConsensusStateId = decoder.decode(consensusStateIdToBytes);
+    const payload = {
+      state_id,
+      consensus_state_id: decodedConsensusStateId
+    };
+    const challengePeriod = await this.rpcClient.call("ismp_queryChallengePeriod", [payload]);
+    return BigInt(challengePeriod);
   }
   /**
    * Encode an ISMP calldata for a substrate chain.
@@ -5331,6 +5393,24 @@ function convertStateMachineIdToEnum(id) {
   }
   return { tag, value };
 }
+function convertStateIdToStateMachineId(stateId) {
+  switch (true) {
+    case stateId.Evm !== void 0:
+      return `EVM-${stateId.Evm}`;
+    case stateId.Polkadot !== void 0:
+      return `POLKADOT-${stateId.Polkadot}`;
+    case stateId.Kusama !== void 0:
+      return `KUSAMA-${stateId.Kusama}`;
+    case stateId.Substrate !== void 0: {
+      const bytes = hexToBytes(stateId.Substrate);
+      const decoder = new TextDecoder("utf-8");
+      const decoded = decoder.decode(bytes);
+      return `SUBSTRATE-${decoded}`;
+    }
+    default:
+      throw new Error("Unsupported stateId variant");
+  }
+}
 function convertIPostRequestToCodec(request) {
   return {
     tag: "Post",
@@ -11600,13 +11680,6 @@ var IntentGateway = class {
     this.source = source;
     this.dest = dest;
   }
-  destStateproofCache = /* @__PURE__ */ new Map();
-  getCachedProof(id) {
-    return this.destStateproofCache.get(id);
-  }
-  clearCachedProof(id) {
-    this.destStateproofCache.delete(id);
-  }
   /**
    * Estimates the total cost required to fill an order, including gas fees, relayer fees,
    * protocol fees, and swap operations.
@@ -12215,118 +12288,128 @@ var IntentGateway = class {
     });
     return filledStatus !== "0x0000000000000000000000000000000000000000000000000000000000000000";
   }
-  async *cancelOrder(order, hyperbridgeConfig, indexerClient) {
-    const hyperbridge = await getChain({
-      ...hyperbridgeConfig,
-      hasher: "Keccak"
-    });
+  async submitAndConfirmReceipt(hyperbridge, commitment, message) {
+    let storageValue = await hyperbridge.queryRequestReceipt(commitment);
+    if (!storageValue) {
+      console.log("No receipt found. Attempting to submit...");
+      try {
+        await hyperbridge.submitUnsigned(message);
+      } catch {
+        console.warn("Submission failed. Awaiting network confirmation...");
+      }
+      console.log("Waiting for network state update...");
+      await sleep(3e4);
+      storageValue = await retryPromise(
+        async () => {
+          const value = await hyperbridge.queryRequestReceipt(commitment);
+          if (!value) throw new Error("Receipt not found");
+          return value;
+        },
+        { maxRetries: 5, backoffMs: 5e3, logMessage: "Checking for receipt" }
+      );
+    }
+    console.log("Hyperbridge Receipt confirmed.");
+  }
+  async *cancelOrder(order, hyperbridgeConfig, indexerClient, storedData) {
+    const hyperbridge = await getChain({ ...hyperbridgeConfig, hasher: "Keccak" });
     const sourceStateMachine = hexToString$1(order.sourceChain);
     const destStateMachine = hexToString$1(order.destChain);
     const sourceConsensusStateId = this.source.config.getConsensusStateId(sourceStateMachine);
     const destConsensusStateId = this.dest.config.getConsensusStateId(destStateMachine);
-    let latestHeight = 0n;
-    while (latestHeight <= order.deadline) {
-      const { stateId } = parseStateMachineId(destStateMachine);
-      latestHeight = await hyperbridge.latestStateMachineHeight({
-        stateId,
-        consensusStateId: destConsensusStateId
-      });
-      yield {
-        status: "AWAITING_DESTINATION_FINALIZED",
-        data: { currentHeight: latestHeight, deadline: order.deadline }
-      };
-      if (latestHeight <= order.deadline) {
-        await sleep(1e4);
+    let destIProof;
+    if (storedData?.destIProof) {
+      destIProof = storedData.destIProof;
+      yield { status: "DESTINATION_FINALIZED", data: { proof: destIProof } };
+    } else {
+      let latestHeight = 0n;
+      let lastFailedHeight = null;
+      let proofHex = null;
+      while (!proofHex) {
+        latestHeight = await retryPromise(
+          () => hyperbridge.latestStateMachineHeight({
+            stateId: parseStateMachineId(destStateMachine).stateId,
+            consensusStateId: destConsensusStateId
+          }),
+          { maxRetries: 5, backoffMs: 500, logMessage: "Failed to fetch latest state machine height" }
+        );
+        const shouldFetchProof = lastFailedHeight === null ? latestHeight > order.deadline : latestHeight > lastFailedHeight;
+        if (!shouldFetchProof) {
+          yield {
+            status: "AWAITING_DESTINATION_FINALIZED",
+            data: {
+              currentHeight: latestHeight,
+              deadline: order.deadline,
+              ...lastFailedHeight && { lastFailedHeight }
+            }
+          };
+          await sleep(1e4);
+          continue;
+        }
+        try {
+          const intentGatewayAddress = this.dest.config.getIntentGatewayAddress(destStateMachine);
+          const orderId = orderCommitment(order);
+          const slotHash = await this.dest.client.readContract({
+            abi: IntentGateway_default.ABI,
+            address: intentGatewayAddress,
+            functionName: "calculateCommitmentSlotHash",
+            args: [orderId]
+          });
+          proofHex = await this.dest.queryStateProof(latestHeight, [slotHash], intentGatewayAddress);
+        } catch (error) {
+          lastFailedHeight = latestHeight;
+          yield {
+            status: "PROOF_FETCH_FAILED",
+            data: {
+              failedHeight: latestHeight,
+              error: error instanceof Error ? error.message : String(error),
+              deadline: order.deadline
+            }
+          };
+          await sleep(1e4);
+        }
       }
+      destIProof = {
+        consensusStateId: destConsensusStateId,
+        height: latestHeight,
+        proof: proofHex,
+        stateMachine: destStateMachine
+      };
+      yield { status: "DESTINATION_FINALIZED", data: { proof: destIProof.proof, height: destIProof.height } };
     }
-    yield { status: "DESTINATION_FINALIZED", data: { height: latestHeight } };
-    const intentGatewayAddress = this.dest.config.getIntentGatewayAddress(destStateMachine);
-    const orderId = orderCommitment(order);
-    const slotHash = await this.dest.client.readContract({
-      abi: IntentGateway_default.ABI,
-      address: intentGatewayAddress,
-      functionName: "calculateCommitmentSlotHash",
-      args: [orderId]
-    });
-    const proof = await this.dest.queryStateProof(latestHeight, [slotHash], intentGatewayAddress);
-    const destIProof = {
-      consensusStateId: destConsensusStateId,
-      height: latestHeight,
-      proof,
-      stateMachine: destStateMachine
-    };
-    this.destStateproofCache.set(order.id, destIProof);
-    yield { status: "STATE_PROOF_RECEIVED", data: { proof, height: latestHeight } };
-    const getRequest = yield { status: "AWAITING_GET_REQUEST" };
-    if (!getRequest) {
-      throw new Error("[Cancel Order]: Get Request not provided");
-    }
-    const commitment = getRequestCommitment({
-      ...getRequest,
-      keys: [...getRequest.keys]
-    });
-    const statusStream = indexerClient.getRequestStatusStream(commitment);
-    for await (const statusUpdate of statusStream) {
+    const getRequest = storedData?.getRequest ?? (yield { status: "AWAITING_GET_REQUEST" });
+    if (!getRequest) throw new Error("[Cancel Order]: Get Request not provided");
+    const commitment = getRequestCommitment({ ...getRequest, keys: [...getRequest.keys] });
+    const sourceStatusStream = indexerClient.getRequestStatusStream(commitment);
+    for await (const statusUpdate of sourceStatusStream) {
       if (statusUpdate.status === RequestStatus.SOURCE_FINALIZED) {
-        const sourceHeight = statusUpdate.metadata.blockNumber;
-        const proof2 = await this.source.queryProof(
+        const sourceHeight = BigInt(statusUpdate.metadata.blockNumber);
+        const proof = await this.source.queryProof(
           { Requests: [commitment] },
           hyperbridgeConfig.stateMachineId,
-          BigInt(sourceHeight)
+          sourceHeight
         );
-        yield { status: "SOURCE_PROOF_RECIEVED", data: proof2 };
-        const { stateId } = parseStateMachineId(sourceStateMachine);
         const sourceIProof = {
-          height: BigInt(sourceHeight),
+          height: sourceHeight,
           stateMachine: sourceStateMachine,
           consensusStateId: sourceConsensusStateId,
-          proof: proof2
+          proof
         };
+        yield { status: "SOURCE_PROOF_RECEIVED", data: sourceIProof };
         const getRequestMessage = {
           kind: "GetRequest",
           requests: [getRequest],
           source: sourceIProof,
-          response: this.getCachedProof(order.id),
+          response: destIProof,
           signer: pad("0x")
         };
         await waitForChallengePeriod(hyperbridge, {
-          height: BigInt(sourceHeight),
+          height: sourceHeight,
           id: {
-            stateId,
+            stateId: parseStateMachineId(sourceStateMachine).stateId,
             consensusStateId: sourceConsensusStateId
           }
         });
-        const receiptKey = hyperbridge.requestReceiptKey(commitment);
-        const { api } = hyperbridge;
-        if (!api) {
-          throw new Error("Hyperbridge API is not available");
-        }
-        let storageValue = await api.rpc.childstate.getStorage(":child_storage:default:ISMP", receiptKey);
-        if (storageValue.isNone) {
-          console.log("No receipt found. Attempting to submit...");
-          try {
-            await hyperbridge.submitUnsigned(getRequestMessage);
-          } catch {
-            console.warn("Submission failed. Awaiting network confirmation...");
-          }
-          console.log("Waiting for network state update...");
-          await sleep(3e4);
-          storageValue = await retryPromise(
-            async () => {
-              const value = await api.rpc.childstate.getStorage(":child_storage:default:ISMP", receiptKey);
-              if (value.isNone) {
-                throw new Error("Receipt not found");
-              }
-              return value;
-            },
-            {
-              maxRetries: 10,
-              backoffMs: 5e3,
-              logMessage: "Checking for receipt"
-            }
-          );
-        }
-        console.log("Receipt confirmed on Hyperbridge. Proceeding.");
+        await this.submitAndConfirmReceipt(hyperbridge, commitment, getRequestMessage);
       }
       yield statusUpdate;
     }
@@ -12702,6 +12785,6 @@ async function teleportDot(param_) {
   return stream;
 }
 
-export { ADDRESS_ZERO, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, ERC20Method, EvmChain, HyperClientStatus, IndexerClient, IntentGateway, OrderStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, STATE_COMMITMENTS_SLOT, SubstrateChain, TeleportStatus, TimeoutStatus, WrappedNativeDecimals, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, coingeckoIds, consensusStateIds, constructRedeemEscrowRequestBody, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, orderCommitment, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };
+export { ADDRESS_ZERO, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, ERC20Method, EvmChain, HyperClientStatus, IndexerClient, IntentGateway, OrderStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, STATE_COMMITMENTS_SLOT, SubstrateChain, TeleportStatus, TimeoutStatus, WrappedNativeDecimals, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, coingeckoIds, consensusStateIds, constructRedeemEscrowRequestBody, convertStateIdToStateMachineId, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, orderCommitment, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map