@lifi/sdk 3.6.14-beta.0 → 3.7.0-alpha.0

package/src/core/Sui/getSuiNSAddress.ts

@@ -0,0 +1,40 @@
+import { SuiClient } from '@mysten/sui/client'
+
+const SNS_REGISTRY_ID =
+  '0x6e0ddefc0ad3ed64f53f5f91b7023077b2f7c131d7e6d5e0d1a0e4e6f1a2c3b4'
+
+export async function getSuiNSAddress(
+  name: string,
+  rpcUrl?: string
+): Promise<string | undefined> {
+  const client = new SuiClient({
+    url: rpcUrl || 'https://fullnode.mainnet.sui.io:443',
+  })
+
+  try {
+    const result = await client.getObject({
+      id: SNS_REGISTRY_ID,
+      options: {
+        showContent: true,
+      },
+    })
+
+    if (!result.data?.content) {
+      return
+    }
+
+    const registry = result.data.content as any
+    const nameRecord = registry.fields.records.find(
+      (record: any) => record.fields.name === name
+    )
+
+    if (!nameRecord) {
+      return
+    }
+
+    return nameRecord.fields.address
+  } catch (error) {
+    console.error('Error resolving SuiNS address:', error)
+    return
+  }
+}

package/src/core/Sui/parseSuiErrors.ts

@@ -0,0 +1,55 @@
+import type { LiFiStep } from '@lifi/types'
+import { SDKError } from '../../errors/SDKError.js'
+import { BaseError } from '../../errors/baseError.js'
+import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError, UnknownError } from '../../errors/errors.js'
+import type { Process } from '../types.js'
+
+export const parseSuiErrors = async (
+  e: Error,
+  step?: LiFiStep,
+  process?: Process
+): Promise<SDKError> => {
+  if (e instanceof SDKError) {
+    e.step = e.step ?? step
+    e.process = e.process ?? process
+    return e
+  }
+
+  const baseError = handleSpecificErrors(e)
+
+  return new SDKError(baseError, step, process)
+}
+
+const handleSpecificErrors = (e: any) => {
+  const isRejection =
+    typeof e === 'string'
+      ? e.toLowerCase().includes('reject')
+      : e.message?.toLowerCase().includes('reject')
+
+  if (isRejection) {
+    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
+  }
+
+  if (
+    e.message?.toLowerCase().includes('transaction') &&
+    (e.message?.toLowerCase().includes('failed') ||
+      e.message?.toLowerCase().includes('error'))
+  ) {
+    return new TransactionError(LiFiErrorCode.TransactionFailed, e.message, e)
+  }
+
+  if (e.message?.includes('simulate') || e.message?.includes('simulation')) {
+    return new TransactionError(
+      LiFiErrorCode.TransactionSimulationFailed,
+      e.message,
+      e
+    )
+  }
+
+  if (e instanceof BaseError) {
+    return e
+  }
+
+  return new UnknownError(e.message || ErrorMessage.UnknownError, e)
+}

package/src/core/Sui/suiClient.ts

@@ -0,0 +1,51 @@
+import { ChainId } from '@lifi/types'
+import { SuiClient } from '@mysten/sui/client'
+import { getRpcUrls } from '../rpc.js'
+
+const clients = new Map<string, SuiClient>()
+
+/**
+ * Initializes the Sui clients if they haven't been initialized yet.
+ * @returns - Promise that resolves when clients are initialized.
+ */
+export const ensureClients = async (): Promise<void> => {
+  const rpcUrls = await getRpcUrls(ChainId.SUI)
+  for (const rpcUrl of rpcUrls) {
+    if (!clients.get(rpcUrl)) {
+      const client = new SuiClient({ url: rpcUrl })
+      clients.set(rpcUrl, client)
+    }
+  }
+}
+
+/**
+ * Wrapper around getting the client (RPC provider) for Sui
+ * @returns - Sui RPC clients
+ */
+export const getSuiClients = async (): Promise<SuiClient[]> => {
+  await ensureClients()
+  return Array.from(clients.values())
+}
+
+/**
+ * Calls a function on the SuiClient instances with retry logic.
+ * @param fn - The function to call, which receives a SuiClient instance.
+ * @returns - The result of the function call.
+ */
+export async function callSuiWithRetry<R>(
+  fn: (client: SuiClient) => Promise<R>
+): Promise<R> {
+  // Ensure clients are initialized
+  await ensureClients()
+  let lastError: any = null
+  for (const client of clients.values()) {
+    try {
+      const result = await fn(client)
+      return result
+    } catch (error) {
+      lastError = error
+    }
+  }
+  // Throw the last encountered error
+  throw lastError
+}

package/src/core/Sui/types.ts

