@lifi/sdk 3.7.0-beta.2 → 3.7.0-beta.3

package/src/core/Sui/SuiStepExecutor.ts

@@ -0,0 +1,203 @@
+import {
+  type WalletWithRequiredFeatures,
+  signAndExecuteTransaction,
+} from '@mysten/wallet-standard'
+import { config } from '../../config.js'
+import { LiFiErrorCode } from '../../errors/constants.js'
+import { TransactionError } from '../../errors/errors.js'
+import { getStepTransaction } from '../../services/api.js'
+import { BaseStepExecutor } from '../BaseStepExecutor.js'
+import { checkBalance } from '../checkBalance.js'
+import { stepComparison } from '../stepComparison.js'
+import type { LiFiStepExtended, TransactionParameters } from '../types.js'
+import { waitForDestinationChainTransaction } from '../waitForDestinationChainTransaction.js'
+import { parseSuiErrors } from './parseSuiErrors.js'
+import { callSuiWithRetry } from './suiClient.js'
+import type { SuiStepExecutorOptions } from './types.js'
+
+export class SuiStepExecutor extends BaseStepExecutor {
+  private wallet: WalletWithRequiredFeatures
+
+  constructor(options: SuiStepExecutorOptions) {
+    super(options)
+    this.wallet = options.wallet
+  }
+
+  checkWallet = (step: LiFiStepExtended) => {
+    // Prevent execution of the quote by wallet different from the one which requested the quote
+    if (
+      !this.wallet.accounts?.some?.(
+        (account) => account.address === step.action.fromAddress
+      )
+    ) {
+      throw new TransactionError(
+        LiFiErrorCode.WalletChangedDuringExecution,
+        'The wallet address that requested the quote does not match the wallet address attempting to sign the transaction.'
+      )
+    }
+  }
+
+  executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
+    step.execution = this.statusManager.initExecutionObject(step)
+
+    const fromChain = await config.getChainById(step.action.fromChainId)
+    const toChain = await config.getChainById(step.action.toChainId)
+
+    const isBridgeExecution = fromChain.id !== toChain.id
+    const currentProcessType = isBridgeExecution ? 'CROSS_CHAIN' : 'SWAP'
+
+    let process = this.statusManager.findOrCreateProcess({
+      step,
+      type: currentProcessType,
+      chainId: fromChain.id,
+    })
+
+    if (process.status !== 'DONE') {
+      try {
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'STARTED'
+        )
+
+        // Check balance
+        await checkBalance(step.action.fromAddress!, step)
+
+        // Create new transaction
+        if (!step.transactionRequest) {
+          const { execution, ...stepBase } = step
+          const updatedStep = await getStepTransaction(stepBase)
+          const comparedStep = await stepComparison(
+            this.statusManager,
+            step,
+            updatedStep,
+            this.allowUserInteraction,
+            this.executionOptions
+          )
+          Object.assign(step, {
+            ...comparedStep,
+            execution: step.execution,
+          })
+        }
+
+        if (!step.transactionRequest?.data) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionUnprepared,
+            'Unable to prepare transaction.'
+          )
+        }
+
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'ACTION_REQUIRED'
+        )
+
+        if (!this.allowUserInteraction) {
+          return step
+        }
+
+        let transactionRequest: TransactionParameters = {
+          data: step.transactionRequest.data,
+        }
+
+        if (this.executionOptions?.updateTransactionRequestHook) {
+          const customizedTransactionRequest: TransactionParameters =
+            await this.executionOptions.updateTransactionRequestHook({
+              requestType: 'transaction',
+              ...transactionRequest,
+            })
+
+          transactionRequest = {
+            ...transactionRequest,
+            ...customizedTransactionRequest,
+          }
+        }
+
+        const transactionRequestData = transactionRequest.data
+
+        if (!transactionRequestData) {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionUnprepared,
+            'Unable to prepare transaction.'
+          )
+        }
+
+        this.checkWallet(step)
+
+        // We give users 2 minutes to sign the transaction
+        const signedTx = await signAndExecuteTransaction(this.wallet, {
+          account: this.wallet.accounts.find(
+            (account) => account.address === step.action.fromAddress
+          )!,
+          chain: 'sui:mainnet',
+          transaction: {
+            toJSON: async () => transactionRequestData,
+          },
+        })
+
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'PENDING'
+        )
+
+        const result = await callSuiWithRetry((client) =>
+          client.waitForTransaction({
+            digest: signedTx.digest,
+            options: {
+              showEffects: true,
+            },
+          })
+        )
+
+        if (result.effects?.status.status !== 'success') {
+          throw new TransactionError(
+            LiFiErrorCode.TransactionFailed,
+            `Transaction failed: ${result.effects?.status.error}`
+          )
+        }
+
+        // Transaction has been confirmed and we can update the process
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'PENDING',
+          {
+            txHash: result.digest,
+            txLink: `${fromChain.metamask.blockExplorerUrls[0]}txblock/${result.digest}`,
+          }
+        )
+
+        if (isBridgeExecution) {
+          process = this.statusManager.updateProcess(step, process.type, 'DONE')
+        }
+      } catch (e: any) {
+        const error = await parseSuiErrors(e, step, process)
+        process = this.statusManager.updateProcess(
+          step,
+          process.type,
+          'FAILED',
+          {
+            error: {
+              message: error.cause.message,
+              code: error.code,
+            },
+          }
+        )
+        this.statusManager.updateExecution(step, 'FAILED')
+        throw error
+      }
+    }
+
+    await waitForDestinationChainTransaction(
+      step,
+      process,
+      fromChain,
+      toChain,
+      this.statusManager
+    )
+
+    return step
+  }
+}

