@sodax/sdk 1.2.3-beta → 1.2.5-beta

package/dist/index.cjs

@@ -10443,13 +10443,12 @@ var MoneyMarketDataService = class {
   }
   /**
    * Get the user reserves data
-   * @param spokeProvider - The spoke provider
+   * @param spokeChainId - The spoke chain ID
+   * @param userAddress - The user's wallet address on the spoke chain
    * @returns {Promise<readonly [readonly UserReserveData[], number]>} - The user reserves data
    */
-  async getUserReservesData(spokeProvider) {
-    const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
-    const spokeChainId = spokeProvider.chainConfig.chain.id;
-    const hubWalletAddress = await HubService.getUserHubWalletAddress(walletAddress, spokeChainId, this.hubProvider);
+  async getUserReservesData(spokeChainId, userAddress) {
+    const hubWalletAddress = await HubService.getUserHubWalletAddress(userAddress, spokeChainId, this.hubProvider);
     return this.uiPoolDataProviderService.getUserReservesData(hubWalletAddress);
   }
   /**
@@ -10475,13 +10474,12 @@ var MoneyMarketDataService = class {
   }
   /**
    * Get the user reserves humanized
-   * @param spokeProvider - The spoke provider
+   * @param spokeChainId - The spoke chain ID
+   * @param userAddress - The user's wallet address on the spoke chain
    * @returns {Promise<{userReserves: UserReserveDataHumanized[], userEmodeCategoryId: number}>} - The user reserves humanized
    */
-  async getUserReservesHumanized(spokeProvider) {
-    const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
-    const spokeChainId = spokeProvider.chainConfig.chain.id;
-    const hubWalletAddress = await HubService.getUserHubWalletAddress(walletAddress, spokeChainId, this.hubProvider);
+  async getUserReservesHumanized(spokeChainId, userAddress) {
+    const hubWalletAddress = await HubService.getUserHubWalletAddress(userAddress, spokeChainId, this.hubProvider);
     return this.uiPoolDataProviderService.getUserReservesHumanized(hubWalletAddress);
   }
   /**
@@ -10767,6 +10765,33 @@ var StellarSpokeService = class _StellarSpokeService {
       raw
     );
   }
+  static async waitForTransactionRaw(params) {
+    const defaultParams = {
+      pollingTimeout: 750,
+      maxAttempts: 40
+    };
+    const { pollingTimeout, maxAttempts, sorobanRpcConfig, txHash } = { ...defaultParams, ...params };
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const sorobanServer = new CustomSorobanServer(sorobanRpcConfig.sorobanRpcUrl, sorobanRpcConfig.customHeaders);
+        const tx = await sorobanServer.getTransaction(txHash);
+        if (tx && tx.status === "SUCCESS") {
+          return { ok: true, value: true };
+        }
+        if (tx && tx.status === "FAILED") {
+          return { ok: false, error: new Error(`Transaction failed: ${JSON.stringify(tx)}`) };
+        }
+        if (tx && tx.status === "NOT_FOUND") {
+          await sleep(pollingTimeout);
+          continue;
+        }
+        await sleep(pollingTimeout);
+      } catch (err) {
+        await sleep(pollingTimeout);
+      }
+    }
+    return { ok: false, error: new Error("Transaction was not confirmed within the max attempts") };
+  }
   static async waitForTransaction(spokeProvider, txHash, pollingTimeout = 750, maxAttempts = 40) {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       try {
@@ -11576,6 +11601,42 @@ var EvmSpokeService = class _EvmSpokeService {
     }
     return spokeProvider.walletProvider.sendTransaction(rawTx);
   }
+  static async waitForTransactionReceipt(params) {
+    try {
+      const { txHash, chainId, rpcUrl, confirmations, pollingInterval, retryCount, retryDelay, timeout } = params;
+      const evmChain = getEvmViemChain(chainId);
+      const publicClient = viem.createPublicClient({
+        chain: evmChain,
+        transport: viem.http(rpcUrl ?? evmChain.rpcUrls.default.http[0])
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: txHash,
+        confirmations,
+        pollingInterval,
+        retryCount,
+        retryDelay,
+        timeout
+      });
+      const response = {
+        ...receipt,
+        transactionIndex: receipt.transactionIndex.toString(),
+        blockNumber: receipt.blockNumber.toString(),
+        cumulativeGasUsed: receipt.cumulativeGasUsed.toString(),
+        gasUsed: receipt.gasUsed.toString(),
+        contractAddress: receipt.contractAddress?.toString() ?? null,
+        logs: receipt.logs.map((log) => ({
+          ...log,
+          blockNumber: log.blockNumber.toString(),
+          logIndex: log.logIndex.toString(),
+          transactionIndex: log.transactionIndex.toString()
+        })),
+        effectiveGasPrice: receipt.effectiveGasPrice?.toString()
+      };
+      return { ok: true, value: response };
+    } catch (error) {
+      return { ok: false, error: new Error(`Failed to get transaction receipt: ${JSON.stringify(error)}`) };
+    }
+  }
 };
 
 // src/shared/utils/icon-utils.ts
@@ -12037,7 +12098,40 @@ var SolanaSpokeService = class _SolanaSpokeService {
     }
     return spokeProvider.walletProvider.sendTransaction(serializedTransaction);
   }
-  static async waitForConfirmation(spokeProvider, signature, commitment = "finalized", timeoutMs = 6e4) {
+  static async waitForConfirmationRaw(params) {
+    try {
+      const defaultParams = {
+        commitment: "finalized",
+        timeoutMs: 6e4,
+        // total time to wait
+        pollingTimeout: 750
+        // 750ms retry interval
+      };
+      const { rpcUrl, signature, commitment, timeoutMs, pollingTimeout } = { ...defaultParams, ...params };
+      const connection = new web3_js.Connection(rpcUrl, commitment);
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        try {
+          const tx = await connection.getTransaction(signature, { commitment, maxSupportedTransactionVersion: 0 });
+          if (tx) {
+            if (tx.meta?.err) {
+              return { ok: false, error: new Error(JSON.stringify(tx.meta.err)) };
+            }
+            return { ok: true, value: true };
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, pollingTimeout));
+      }
+      return {
+        ok: false,
+        error: new Error(`Timed out after ${timeoutMs}ms waiting for ${commitment} confirmation for ${signature}`)
+      };
+    } catch (error) {
+      return { ok: false, error: new Error(`Failed to get transaction confirmation: ${JSON.stringify(error)}`) };
+    }
+  }
+  static async waitForConfirmation(spokeProvider, signature, commitment = "finalized", timeoutMs = 6e4, pollingTimeout = 750) {
     try {
       const connection = new web3_js.Connection(spokeProvider.chainConfig.rpcUrl, commitment);
       const deadline = Date.now() + timeoutMs;
@@ -12052,7 +12146,7 @@ var SolanaSpokeService = class _SolanaSpokeService {
           }
         } catch {
         }
-        await new Promise((r) => setTimeout(r, 750));
+        await new Promise((r) => setTimeout(r, pollingTimeout));
       }
       return {
         ok: false,
@@ -12474,6 +12568,31 @@ var SpokeService = class _SpokeService {
       value: true
     };
   }
+  /**
+   * Verifies the transaction hash for the spoke chain to exist on chain.
+   * @param {VerifyTxHashRawConfig} params - The parameters for the verification.
+   * @returns {Promise<Result<boolean>>} A promise that resolves to the result of the verification.
+   */
+  static async verifyTxHashRaw(params) {
+    switch (params.chainType) {
+      case "SOLANA":
+        return SolanaSpokeService.waitForConfirmationRaw(params);
+      case "STELLAR":
+        return StellarSpokeService.waitForTransactionRaw(params);
+      case "EVM": {
+        const result = await EvmSpokeService.waitForTransactionReceipt(params);
+        if (!result.ok) {
+          return result;
+        }
+        if (result.value.status && result.value.status !== "0x1") {
+          return { ok: false, error: new Error("Transaction reverted") };
+        }
+        return { ok: true, value: true };
+      }
+      default:
+        return { ok: true, value: true };
+    }
+  }
 };
 var IntentDataType = /* @__PURE__ */ ((IntentDataType2) => {
   IntentDataType2[IntentDataType2["FEE"] = 1] = "FEE";
@@ -15400,6 +15519,11 @@ var PartnerFeeClaimService = class {
       invariant6__default.default(isSonicSpokeProviderType(spokeProvider), "PartnerFeeClaimService only supports Sonic spoke provider");
       invariant6__default.default(this.config.protocolIntentsContract, "protocolIntentsContract is not configured in solver config");
       const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      const outputToken = params.dstChain !== this.hubProvider.chainConfig.chain.id ? this.hubProvider.configService.getHubAssetInfo(params.dstChain, params.outputToken)?.asset : params.outputToken;
+      invariant6__default.default(
+        outputToken,
+        `hub asset not found for spoke chain token (params.outputToken): ${params.outputToken} with chain id: ${params.dstChain}`
+      );
       const rawTx = {
         from: walletAddress,
         to: this.config.protocolIntentsContract,
@@ -15408,7 +15532,7 @@ var PartnerFeeClaimService = class {
           abi: ProtocolIntentsAbi,
           functionName: "setAutoSwapPreferences",
           args: [
-            params.outputToken,
+            outputToken,
             BigInt(types.getIntentRelayChainId(params.dstChain)),
             encodeAddress(params.dstChain, params.dstAddress)
           ]