@hyperbridge/sdk 1.3.9 → 1.3.10

package/dist/browser/index.d.ts

@@ -1,5 +1,6 @@
 import { ConsolaInstance } from 'consola';
 import { GraphQLClient } from 'graphql-request';
+import * as viem from 'viem';
 import { Hex, ContractFunctionArgs, Log, PublicClient } from 'viem';
 import { ApiPromise } from '@polkadot/api';
 import { SignerOptions } from '@polkadot/api/types';
@@ -1650,9 +1651,10 @@ declare class EvmChain implements IChain {
      * Query and return the encoded storage proof for the provided keys at the given height.
      * @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
      * @returns {Promise<HexString>} The encoded storage proof.
      */
-    queryStateProof(at: bigint, keys: HexString[]): Promise<HexString>;
+    queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
     /**
      * Returns the current timestamp of the chain.
      * @returns {Promise<bigint>} The current timestamp.
@@ -2573,6 +2575,9 @@ 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
@@ -2658,6 +2663,115 @@ 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<{
+        status: RequestStatus["SOURCE"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: RequestStatus["SOURCE_FINALIZED"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: RequestStatus["HYPERBRIDGE_DELIVERED"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: RequestStatus["HYPERBRIDGE_FINALIZED"];
+        metadata: {
+            calldata: viem.Hex;
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: RequestStatus["DESTINATION"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: TimeoutStatus["PENDING_TIMEOUT"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+        };
+    } | {
+        status: TimeoutStatus["DESTINATION_FINALIZED_TIMEOUT"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: TimeoutStatus["HYPERBRIDGE_TIMED_OUT"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: TimeoutStatus["HYPERBRIDGE_FINALIZED_TIMEOUT"];
+        metadata: {
+            calldata: viem.Hex;
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: TimeoutStatus["TIMED_OUT"];
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp?: number;
+        };
+    } | {
+        status: string;
+        data: {
+            currentHeight: bigint;
+            deadline: bigint;
+            height?: undefined;
+            proof?: undefined;
+        };
+    } | {
+        status: string;
+        data: {
+            height: bigint;
+            currentHeight?: undefined;
+            deadline?: undefined;
+            proof?: undefined;
+        };
+    } | {
+        status: string;
+        data: {
+            proof: `0x${string}`;
+            height: bigint;
+            currentHeight?: undefined;
+            deadline?: undefined;
+        };
+    } | {
+        status: string;
+        data?: undefined;
+    }, void, IGetRequest | undefined>;
     /**
      * Returns the tick spacing for a given fee tier in Uniswap V4
      * @param fee - The fee tier in basis points

package/dist/browser/index.js

@@ -1,6 +1,6 @@
 import { createConsola, LogLevels } from 'consola';
 import { flatten, zip, capitalize, maxBy, isNil } from 'lodash-es';
-import { toHex, hexToBytes, encodePacked, keccak256, encodeAbiParameters, bytesToHex, concatHex, createPublicClient, http, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, maxUint256, formatUnits, parseUnits } from 'viem';
+import { toHex, hexToBytes, encodePacked, keccak256, encodeAbiParameters, bytesToHex, concatHex, createPublicClient, http, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, maxUint256, formatUnits, parseUnits, hexToString as hexToString$1 } from 'viem';
 import mergeRace from '@async-generator/merge-race';
 import { gnosisChiado, gnosis, bscTestnet, bsc, soneium, baseSepolia, base, optimismSepolia, optimism, arbitrumSepolia, arbitrum, mainnet, sepolia } from 'viem/chains';
 import { hasWindow, isNode, env } from 'std-env';
@@ -3440,7 +3440,7 @@ var addresses = {
   IntentGateway: {
     ["EVM-97" /* BSC_CHAPEL */]: "0x016b6ffC9f890d1e28f9Fdb9eaDA776b02F89509",
     ["EVM-10200" /* GNOSIS_CHIADO */]: "0x016b6ffC9f890d1e28f9Fdb9eaDA776b02F89509",
-    ["EVM-11155111" /* SEPOLIA */]: "0x0000000000000000000000000000000000000000",
+    ["EVM-11155111" /* SEPOLIA */]: "0x016b6ffC9f890d1e28f9Fdb9eaDA776b02F89509",
     ["EVM-1" /* MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA",
     ["EVM-56" /* BSC_MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA",
     ["EVM-42161" /* ARBITRUM_MAINNET */]: "0xd54165e45926720b062C192a5bacEC64d5bB08DA",
@@ -4667,11 +4667,12 @@ var EvmChain = class {
    * Query and return the encoded storage proof for the provided keys at the given height.
    * @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
    * @returns {Promise<HexString>} The encoded storage proof.
    */
-  async queryStateProof(at, keys) {
+  async queryStateProof(at, keys, address) {
     const config = {
-      address: this.params.host,
+      address: address ?? this.params.host,
       storageKeys: keys
     };
     if (!at) {
@@ -5535,7 +5536,7 @@ query StateMachineUpdatesByHeight($statemachineId: String!, $height: Int!, $chai
 				{ chain: { equalTo: $chain } }
 			]
 		}
-		orderBy: HEIGHT_ASC
+		orderBy: HEIGHT_DESC
 		first: 1
 	) {
     nodes {
@@ -11600,6 +11601,13 @@ 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.
@@ -12208,6 +12216,121 @@ var IntentGateway = class {
     });
     return filledStatus !== "0x0000000000000000000000000000000000000000000000000000000000000000";
   }
+  async *cancelOrder(order, hyperbridgeConfig, indexerClient) {
+    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);
+      }
+    }
+    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) {
+      if (statusUpdate.status === RequestStatus.SOURCE_FINALIZED) {
+        const sourceHeight = statusUpdate.metadata.blockNumber;
+        const proof2 = await this.source.queryProof(
+          { Requests: [commitment] },
+          hyperbridgeConfig.stateMachineId,
+          BigInt(sourceHeight)
+        );
+        const { stateId } = parseStateMachineId(sourceStateMachine);
+        const sourceIProof = {
+          height: BigInt(sourceHeight),
+          stateMachine: sourceStateMachine,
+          consensusStateId: sourceConsensusStateId,
+          proof: proof2
+        };
+        const getRequestMessage = {
+          kind: "GetRequest",
+          requests: [getRequest],
+          source: sourceIProof,
+          response: this.getCachedProof(order.id),
+          signer: pad("0x")
+        };
+        await waitForChallengePeriod(hyperbridge, {
+          height: BigInt(sourceHeight),
+          id: {
+            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.");
+      }
+      yield statusUpdate;
+    }
+  }
   /**
    * Returns the tick spacing for a given fee tier in Uniswap V4
    * @param fee - The fee tier in basis points