package/src/core/Sui/getSuiBalance.ts

@@ -0,0 +1,86 @@
+import type { Token, TokenAmount } from '@lifi/types'
+import { withDedupe } from '../../utils/withDedupe.js'
+import { callSuiWithRetry } from './suiClient.js'
+import { SuiTokenLongAddress, SuiTokenShortAddress } from './types.js'
+
+export async function getSuiBalance(
+  walletAddress: string,
+  tokens: Token[]
+): Promise<TokenAmount[]> {
+  if (tokens.length === 0) {
+    return []
+  }
+
+  const { chainId } = tokens[0]
+  for (const token of tokens) {
+    if (token.chainId !== chainId) {
+      console.warn('Requested tokens have to be on the same chain.')
+    }
+  }
+
+  return getSuiBalanceDefault(chainId, tokens, walletAddress)
+}
+
+const getSuiBalanceDefault = async (
+  _chainId: number,
+  tokens: Token[],
+  walletAddress: string
+): Promise<TokenAmount[]> => {
+  const [coins, checkpoint] = await Promise.allSettled([
+    withDedupe(
+      () =>
+        callSuiWithRetry((client) =>
+          client.getAllBalances({
+            owner: walletAddress,
+          })
+        ),
+      { id: `${getSuiBalanceDefault.name}.getAllBalances` }
+    ),
+    withDedupe(
+      () =>
+        callSuiWithRetry((client) =>
+          client.getLatestCheckpointSequenceNumber()
+        ),
+      { id: `${getSuiBalanceDefault.name}.getLatestCheckpointSequenceNumber` }
+    ),
+  ])
+
+  const coinsResult = coins.status === 'fulfilled' ? coins.value : []
+  const blockNumber =
+    checkpoint.status === 'fulfilled' ? BigInt(checkpoint.value) : 0n
+
+  const walletTokenAmounts = coinsResult.reduce(
+    (tokenAmounts, coin) => {
+      const amount = BigInt(coin.totalBalance)
+      if (amount > 0n) {
+        tokenAmounts[coin.coinType] = amount
+      }
+      return tokenAmounts
+    },
+    {} as Record<string, bigint>
+  )
+
+  const suiTokenBalance = coinsResult.find(
+    (coin) => coin.coinType === SuiTokenShortAddress
+  )
+  if (suiTokenBalance?.totalBalance) {
+    walletTokenAmounts[SuiTokenLongAddress] = BigInt(
+      suiTokenBalance.totalBalance
+    )
+  }
+
+  const tokenAmounts: TokenAmount[] = tokens.map((token) => {
+    if (walletTokenAmounts[token.address]) {
+      return {
+        ...token,
+        amount: walletTokenAmounts[token.address],
+        blockNumber,
+      }
+    }
+    return {
+      ...token,
+      blockNumber,
+    }
+  })
+  return tokenAmounts
+}

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.7.0-beta.2'
+export const version = '3.7.0-beta.3'