@@ -0,0 +1,23 @@
+import { ChainType } from '@lifi/types'
+import type { WalletWithRequiredFeatures } from '@mysten/wallet-standard'
+import type { SDKProvider, StepExecutorOptions } from '../types.js'
+
+export interface SuiProviderOptions {
+  getWallet?: () => Promise<WalletWithRequiredFeatures>
+}
+
+export interface SuiProvider extends SDKProvider {
+  setOptions(options: SuiProviderOptions): void
+}
+
+export function isSui(provider: SDKProvider): provider is SuiProvider {
+  return provider.type === ChainType.MVM
+}
+
+export interface SuiStepExecutorOptions extends StepExecutorOptions {
+  wallet: WalletWithRequiredFeatures
+}
+
+export const SuiTokenShortAddress = '0x2::sui::SUI'
+export const SuiTokenLongAddress =
+  '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'

package/src/core/checkBalance.ts

@@ -27,9 +27,9 @@ export const checkBalance = async (
         // adjust amount in slippage limits
         step.action.fromAmount = currentBalance.toString()
       } else {
-        const neeeded = formatUnits(neededBalance, token.decimals)
+        const needed = formatUnits(neededBalance, token.decimals)
         const current = formatUnits(currentBalance, token.decimals)
-        let errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${neeeded} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
+        let errorMessage = `Your ${token.symbol} balance is too low, you try to transfer ${needed} ${token.symbol}, but your wallet only holds ${current} ${token.symbol}. No funds have been sent.`
 
         if (currentBalance !== 0n) {
           errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`

package/src/core/rpc.ts

@@ -9,7 +9,7 @@ export const getRpcUrl = async (chainId: ChainId): Promise<string> => {
 export const getRpcUrls = async (chainId: ChainId): Promise<string[]> => {
   const rpcUrls = (await config.getRPCUrls())[chainId]
   if (!rpcUrls?.length) {
-    throw new Error('RPC URL not found')
+    throw new Error(`RPC URL not found for chainId: ${chainId}`)
   }
   return rpcUrls
 }

package/src/createConfig.ts

@@ -20,7 +20,7 @@ function createBaseConfig(options: SDKConfig) {
 
 export async function createChainsConfig() {
   config.loading = getChains({
-    chainTypes: [ChainType.EVM, ChainType.SVM, ChainType.UTXO],
+    chainTypes: [ChainType.EVM, ChainType.SVM, ChainType.UTXO, ChainType.MVM],
   })
     .then((chains) => config.setChains(chains))
     .catch()

package/src/index.ts

@@ -15,10 +15,7 @@ export { isEVM } from './core/EVM/types.js'
 export { isBatchingSupported } from './core/EVM/isBatchingSupported.js'
 export { isExtendedChain, convertExtendedChain } from './core/EVM/utils.js'
 export { isRelayerStep, isGaslessStep } from './core/EVM/typeguards.js'
-export type {
-  EVMProvider,
-  EVMProviderOptions,
-} from './core/EVM/types.js'
+export type { EVMProvider, EVMProviderOptions } from './core/EVM/types.js'
 export { StatusManager } from './core/StatusManager.js'
 export {
   executeRoute,
@@ -96,11 +93,7 @@ export {
 export { getNameServiceAddress } from './services/getNameServiceAddress.js'
 export type { RPCUrls, SDKBaseConfig, SDKConfig } from './types/internal.js'
 export { BaseError } from './errors/baseError.js'
-export {
-  ErrorMessage,
-  ErrorName,
-  LiFiErrorCode,
-} from './errors/constants.js'
+export { ErrorMessage, ErrorName, LiFiErrorCode } from './errors/constants.js'
 export type { ErrorCode } from './errors/constants.js'
 export {
   BalanceError,
@@ -113,3 +106,6 @@ export {
 } from './errors/errors.js'
 export { HTTPError } from './errors/httpError.js'
 export { SDKError } from './errors/SDKError.js'
+export { Sui } from './core/Sui/Sui.js'
+export { isSui } from './core/Sui/types.js'
+export type { SuiProvider, SuiProviderOptions } from './core/Sui/types.js'

package/src/services/balance.ts

@@ -1,4 +1,4 @@
-import { ChainType, type Token, type TokenAmount } from '@lifi/types'
+import type { Token, TokenAmount } from '@lifi/types'
 import { config } from '../config.js'
 import { ValidationError } from '../errors/errors.js'
 import { isToken } from '../typeguards.js'
@@ -74,14 +74,9 @@ export const getTokenBalancesByChain = async (
     Object.keys(tokensByChain).map(async (chainIdStr) => {
       const chainId = Number.parseInt(chainIdStr)
       const chain = await config.getChainById(chainId)
-      const tokenAddress = tokensByChain[chainId][0].address
       const provider = config
         .get()
-        .providers.find((provider) =>
-          chain.chainType === ChainType.UTXO
-            ? provider.isAddress(walletAddress)
-            : provider.isAddress(tokenAddress)
-        )
+        .providers.find((provider) => provider.isAddress(walletAddress))
       if (!provider) {
         throw new Error(
           `SDK Token Provider for ${chain.chainType} is not found.`

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.6.14-beta.0'
+export const version = '3.7.0-alpha.0'