@hyperbridge/sdk 1.3.6 → 1.3.7

package/dist/node/index.d.ts

@@ -989,9 +989,7 @@ interface AssetTeleported {
     blockNumber: number;
 }
 interface AssetTeleportedResponse {
-    assetTeleporteds: {
-        nodes: AssetTeleported[];
-    };
+    assetTeleported: AssetTeleported;
 }
 interface StateMachineIdParams {
     stateId: {
@@ -2445,14 +2443,6 @@ declare class IndexerClient {
      * @returns AsyncGenerator that emits status updates until a terminal state is reached
      */
     postRequestTimeoutStreamInternal(hash: HexString, signal: AbortSignal): AsyncGenerator<PostRequestTimeoutStatus, void>;
-    /**
-     * Query for asset teleported events by sender, recipient, and destination chain
-     * @param from - The sender address
-     * @param to - The recipient address
-     * @param dest - The destination chain ID
-     * @returns The asset teleported event if found, undefined otherwise
-     */
-    queryAssetTeleported(from: string, to: string, dest: string, blockNumber: number): Promise<AssetTeleported | undefined>;
     /**
      * Executes an async operation with exponential backoff retry
      * @param operation - Async function to execute
@@ -2678,14 +2668,17 @@ declare class IntentGateway {
 type HyperbridgeTxEvents = {
     kind: "Ready";
     transaction_hash: HexString;
+    message_id?: HexString;
 } | {
     kind: "Dispatched";
     transaction_hash: HexString;
     block_number: bigint;
+    message_id?: HexString;
     commitment: HexString;
 } | {
     kind: "Finalized";
     transaction_hash: HexString;
+    message_id?: HexString;
     block_number?: bigint;
     commitment?: HexString;
 } | {
@@ -2747,12 +2740,10 @@ type XcmGatewayParams = {
  * @yields {HyperbridgeTxEvents} Stream of events indicating transaction status
  */
 declare function teleportDot(param_: {
-    relayApi: ApiPromise;
-    hyperbridge: ApiPromise;
+    sourceApi: ApiPromise;
+    sourceIsAssetHub: boolean;
     who: string;
     xcmGatewayParams: XcmGatewayParams;
-    indexerClient: IndexerClient;
-    pollInterval?: number;
     options: Partial<SignerOptions>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
 

package/dist/node/index.js

@@ -7,14 +7,14 @@ import { toHex, hexToBytes, encodePacked, keccak256, encodeAbiParameters, bytesT
 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';
-import { Vector, u8, Struct, Tuple, Enum, _void, u64, u32, Option, bool, u128 } from 'scale-ts';
+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, xxhashAsU8a } from '@polkadot/util-crypto';
+import { keccakAsU8a, decodeAddress, keccakAsHex, xxhashAsU8a } from '@polkadot/util-crypto';
 import { GraphQLClient } from 'graphql-request';
 import { Decimal } from 'decimal.js';
-import { u8aToHex } from '@polkadot/util';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -5527,33 +5527,6 @@ query StateMachineUpdatesByTimestamp($statemachineId: String!, $commitmentTimest
     }
   }
 `;
-var ASSET_TELEPORTED_BY_PARAMS = `
-query AssetTeleportedByParams($from: String!, $to: String!, $dest: String!, $blockNumber: Int!) {
-  assetTeleporteds(
-    filter: {
-      and: [
-        { from: { equalTo: $from } }
-        { to: { equalTo: $to } }
-        { dest: { includes: $dest } }
-        { blockNumber: { greaterThanOrEqualTo: $blockNumber } }
-      ]
-    }
-    orderBy: CREATED_AT_DESC
-    first: 1
-  ) {
-    nodes {
-      id
-      from
-      to
-      amount
-      dest
-      commitment
-      createdAt
-      blockNumber
-    }
-  }
-}
-`;
 var GET_RESPONSE_BY_REQUEST_ID = `
 query GetResponseByRequestId($requestId: String!) {
   getResponses(filter: {requestId: {equalTo: $requestId}}) {
@@ -6986,24 +6959,6 @@ var IndexerClient = class {
       }
     }
   }
-  /**
-   * Query for asset teleported events by sender, recipient, and destination chain
-   * @param from - The sender address
-   * @param to - The recipient address
-   * @param dest - The destination chain ID
-   * @returns The asset teleported event if found, undefined otherwise
-   */
-  async queryAssetTeleported(from, to, dest, blockNumber) {
-    const response = await this.withRetry(
-      () => this.client.request(ASSET_TELEPORTED_BY_PARAMS, {
-        from,
-        to,
-        dest,
-        blockNumber
-      })
-    );
-    return response.assetTeleporteds.nodes[0];
-  }
   /**
    * Executes an async operation with exponential backoff retry
    * @param operation - Async function to execute
@@ -12358,24 +12313,30 @@ function readIsmpCommitmentHash(events) {
     }
   }
 }
+var MultiAccount = Struct({
+  substrate_account: Bytes(32),
+  evm_account: Bytes(20),
+  dest_state_machine: StateMachine,
+  timeout: u64,
+  account_nonce: u64
+});
 var DECIMALS = 10;
 async function teleportDot(param_) {
-  const { relayApi, hyperbridge, who, options, xcmGatewayParams: params, indexerClient, pollInterval = 2e3 } = param_;
-  const destination = {
-    V3: {
-      parents: 0,
-      interior: {
-        X1: {
-          Parachain: params.paraId
-        }
-      }
-    }
-  };
+  const { sourceApi, sourceIsAssetHub, who, options, xcmGatewayParams: params } = param_;
+  let { nonce: accountNonce } = await sourceApi.query.system.account(who);
+  let encoded_message = MultiAccount.enc({
+    substrate_account: decodeAddress(who),
+    evm_account: hexToU8a(params.recipient),
+    dest_state_machine: { tag: "Evm", value: params.destination },
+    timeout: params.timeout,
+    account_nonce: accountNonce
+  });
+  let message_id = keccakAsHex(encoded_message);
   const beneficiary = {
     V3: {
       parents: 0,
       interior: {
-        X3: [
+        X4: [
           {
             AccountId32: {
               id: u8aToHex(decodeAddress(who)),
@@ -12394,37 +12355,89 @@ async function teleportDot(param_) {
           },
           {
             GeneralIndex: params.timeout
+          },
+          {
+            GeneralIndex: accountNonce
           }
         ]
       }
     }
   };
-  const assets2 = {
-    V3: [
-      {
-        id: {
-          Concrete: {
-            parents: 0,
-            interior: "Here"
+  let assets2;
+  let destination;
+  if (sourceIsAssetHub) {
+    destination = {
+      V3: {
+        parents: 1,
+        interior: {
+          X1: {
+            Parachain: params.paraId
           }
-        },
-        fun: {
-          Fungible: parseUnits(params.amount.toString(), DECIMALS)
         }
       }
-    ]
-  };
+    };
+    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
+          }
+        }
+      }
+    };
+    assets2 = {
+      V3: [
+        {
+          id: {
+            Concrete: {
+              parents: 0,
+              interior: "Here"
+            }
+          },
+          fun: {
+            Fungible: parseUnits(params.amount.toString(), DECIMALS)
+          }
+        }
+      ]
+    };
+  }
   const feeAssetItem = 0;
   const weightLimit = "Unlimited";
-  const tx = relayApi.tx.xcmPallet.limitedReserveTransferAssets(
-    destination,
-    beneficiary,
-    assets2,
-    feeAssetItem,
-    weightLimit
-  );
-  const finalized_hash = await hyperbridge.rpc.chain.getFinalizedHead();
-  const hyperbridgeBlock = (await hyperbridge.rpc.chain.getHeader(finalized_hash)).number.toNumber();
+  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
+    );
+  }
   let closed = false;
   let unsubscribe;
   const stream = new ReadableStream(
@@ -12446,44 +12459,14 @@ async function teleportDot(param_) {
             if (status.isReady) {
               controller.enqueue({
                 kind: "Ready",
-                transaction_hash: txHash.toHex()
+                transaction_hash: txHash.toHex(),
+                message_id
               });
             } else if (status.isInBlock || status.isFinalized) {
-              const decodedWho = u8aToHex(decodeAddress(who, false));
-              let assetTeleported = void 0;
-              let attempts = 0;
-              const maxAttempts = Math.ceil(3e5 / pollInterval);
-              if (!indexerClient) {
-                controller.enqueue({
-                  kind: "Error",
-                  error: "IndexerClient is required but not provided"
-                });
-                return;
-              }
-              while (!assetTeleported && attempts < maxAttempts) {
-                await sleep(pollInterval);
-                assetTeleported = await indexerClient.queryAssetTeleported(
-                  decodedWho,
-                  params.recipient.toLowerCase(),
-                  params.destination.toString(),
-                  hyperbridgeBlock
-                );
-                attempts++;
-              }
-              if (!assetTeleported) {
-                controller.enqueue({
-                  kind: "Error",
-                  error: "Failed to locate AssetTeleported event in the indexer after maximum attempts"
-                });
-                return;
-              }
-              const commitment = assetTeleported.commitment;
-              const blockNumber = BigInt(assetTeleported.blockNumber);
               controller.enqueue({
                 kind: "Finalized",
                 transaction_hash: txHash.toHex(),
-                block_number: blockNumber,
-                commitment
+                message_id
               });
               closed = true;
               unsubscribe?.();