@sodax/sdk 1.0.4-beta-rc1 → 1.0.4-beta

package/dist/index.cjs

@@ -6871,6 +6871,7 @@ var getAllLegacybnUSDTokens = () => {
 var ConfigService = class {
   serviceConfig;
   backendApiService;
+  sharedConfig;
   initialized = false;
   sodaxConfig;
   // data structures for quick lookup
@@ -6883,7 +6884,7 @@ var ConfigService = class {
   supportedTokensPerChain;
   moneyMarketReserveAssetsSet;
   spokeChainIdsSet;
-  constructor({ backendApiService, config }) {
+  constructor({ backendApiService, config, sharedConfig }) {
     this.serviceConfig = {
       backendApiUrl: config?.backendApiUrl ?? DEFAULT_BACKEND_API_ENDPOINT,
       timeout: config?.timeout ?? DEFAULT_BACKEND_API_TIMEOUT
@@ -6891,6 +6892,10 @@ var ConfigService = class {
     this.backendApiService = backendApiService;
     this.sodaxConfig = types.defaultSodaxConfig;
     this.loadSodaxConfigDataStructures(this.sodaxConfig);
+    this.sharedConfig = {
+      ...types.defaultSharedConfig,
+      ...sharedConfig
+    };
   }
   async initialize() {
     try {
@@ -7507,6 +7512,30 @@ var EvmVaultTokenService = class {
     });
     return { decimals, depositFee, withdrawalFee, maxDeposit, isSupported };
   }
+  /**
+   * Fetches token information for a list of tokens in a vault using a multicall.
+   * @param vault - The address of the vault contract.
+   * @param tokens - An array of token addresses to fetch info for.
+   * @param publicClient - The Viem PublicClient instance used to interact with the blockchain.
+   * @returns A promise that resolves to an array of TokenInfo objects, one for each provided token.
+   */
+  static async getTokenInfos(vault, tokens, publicClient) {
+    const infos = await publicClient.multicall({
+      contracts: tokens.map(
+        (token) => ({
+          address: vault,
+          abi: vaultTokenAbi,
+          functionName: "tokenInfo",
+          args: [token]
+        })
+      ),
+      allowFailure: false
+    });
+    return infos.map((info) => {
+      const [decimals, depositFee, withdrawalFee, maxDeposit, isSupported] = info;
+      return { decimals, depositFee, withdrawalFee, maxDeposit, isSupported };
+    });
+  }
   /**
    * Retrieves the reserves of the vault.
    * @param vault - The address of the vault.
@@ -10460,6 +10489,38 @@ var StellarSpokeService = class _StellarSpokeService {
     const availableTrustAmount = limit - balance;
     return availableTrustAmount >= amount;
   }
+  /**
+   * Check if the user has sufficent trustline established for the token.
+   * @param token - The token address to check the trustline for.
+   * @param amount - The amount of tokens to check the trustline for.
+   * @param spokeProvider - The Stellar spoke provider.
+   * @returns True if the user has sufficent trustline established for the token, false otherwise.
+   */
+  static async walletHasSufficientTrustline(token, amount, walletAddress, horizonRpcUrl) {
+    const stellarChainConfig = types.spokeChainConfig[types.STELLAR_MAINNET_CHAIN_ID];
+    if (token.toLowerCase() === stellarChainConfig.nativeToken.toLowerCase() || token.toLowerCase() === stellarChainConfig.supportedTokens.legacybnUSD.address.toLowerCase()) {
+      return true;
+    }
+    const trustlineConfig = stellarChainConfig.trustlineConfigs.find(
+      (config) => config.contractId.toLowerCase() === token.toLowerCase()
+    );
+    if (!trustlineConfig) {
+      throw new Error(`Trustline config not found for token: ${token}`);
+    }
+    const server = new stellarSdk.Horizon.Server(horizonRpcUrl, { allowHttp: true });
+    const { balances } = await server.accounts().accountId(walletAddress).call();
+    const tokenBalance = balances.find(
+      (balance2) => "limit" in balance2 && "balance" in balance2 && "asset_code" in balance2 && trustlineConfig.assetCode.toLowerCase() === balance2.asset_code?.toLowerCase() && "asset_issuer" in balance2 && trustlineConfig.assetIssuer.toLowerCase() === balance2.asset_issuer?.toLowerCase()
+    );
+    if (!tokenBalance) {
+      console.error(`No token balances found for token: ${token}`);
+      return false;
+    }
+    const limit = parseToStroops(tokenBalance.limit);
+    const balance = parseToStroops(tokenBalance.balance);
+    const availableTrustAmount = limit - balance;
+    return availableTrustAmount >= amount;
+  }
   /**
    * Request a trustline for a given token and amount.
    * @param token - The token address to request the trustline for.
@@ -11878,7 +11939,7 @@ var SolanaSpokeService = class _SolanaSpokeService {
     }
     return spokeProvider.walletProvider.sendTransaction(serializedTransaction);
   }
-  static async waitForConfirmation(spokeProvider, signature, commitment = "finalized", timeoutMs = 12e4) {
+  static async waitForConfirmation(spokeProvider, signature, commitment = "finalized", timeoutMs = 6e4) {
     try {
       const connection = new web3_js.Connection(spokeProvider.chainConfig.rpcUrl, commitment);
       const deadline = Date.now() + timeoutMs;
@@ -13919,7 +13980,27 @@ var MoneyMarketService = class _MoneyMarketService {
         );
       }
       const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
-      if (isStellarSpokeProviderType(spokeProvider) && (params.action === "supply" || params.action === "repay")) {
+      if (params.toChainId === types.STELLAR_MAINNET_CHAIN_ID && params.toAddress) {
+        const targetHasTrustline = await StellarSpokeService.walletHasSufficientTrustline(
+          params.token,
+          params.amount,
+          params.toAddress,
+          this.configService.sharedConfig[types.STELLAR_MAINNET_CHAIN_ID].horizonRpcUrl
+        );
+        let srcHasTrustline = true;
+        if (isStellarSpokeProviderType(spokeProvider)) {
+          srcHasTrustline = await StellarSpokeService.hasSufficientTrustline(
+            params.token,
+            params.amount,
+            spokeProvider
+          );
+        }
+        return {
+          ok: true,
+          value: targetHasTrustline && srcHasTrustline
+        };
+      }
+      if (isStellarSpokeProviderType(spokeProvider)) {
         return {
           ok: true,
           value: await StellarSpokeService.hasSufficientTrustline(params.token, params.amount, spokeProvider)
@@ -13953,6 +14034,9 @@ var MoneyMarketService = class _MoneyMarketService {
    * Approve amount spending if isAllowanceValid returns false.
    * For evm spoke chains, the spender is the asset manager contract while
    * for sonic spoke (hub) chain, the spender is the user router contract.
+   * NOTE: Stellar requires trustline when being either sender or receiver. Thus
+   * you should make sure that both src and destination wallets have sufficient trustlines.
+   * Make sure to invoke this method using wallet address which is about to receive the tokens!
    * @param token - ERC20 token address
    * @param amount - Amount to approve
    * @param spender - Spender address
@@ -13994,10 +14078,6 @@ var MoneyMarketService = class _MoneyMarketService {
       }
       const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
       if (isStellarSpokeProviderType(spokeProvider)) {
-        invariant6__default.default(
-          params.action === "supply" || params.action === "repay",
-          "Invalid action (only supply and repay are supported on stellar)"
-        );
         const result = await StellarSpokeService.requestTrustline(params.token, params.amount, spokeProvider, raw);
         return {
           ok: true,
@@ -14188,7 +14268,7 @@ var MoneyMarketService = class _MoneyMarketService {
         ok: true,
         value: txResult,
         data: {
-          address: toHubWallet,
+          address: fromHubWallet,
           payload: data
         }
       };
@@ -14255,7 +14335,7 @@ var MoneyMarketService = class _MoneyMarketService {
       if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id || params.toChainId && params.toAddress && params.toChainId !== this.hubProvider.chainConfig.chain.id) {
         const packetResult = await relayTxAndWaitPacket(
           txResult.value,
-          isSolanaSpokeProviderType(spokeProvider) ? txResult.data : void 0,
+          spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
           spokeProvider,
           this.config.relayerApiEndpoint,
           timeout
@@ -14540,7 +14620,7 @@ var MoneyMarketService = class _MoneyMarketService {
       if (spokeProvider.chainConfig.chain.id !== this.hubProvider.chainConfig.chain.id) {
         const packetResult = await relayTxAndWaitPacket(
           txResult.value,
-          spokeProvider instanceof SolanaSpokeProvider ? txResult.data : void 0,
+          isSolanaSpokeProviderType(spokeProvider) ? txResult.data : void 0,
           spokeProvider,
           this.config.relayerApiEndpoint,
           timeout
@@ -14640,7 +14720,7 @@ var MoneyMarketService = class _MoneyMarketService {
       ok: true,
       value: txResult,
       data: {
-        address: toHubWallet,
+        address: fromHubWallet,
         payload: data
       }
     };
@@ -15042,7 +15122,8 @@ var Sodax = class {
       config: {
         backendApiUrl: config?.backendApiConfig?.baseURL,
         timeout: config?.backendApiConfig?.timeout
-      }
+      },
+      sharedConfig: config?.sharedConfig
     });
     this.hubProvider = new EvmHubProvider({ config: config?.hubProviderConfig, configService: this.config });
     this.swaps = config && config.swaps ? new SwapService({
@@ -16529,7 +16610,7 @@ var BridgeService = class {
    *
    * @param spokeProvider - The spoke provider instance
    * @param token - The token address to query the balance for
-   * @returns {Promise<bigint>} - The token balance as a bigint value
+   * @returns {Promise<BridgeLimit>} - The max bridgeable amount with corresponding decimals
    */
   async getBridgeableAmount(from, to) {
     try {
@@ -16537,51 +16618,59 @@ var BridgeService = class {
       const toHubAsset = this.configService.getHubAssetInfo(to.xChainId, to.address);
       invariant6__default.default(fromHubAsset, `Hub asset not found for token ${from.address} on chain ${from.xChainId}`);
       invariant6__default.default(toHubAsset, `Hub asset not found for token ${to.address} on chain ${to.xChainId}`);
-      const [depositTokenInfo, reserves] = await Promise.all([
-        EvmVaultTokenService.getTokenInfo(fromHubAsset.vault, fromHubAsset.asset, this.hubProvider.publicClient),
+      invariant6__default.default(this.isBridgeable({ from, to }), `Tokens ${from.address} and ${to.address} are not bridgeable`);
+      const [tokenInfos, reserves] = await Promise.all([
+        EvmVaultTokenService.getTokenInfos(
+          fromHubAsset.vault,
+          [fromHubAsset.asset, toHubAsset.asset],
+          this.hubProvider.publicClient
+        ),
         EvmVaultTokenService.getVaultReserves(toHubAsset.vault, this.hubProvider.publicClient)
       ]);
-      if (!this.configService.isValidVault(fromHubAsset.asset) && this.configService.isValidVault(toHubAsset.asset)) {
-        const fromTokenIndex2 = reserves.tokens.findIndex((t) => t.toLowerCase() === fromHubAsset.asset.toLowerCase());
-        invariant6__default.default(
-          fromTokenIndex2 !== -1,
-          `Token ${fromHubAsset.asset} not found in the vault reserves for chain ${from.xChainId}`
-        );
-        const fromTokenDepositedAmount2 = reserves.balances[fromTokenIndex2] ?? 0n;
-        const availableDeposit2 = depositTokenInfo.maxDeposit - fromTokenDepositedAmount2;
+      invariant6__default.default(tokenInfos.length === 2, `Expected 2 token infos, got ${tokenInfos.length}`);
+      const [fromTokenInfo, toTokenInfo] = tokenInfos;
+      invariant6__default.default(fromTokenInfo, "From token info not found");
+      invariant6__default.default(toTokenInfo, "To token info not found");
+      if (!fromTokenInfo.isSupported) {
         return {
           ok: true,
-          value: availableDeposit2
+          value: {
+            amount: 0n,
+            decimals: fromTokenInfo.decimals,
+            type: "DEPOSIT_LIMIT"
+          }
         };
       }
-      if (this.configService.isValidVault(fromHubAsset.asset)) {
-        const tokenIndex2 = reserves.tokens.findIndex((t) => t.toLowerCase() === toHubAsset.asset.toLowerCase());
-        invariant6__default.default(
-          tokenIndex2 !== -1,
-          `Token ${toHubAsset.asset} not found in the vault reserves for chain ${to.xChainId}`
-        );
-        const assetManagerBalance2 = reserves.balances[tokenIndex2] ?? 0n;
+      if (from.xChainId !== this.hubProvider.chainConfig.chain.id && to.xChainId === this.hubProvider.chainConfig.chain.id) {
+        const fromTokenDepositedAmount2 = this.findTokenBalanceInReserves(reserves, from);
+        const availableDeposit2 = fromTokenInfo.maxDeposit - fromTokenDepositedAmount2;
         return {
           ok: true,
-          value: assetManagerBalance2
+          value: {
+            amount: availableDeposit2,
+            decimals: fromTokenInfo.decimals,
+            type: "DEPOSIT_LIMIT"
+          }
         };
       }
-      const fromTokenIndex = reserves.tokens.findIndex((t) => t.toLowerCase() === fromHubAsset.asset.toLowerCase());
-      invariant6__default.default(
-        fromTokenIndex !== -1,
-        `Token ${fromHubAsset.asset} not found in the vault reserves for chain ${from.xChainId}`
-      );
-      const fromTokenDepositedAmount = reserves.balances[fromTokenIndex] ?? 0n;
-      const availableDeposit = depositTokenInfo.maxDeposit - fromTokenDepositedAmount;
-      const tokenIndex = reserves.tokens.findIndex((t) => t.toLowerCase() === toHubAsset.asset.toLowerCase());
-      invariant6__default.default(
-        tokenIndex !== -1,
-        `Token ${toHubAsset.asset} not found in the vault reserves for chain ${to.xChainId}`
-      );
-      const assetManagerBalance = reserves.balances[tokenIndex] ?? 0n;
+      if (from.xChainId === this.hubProvider.chainConfig.chain.id && to.xChainId !== this.hubProvider.chainConfig.chain.id) {
+        return {
+          ok: true,
+          value: {
+            amount: this.findTokenBalanceInReserves(reserves, to),
+            decimals: toTokenInfo.decimals,
+            type: "WITHDRAWAL_LIMIT"
+          }
+        };
+      }
+      const fromTokenDepositedAmount = this.findTokenBalanceInReserves(reserves, from);
+      const availableDeposit = fromTokenInfo.maxDeposit - fromTokenDepositedAmount;
+      const assetManagerBalance = this.findTokenBalanceInReserves(reserves, to);
+      const availableDepositNormalised = BigNumber4__default.default(availableDeposit).shiftedBy(-fromTokenInfo.decimals);
+      const assetManagerBalanceNormalised = BigNumber4__default.default(assetManagerBalance).shiftedBy(-toTokenInfo.decimals);
       return {
         ok: true,
-        value: availableDeposit < assetManagerBalance ? availableDeposit : assetManagerBalance
+        value: availableDepositNormalised.isLessThan(assetManagerBalanceNormalised) ? { amount: availableDeposit, decimals: fromTokenInfo.decimals, type: "DEPOSIT_LIMIT" } : { amount: assetManagerBalance, decimals: toTokenInfo.decimals, type: "WITHDRAWAL_LIMIT" }
       };
     } catch (error) {
       console.error(error);
@@ -16658,6 +16747,13 @@ var BridgeService = class {
     }
     return bridgeableTokens;
   }
+  findTokenBalanceInReserves(reserves, token) {
+    const hubAsset = this.configService.getHubAssetInfo(token.xChainId, token.address);
+    invariant6__default.default(hubAsset, `Hub asset not found for token ${token.address} on chain ${token.xChainId}`);
+    const tokenIndex = reserves.tokens.findIndex((t) => t.toLowerCase() === hubAsset.asset.toLowerCase());
+    invariant6__default.default(tokenIndex !== -1, `Token ${hubAsset.asset} not found in the vault reserves for chain ${token.xChainId}`);
+    return reserves.balances[tokenIndex] ?? 0n;
+  }
 };
 var StakingLogic = class _StakingLogic {
   constructor() {