@hyperbridge/sdk 1.4.5 → 1.4.6

package/dist/node/index.d.ts

@@ -717,8 +717,8 @@ declare class EvmChain implements IChain {
      * @param request - The post request to calculate the fee for
      * @returns The total fee in wei required to send the post request
      */
-    quote(request: IPostRequest): Promise<bigint>;
-    quoteNative(request: IPostRequest, fee: bigint): Promise<bigint>;
+    quote(request: IPostRequest | IGetRequest): Promise<bigint>;
+    quoteNative(request: IPostRequest | IGetRequest, fee: bigint): Promise<bigint>;
     private getAmountsIn;
     /**
      * Estimates the gas required for a post request execution on this chain.
@@ -2994,6 +2994,11 @@ declare class IntentGateway {
      */
     isOrderFilled(order: Order): Promise<boolean>;
     private submitAndConfirmReceipt;
+    /**
+     * Returns the native token amount required to dispatch a cancellation GET request for the given order.
+     * Internally constructs the IGetRequest and calls quoteNative.
+     */
+    quoteCancelNative(order: Order): Promise<bigint>;
     /**
      * Cancels an order through the cross-chain protocol by generating and submitting proofs.
      * This is an async generator function that yields status updates throughout the cancellation process.
@@ -3123,7 +3128,7 @@ type HyperbridgeTxEvents = {
     error: unknown;
 };
 /**
- * Parameters for teleporting DOT from Polkadot relay chain to EVM-based destination
+ * Parameters for teleporting DOT from AssetHub to EVM-based destination
  */
 type XcmGatewayParams = {
     /**
@@ -3152,33 +3157,32 @@ type XcmGatewayParams = {
     paraId: number;
 };
 /**
- * Teleports DOT tokens from Polkadot relay chain to an EVM-based destination chain
- * using XCM (Cross-Consensus Message Format) and uses the indexer client to track
- * the transaction instead of polling hyperbridge blocks.
+ * Teleports DOT tokens from AssetHub to Hyperbridge parachain
+ * using XCM V3 with transferAssetsUsingTypeAndThen.
+ *
+ * This function uses transferAssetsUsingTypeAndThen to construct XCM V3 transfers with a custom
+ * beneficiary structure that embeds Hyperbridge-specific parameters (sender account, recipient EVM address,
+ * timeout, and nonce) within an X4 junction. The beneficiary is wrapped in a DepositAsset XCM V3 instruction
+ * that deposits all transferred assets. The assets are transferred using LocalReserve transfer type.
  *
- * This function initiates a teleport transaction, monitors its status through the indexer,
- * and yields events about the transaction's progress through a ReadableStream.
  * It handles the complete lifecycle of a teleport operation:
- * 1. Transaction preparation and signing
- * 2. Broadcasting to the relay chain
- * 3. Tracking the transaction via the indexer client
- * 4. Yielding events about transaction status
+ * 1. Encoding Hyperbridge parameters into the beneficiary X4 junction
+ * 2. Wrapping the beneficiary in a DepositAsset XCM V3 instruction using sourceApi.createType
+ * 3. Constructing the XCM V3 transfer transaction using polkadotXcm.transferAssetsUsingTypeAndThen
+ * 4. Transaction signing and broadcasting
+ * 5. Yielding events about transaction status through a ReadableStream
  *
  * Note: There is no guarantee that both Dispatched and Finalized events will be yielded.
  * Consumers should listen for either one of these events instead of expecting both.
  *
- * @param sourceApi - Polkadot API instance connected to the relay chain or asset hub
- * @param sourceIsAssetHub - If `true` uses AssetHub Network for teleport
+ * @param sourceApi - Polkadot API instance connected to AssetHub
  * @param who - Sender's SS58Address address
  * @param options - Transaction signing options
- * @param params - Teleport parameters including destination, recipient, and amount
- * @param indexerClient - The indexer client to track the transaction
- * @param pollInterval - Optional polling interval in milliseconds (default: 2000)
+ * @param params - Teleport parameters including destination, recipient, amount, timeout, and paraId
  * @yields {HyperbridgeTxEvents} Stream of events indicating transaction status
  */
 declare function teleportDot(param_: {
     sourceApi: ApiPromise;
-    sourceIsAssetHub: boolean;
     who: string;
     xcmGatewayParams: XcmGatewayParams;
     options: Partial<SignerOptions>;

package/dist/node/index.js

@@ -6032,13 +6032,14 @@ var EvmChain = class {
    * @returns The total fee in wei required to send the post request
    */
   async quote(request) {
+    const bodyByteLength = "body" in request ? Math.floor((request.body.length - 2) / 2) : Math.floor((request.context.length - 2) / 2);
+    const args = "body" in request ? [toHex(request.dest)] : [toHex(request.source)];
     const perByteFee = await this.publicClient.readContract({
       address: this.params.host,
       abi: evmHost_default.ABI,
       functionName: "perByteFee",
-      args: [toHex(request.dest)]
+      args
     });
-    const bodyByteLength = Math.floor((request.body.length - 2) / 2);
     const length = bodyByteLength < 32 ? 32 : bodyByteLength;
     return perByteFee * BigInt(length);
   }
@@ -6874,7 +6875,7 @@ query GetResponseByRequestId($requestId: String!) {
 `;
 var ORDER_STATUS = `
 query OrderStatus($commitment: String!) {
-  orderPlaceds(
+  orders(
     filter: { commitment: { equalTo: $commitment } }
   ) {
     nodes {
@@ -6895,6 +6896,7 @@ query OrderStatus($commitment: String!) {
       outputBeneficiaries
       calldata
       status
+      referrer
       createdAt
       blockNumber
       blockTimestamp
@@ -12733,6 +12735,60 @@ var IntentGateway = class {
     }
     console.log("Hyperbridge Receipt confirmed.");
   }
+  /**
+   * Returns the native token amount required to dispatch a cancellation GET request for the given order.
+   * Internally constructs the IGetRequest and calls quoteNative.
+   */
+  async quoteCancelNative(order) {
+    const orderWithCommitment = transformOrder(order);
+    const height = orderWithCommitment.deadline + 1n;
+    const destIntentGateway = this.dest.configService.getIntentGatewayAddress(orderWithCommitment.destChain);
+    const slotHash = await this.dest.client.readContract({
+      abi: IntentGateway_default.ABI,
+      address: destIntentGateway,
+      functionName: "calculateCommitmentSlotHash",
+      args: [orderWithCommitment.id]
+    });
+    const key = concatHex([destIntentGateway, slotHash]);
+    const context = encodeAbiParameters(
+      [
+        {
+          name: "requestBody",
+          type: "tuple",
+          components: [
+            { name: "commitment", type: "bytes32" },
+            { name: "beneficiary", type: "bytes32" },
+            {
+              name: "tokens",
+              type: "tuple[]",
+              components: [
+                { name: "token", type: "bytes32" },
+                { name: "amount", type: "uint256" }
+              ]
+            }
+          ]
+        }
+      ],
+      [
+        {
+          commitment: orderWithCommitment.id,
+          beneficiary: orderWithCommitment.user,
+          tokens: orderWithCommitment.inputs
+        }
+      ]
+    );
+    const getRequest = {
+      source: orderWithCommitment.sourceChain,
+      dest: orderWithCommitment.destChain,
+      from: this.source.configService.getIntentGatewayAddress(orderWithCommitment.destChain),
+      nonce: await this.source.getHostNonce(),
+      height,
+      keys: [key],
+      timeoutTimestamp: 0n,
+      context
+    };
+    return await this.source.quoteNative(getRequest, 0n);
+  }
   /**
    * Cancels an order through the cross-chain protocol by generating and submitting proofs.
    * This is an async generator function that yields status updates throughout the cancellation process.
@@ -13067,7 +13123,7 @@ var MultiAccount = Struct({
 });
 var DECIMALS = 10;
 async function teleportDot(param_) {
-  const { sourceApi, sourceIsAssetHub, who, options, xcmGatewayParams: params } = param_;
+  const { sourceApi, who, options, xcmGatewayParams: params } = param_;
   const { nonce: accountNonce } = await sourceApi.query.system.account(who);
   const encoded_message = MultiAccount.enc({
     substrate_account: decodeAddress(who),
@@ -13078,7 +13134,7 @@ async function teleportDot(param_) {
   });
   const message_id = keccakAsHex(encoded_message);
   const beneficiary = {
-    V3: {
+    V4: {
       parents: 0,
       interior: {
         X4: [
@@ -13108,81 +13164,58 @@ async function teleportDot(param_) {
       }
     }
   };
-  let assets2;
-  let destination;
-  if (sourceIsAssetHub) {
-    destination = {
-      V3: {
-        parents: 1,
-        interior: {
-          X1: {
-            Parachain: params.paraId
-          }
-        }
+  const destination = {
+    V4: {
+      parents: 1,
+      interior: {
+        X1: [{ Parachain: params.paraId }]
       }
-    };
-    assets2 = {
-      V3: [
-        {
-          id: {
-            Concrete: {
-              parents: 1,
-              interior: "Here"
-            }
-          },
-          fun: {
-            Fungible: parseUnits(params.amount.toString(), DECIMALS)
-          }
-        }
-      ]
-    };
-  } else {
-    destination = {
-      V3: {
-        parents: 0,
-        interior: {
-          X1: {
-            Parachain: params.paraId
-          }
+    }
+  };
+  const assets2 = {
+    V4: [
+      {
+        id: {
+          parents: 1,
+          interior: "Here"
+        },
+        fun: {
+          Fungible: parseUnits(params.amount.toString(), DECIMALS)
         }
       }
-    };
-    assets2 = {
-      V3: [
-        {
-          id: {
-            Concrete: {
-              parents: 0,
-              interior: "Here"
+    ]
+  };
+  const weightLimit = "Unlimited";
+  const feeAssetId = {
+    V4: assets2.V4[0].id
+  };
+  const customXcmOnDest = {
+    V4: [
+      {
+        DepositAsset: {
+          assets: {
+            Wild: {
+              AllCounted: 1
             }
           },
-          fun: {
-            Fungible: parseUnits(params.amount.toString(), DECIMALS)
-          }
+          beneficiary: beneficiary.V4
         }
-      ]
-    };
-  }
-  const feeAssetItem = 0;
-  const weightLimit = "Unlimited";
-  let tx;
-  if (sourceIsAssetHub) {
-    tx = sourceApi.tx.polkadotXcm.limitedReserveTransferAssets(
-      destination,
-      beneficiary,
-      assets2,
-      feeAssetItem,
-      weightLimit
-    );
-  } else {
-    tx = sourceApi.tx.xcmPallet.limitedReserveTransferAssets(
-      destination,
-      beneficiary,
-      assets2,
-      feeAssetItem,
-      weightLimit
-    );
-  }
+      }
+    ]
+  };
+  const tx = sourceApi.tx.polkadotXcm.transferAssetsUsingTypeAndThen(
+    destination,
+    assets2,
+    { LocalReserve: null },
+    // Assets transfer type
+    feeAssetId,
+    // Fee asset ID wrapped as VersionedAssetId
+    { LocalReserve: null },
+    // Remote fee transfer type
+    customXcmOnDest,
+    // XCM instruction with DepositAsset containing custom beneficiary
+    weightLimit
+  );
   let closed = false;
   let unsubscribe;
   const stream = new ReadableStream(