@hyperbridge/sdk 1.3.5 → 1.3.7

package/dist/node/index.js

@@ -3,17 +3,18 @@ import { join } from 'path';
 import { TextDecoder as TextDecoder$1, TextEncoder as TextEncoder$1 } from 'util';
 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, parseUnits } from 'viem';
+import { toHex, hexToBytes, encodePacked, keccak256, encodeAbiParameters, bytesToHex, concatHex, createPublicClient, http, encodeFunctionData, erc20Abi, bytesToBigInt, pad, toBytes, maxUint256, formatUnits, parseUnits } 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';
-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 { u8aToHex } from '@polkadot/util';
+import { Decimal } from 'decimal.js';
+import { hexToU8a, u8aToHex } from '@polkadot/util';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -3933,6 +3934,10 @@ var GetRequest = Struct({
    * Substrate Keys
    */
   keys: Vector(Vector(u8)),
+  /*
+   * The height of the state machine
+   */
+  height: u64,
   /*
    * Some application-specific metadata relating to this request
    */
@@ -4059,6 +4064,24 @@ var TimeoutMessage = Enum({
     requests: Vector(Request)
   })
 });
+var GetRequestsWithProof = Struct({
+  /*
+   * Requests to be fetched
+   */
+  requests: Vector(GetRequest),
+  /*
+   * Membership batch proof for these requests
+   */
+  source: Proof,
+  /*
+   * Storage proof for these responses
+   */
+  response: Proof,
+  /*
+   * Signer information. Ideally should be their account identifier
+   */
+  signer: Vector(u8)
+});
 var Message = Enum({
   /*
    * A consensus update message
@@ -4807,6 +4830,8 @@ var EvmChain = class {
         ]
       });
       return encoded2;
+    }).with({ kind: "GetRequest" }, (message2) => {
+      throw new Error("GetResponse is not yet supported on Substrate chains");
     }).exhaustive();
     return encoded;
   }
@@ -5122,8 +5147,13 @@ var SubstrateChain = class {
   async submitUnsigned(message) {
     if (!this.api) throw new Error("API not initialized");
     const { api } = this;
-    const args = hexToBytes(this.encode(message)).slice(2);
-    const tx = api.tx.ismp.handleUnsigned(args);
+    const args = encodeISMPMessage(message);
+    let tx;
+    if (message.kind === "GetRequest") {
+      tx = api.tx.stateCoprocessor.handleUnsigned(args);
+    } else {
+      tx = api.tx.ismp.handleUnsigned(args);
+    }
     return new Promise((resolve, reject) => {
       let unsub = () => {
       };
@@ -5266,6 +5296,18 @@ function convertIPostRequestToCodec(request) {
     }
   };
 }
+function convertIGetRequestToCodec(request) {
+  return {
+    source: convertStateMachineIdToEnum(request.source),
+    dest: convertStateMachineIdToEnum(request.dest),
+    from: Array.from(hexToBytes(request.from)),
+    nonce: request.nonce,
+    keys: request.keys.map((key) => Array.from(hexToBytes(key))),
+    context: Array.from(hexToBytes(request.context)),
+    timeoutTimestamp: request.timeoutTimestamp,
+    height: request.height
+  };
+}
 function encodeISMPMessage(message) {
   try {
     return match(message).with({ kind: "PostRequest" }, (message2) => {
@@ -5292,6 +5334,31 @@ function encodeISMPMessage(message) {
       ]);
     }).with({ kind: "GetResponse" }, (message2) => {
       throw new Error("GetResponse is not yet supported on Substrate chains");
+    }).with({ kind: "GetRequest" }, (message2) => {
+      return GetRequestsWithProof.enc({
+        requests: message2.requests.map((request) => convertIGetRequestToCodec(request)),
+        source: {
+          height: {
+            height: message2.source.height,
+            id: {
+              consensusStateId: Array.from(toBytes(message2.source.consensusStateId)),
+              id: convertStateMachineIdToEnum(message2.source.stateMachine)
+            }
+          },
+          proof: Array.from(hexToBytes(message2.source.proof))
+        },
+        response: {
+          height: {
+            height: message2.response.height,
+            id: {
+              consensusStateId: Array.from(toBytes(message2.response.consensusStateId)),
+              id: convertStateMachineIdToEnum(message2.response.stateMachine)
+            }
+          },
+          proof: Array.from(hexToBytes(message2.response.proof))
+        },
+        signer: Array.from(hexToBytes(message2.signer))
+      });
     }).with({ kind: "TimeoutPostRequest" }, (message2) => {
       return Vector(Message).enc([
         {
@@ -5460,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}}) {
@@ -6919,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
@@ -11488,8 +11510,6 @@ var UNISWAP_V4_QUOTER_ABI = [
     inputs: [{ name: "revertData", type: "bytes", internalType: "bytes" }]
   }
 ];
-
-// src/protocols/intents.ts
 var IntentGateway = class {
   /**
    * Creates a new IntentGateway instance for cross-chain operations.
@@ -11575,6 +11595,7 @@ var IntentGateway = class {
       }))
     ];
     let destChainFillGas = 0n;
+    let filledWithNativeToken = false;
     try {
       let protocolFeeInNativeToken = await this.quoteNative(postRequest, relayerFeeInDestFeeToken);
       protocolFeeInNativeToken = protocolFeeInNativeToken + protocolFeeInNativeToken * 50n / 10000n;
@@ -11587,6 +11608,7 @@ var IntentGateway = class {
         value: totalEthValue + protocolFeeInNativeToken,
         stateOverride: stateOverrides
       });
+      filledWithNativeToken = true;
     } catch {
       console.warn(
         `Could not estimate gas for fill order with native token as fees for chain ${order.destChain}, now trying with fee token as fees`
@@ -11628,18 +11650,18 @@ var IntentGateway = class {
       sourceChainFeeTokenDecimals
     );
     const protocolFeeInSourceFeeToken = adjustFeeDecimals(
-      // Following baseIsmpModule.sol, the protocol fee is added to the relayer fee
-      await this.dest.quote(postRequest) + relayerFeeInDestFeeToken,
+      await this.dest.quote(postRequest),
       destChainFeeTokenDecimals,
       sourceChainFeeTokenDecimals
     );
-    const totalEstimate = fillGasInSourceFeeToken + protocolFeeInSourceFeeToken + relayerFeeInSourceFeeToken;
-    const SWAP_OPERATIONS_BPS = 3500n;
-    const swapOperationsInFeeToken = totalEstimate * SWAP_OPERATIONS_BPS / 10000n;
-    const totalFeeTokenAmount = totalEstimate + swapOperationsInFeeToken;
-    const totalNativeTokenAmount = await this.convertFeeTokenToNative(totalFeeTokenAmount, "source");
+    let totalEstimateInSourceFeeToken = fillGasInSourceFeeToken + protocolFeeInSourceFeeToken + relayerFeeInSourceFeeToken;
+    if (!filledWithNativeToken) {
+      totalEstimateInSourceFeeToken = totalEstimateInSourceFeeToken + totalEstimateInSourceFeeToken * 200n / 10000n;
+    }
+    let totalNativeTokenAmount = await this.convertFeeTokenToNative(totalEstimateInSourceFeeToken, "source");
+    totalNativeTokenAmount = totalNativeTokenAmount + totalNativeTokenAmount * 200n / 10000n;
     return {
-      feeTokenAmount: totalFeeTokenAmount,
+      feeTokenAmount: totalEstimateInSourceFeeToken,
       nativeTokenAmount: totalNativeTokenAmount,
       postRequestCalldata
     };
@@ -11649,8 +11671,7 @@ var IntentGateway = class {
    * Uses USD pricing to convert between fee token amounts and native token costs.
    *
    * @param feeTokenAmount - The amount in fee token (DAI)
-   * @param publicClient - The client for the chain to get native token info
-   * @param feeTokenDecimals - The decimal places of the fee token
+   * @param getQuoteIn - Whether to use "source" or "dest" chain for the conversion
    * @returns The fee token amount converted to native token amount
    * @private
    */
@@ -11659,22 +11680,33 @@ var IntentGateway = class {
     const evmChainID = `EVM-${client.chain?.id}`;
     const wethAsset = this[getQuoteIn].config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
     const feeToken = await this[getQuoteIn].getFeeTokenWithDecimals();
-    const { amountOut } = await this.findBestProtocolWithAmountIn(
-      getQuoteIn,
-      feeToken.address,
-      wethAsset,
-      feeTokenAmount,
-      "v2"
-    );
-    return amountOut;
+    try {
+      const { amountOut } = await this.findBestProtocolWithAmountIn(
+        getQuoteIn,
+        feeToken.address,
+        wethAsset,
+        feeTokenAmount,
+        "v2"
+      );
+      if (amountOut === 0n) {
+        throw new Error();
+      }
+      return amountOut;
+    } catch {
+      const nativeCurrency = client.chain?.nativeCurrency;
+      const chainId = client.chain?.id;
+      const feeTokenAmountDecimal = new Decimal(formatUnits(feeTokenAmount, feeToken.decimals));
+      const nativeTokenPriceUsd = new Decimal(await fetchPrice(nativeCurrency?.symbol, chainId));
+      const totalCostInNativeToken = feeTokenAmountDecimal.dividedBy(nativeTokenPriceUsd);
+      return parseUnits(totalCostInNativeToken.toFixed(nativeCurrency?.decimals), nativeCurrency?.decimals);
+    }
   }
   /**
    * Converts gas costs to the equivalent amount in the fee token (DAI).
    * Uses USD pricing to convert between native token gas costs and fee token amounts.
    *
    * @param gasEstimate - The estimated gas units
-   * @param publicClient - The client for the chain to get gas prices
-   * @param targetDecimals - The decimal places of the target fee token
+   * @param gasEstimateIn - Whether to use "source" or "dest" chain for the conversion
    * @returns The gas cost converted to fee token amount
    * @private
    */
@@ -11685,15 +11717,36 @@ var IntentGateway = class {
     const evmChainID = `EVM-${client.chain?.id}`;
     const wethAddr = this[gasEstimateIn].config.getWrappedNativeAssetWithDecimals(evmChainID).asset;
     const feeToken = await this[gasEstimateIn].getFeeTokenWithDecimals();
-    const { amountOut } = await this.findBestProtocolWithAmountIn(
-      gasEstimateIn,
-      wethAddr,
-      feeToken.address,
-      gasCostInWei,
-      "v2"
-    );
-    return amountOut;
+    try {
+      const { amountOut } = await this.findBestProtocolWithAmountIn(
+        gasEstimateIn,
+        wethAddr,
+        feeToken.address,
+        gasCostInWei,
+        "v2"
+      );
+      if (amountOut === 0n) {
+        throw new Error();
+      }
+      return amountOut;
+    } catch {
+      const nativeCurrency = client.chain?.nativeCurrency;
+      const chainId = client.chain?.id;
+      const gasCostInToken = new Decimal(formatUnits(gasCostInWei, nativeCurrency?.decimals));
+      const tokenPriceUsd = await fetchPrice(nativeCurrency?.symbol, chainId);
+      const gasCostUsd = gasCostInToken.times(tokenPriceUsd);
+      const feeTokenPriceUsd = new Decimal(1);
+      const gasCostInFeeToken = gasCostUsd.dividedBy(feeTokenPriceUsd);
+      return parseUnits(gasCostInFeeToken.toFixed(feeToken.decimals), feeToken.decimals);
+    }
   }
+  /**
+   * Gets a quote for the native token cost of dispatching a post request.
+   *
+   * @param postRequest - The post request to quote
+   * @param fee - The fee amount in fee token
+   * @returns The native token amount required
+   */
   async quoteNative(postRequest, fee) {
     const dispatchPost = {
       dest: toHex(postRequest.dest),
@@ -11715,7 +11768,7 @@ var IntentGateway = class {
    * Finds the best Uniswap protocol (V2, V3, or V4) for swapping tokens given a desired output amount.
    * Compares liquidity and pricing across different protocols and fee tiers.
    *
-   * @param chain - The chain identifier where the swap will occur
+   * @param getQuoteIn - Whether to use "source" or "dest" chain for the swap
    * @param tokenIn - The address of the input token
    * @param tokenOut - The address of the output token
    * @param amountOut - The desired output amount
@@ -11880,10 +11933,11 @@ var IntentGateway = class {
    * Finds the best Uniswap protocol (V2, V3, or V4) for swapping tokens given an input amount.
    * Compares liquidity and pricing across different protocols and fee tiers.
    *
-   * @param chain - The chain identifier where the swap will occur
+   * @param getQuoteIn - Whether to use "source" or "dest" chain for the swap
    * @param tokenIn - The address of the input token
    * @param tokenOut - The address of the output token
    * @param amountIn - The input amount to swap
+   * @param selectedProtocol - Optional specific protocol to use ("v2", "v3", or "v4")
    * @returns Object containing the best protocol, expected output amount, and fee tier (for V3/V4)
    */
   async findBestProtocolWithAmountIn(getQuoteIn, tokenIn, tokenOut, amountIn, selectedProtocol) {
@@ -12259,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)),
@@ -12295,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(
@@ -12347,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?.();