@lifi/sdk 3.0.0-alpha.27 → 3.0.0-alpha.29

package/src/core/EVM/EVMStepExecutor.ts

@@ -1,8 +1,4 @@
-import type {
-  ExtendedTransactionInfo,
-  FullStatusData,
-  LiFiStep,
-} from '@lifi/types'
+import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
 import type {
   Address,
   Hash,
@@ -25,7 +21,11 @@ import {
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
 import { stepComparison } from '../stepComparison.js'
-import type { StepExecutorOptions, TransactionParameters } from '../types.js'
+import type {
+  LiFiStepExtended,
+  StepExecutorOptions,
+  TransactionParameters,
+} from '../types.js'
 import { getSubstatusMessage } from '../utils.js'
 import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { checkAllowance } from './checkAllowance.js'
@@ -56,7 +56,7 @@ export class EVMStepExecutor extends BaseStepExecutor {
     throw new Error('checkChain is not implemented.')
   }
 
-  executeStep = async (step: LiFiStep): Promise<LiFiStep> => {
+  executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
     // Make sure that the chain is still correct
 
     // Find if it's bridging and the step is waiting for a transaction on the receiving chain

package/src/core/EVM/switchChain.ts

@@ -1,8 +1,7 @@
-import type { LiFiStep } from '@lifi/types'
 import type { WalletClient } from 'viem'
 import { LiFiErrorCode, ProviderError } from '../../utils/errors.js'
 import type { StatusManager } from '../StatusManager.js'
-import type { SwitchChainHook } from '../types.js'
+import type { LiFiStepExtended, SwitchChainHook } from '../types.js'
 
 /**
  * This method checks whether the wallet client is configured for the correct chain.
@@ -24,7 +23,7 @@ import type { SwitchChainHook } from '../types.js'
 export const switchChain = async (
   walletClient: WalletClient,
   statusManager: StatusManager,
-  step: LiFiStep,
+  step: LiFiStepExtended,
   allowUserInteraction: boolean,
   switchChainHook?: SwitchChainHook
 ): Promise<WalletClient | undefined> => {

package/src/core/Solana/SolanaStepExecutor.ts

@@ -1,9 +1,5 @@
-import type {
-  ExtendedTransactionInfo,
-  FullStatusData,
-  LiFiStep,
-} from '@lifi/types'
-import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import type { ExtendedTransactionInfo, FullStatusData } from '@lifi/types'
+import type { Adapter } from '@solana/wallet-adapter-base'
 import {
   VersionedTransaction,
   type TransactionConfirmationStrategy,
@@ -20,24 +16,28 @@ import {
 import { BaseStepExecutor } from '../BaseStepExecutor.js'
 import { checkBalance } from '../checkBalance.js'
 import { stepComparison } from '../stepComparison.js'
-import type { StepExecutorOptions, TransactionParameters } from '../types.js'
+import type {
+  LiFiStepExtended,
+  StepExecutorOptions,
+  TransactionParameters,
+} from '../types.js'
 import { getSubstatusMessage } from '../utils.js'
 import { waitForReceivingTransaction } from '../waitForReceivingTransaction.js'
 import { getSolanaConnection } from './connection.js'
 
 export interface SolanaStepExecutorOptions extends StepExecutorOptions {
-  walletAdapter: WalletAdapter
+  walletAdapter: Adapter
 }
 
 export class SolanaStepExecutor extends BaseStepExecutor {
-  private walletAdapter: WalletAdapter
+  private walletAdapter: Adapter
 
   constructor(options: SolanaStepExecutorOptions) {
     super(options)
     this.walletAdapter = options.walletAdapter
   }
 
-  executeStep = async (step: LiFiStep): Promise<LiFiStep> => {
+  executeStep = async (step: LiFiStepExtended): Promise<LiFiStepExtended> => {
     step.execution = this.statusManager.initExecutionObject(step)
 
     const fromChain = await config.getChainById(step.action.fromChainId)

package/src/core/Solana/getSolanaBalance.ts

@@ -1,5 +1,6 @@
 import type { ChainId, Token, TokenAmount } from '@lifi/types'
 import { PublicKey } from '@solana/web3.js'
+import { wrappedSolAddress } from '../../constants.js'
 import { getSolanaConnection } from './connection.js'
 import { TokenProgramAddress } from './types.js'
 
@@ -26,36 +27,45 @@ const getSolanaBalanceDefault = async (
   walletAddress: string
 ): Promise<TokenAmount[]> => {
   const connection = await getSolanaConnection()
-  const blockNumber = await connection.getSlot()
   const accountPublicKey = new PublicKey(walletAddress)
   const tokenProgramPublicKey = new PublicKey(TokenProgramAddress)
-  const response = await connection.getParsedTokenAccountsByOwner(
-    accountPublicKey,
-    {
+  const [slot, balance, tokenAccountsByOwner] = await Promise.allSettled([
+    connection.getSlot(),
+    connection.getBalance(accountPublicKey),
+    connection.getParsedTokenAccountsByOwner(accountPublicKey, {
       programId: tokenProgramPublicKey,
-    }
-  )
-  const walletTokenAmounts = response.value.reduce(
-    (tokenAmounts, value) => {
-      const amount = BigInt(value.account.data.parsed.info.tokenAmount.amount)
-      if (amount > 0n) {
-        tokenAmounts[value.account.data.parsed.info.mint] = amount
-      }
-      return tokenAmounts
-    },
-    {} as Record<string, bigint>
-  )
+    }),
+  ])
+  const blockNumber = slot.status === 'fulfilled' ? BigInt(slot.value) : 0n
+  const solBalance = balance.status === 'fulfilled' ? BigInt(balance.value) : 0n
+  const walletTokenAmounts =
+    tokenAccountsByOwner.status === 'fulfilled'
+      ? tokenAccountsByOwner.value.value.reduce(
+          (tokenAmounts, value) => {
+            const amount = BigInt(
+              value.account.data.parsed.info.tokenAmount.amount
+            )
+            if (amount > 0n) {
+              tokenAmounts[value.account.data.parsed.info.mint] = amount
+            }
+            return tokenAmounts
+          },
+          {} as Record<string, bigint>
+        )
+      : {}
+  walletTokenAmounts[wrappedSolAddress] ??= 0n
+  walletTokenAmounts[wrappedSolAddress] += solBalance
   const tokenAmounts: TokenAmount[] = tokens.map((token) => {
     if (walletTokenAmounts[token.address]) {
       return {
         ...token,
         amount: walletTokenAmounts[token.address],
-        blockNumber: BigInt(blockNumber),
+        blockNumber,
       }
     }
     return {
       ...token,
-      blockNumber: BigInt(blockNumber),
+      blockNumber,
     }
   })
   return tokenAmounts

package/src/core/Solana/types.ts

@@ -1,9 +1,9 @@
 import { ChainType, type ChainId } from '@lifi/types'
-import type { WalletAdapter } from '@solana/wallet-adapter-base'
+import type { Adapter } from '@solana/wallet-adapter-base'
 import { type SDKProvider } from '../types.js'
 
 export interface SolanaProviderOptions {
-  getWalletAdapter?: () => Promise<WalletAdapter>
+  getWalletAdapter?: () => Promise<Adapter>
 }
 
 export interface SolanaProvider extends SDKProvider {

package/src/core/StatusManager.ts

@@ -8,6 +8,7 @@ import type {
 } from '@lifi/types'
 import { emptyExecution } from '@lifi/types'
 import { executionState } from './executionState.js'
+import type { LiFiStepExtended } from './types.js'
 import { getProcessMessage } from './utils.js'
 
 interface Receipt {
@@ -53,7 +54,7 @@ export class StatusManager {
    * @param step  The current step in execution
    * @returns The initialized execution object for this step and a function to update this step
    */
-  initExecutionObject = (step: LiFiStep): Execution => {
+  initExecutionObject = (step: LiFiStepExtended): Execution => {
     if (!step.execution) {
       step.execution = structuredClone<Execution>(emptyExecution)
       step.execution.status = 'PENDING'
@@ -76,7 +77,11 @@ export class StatusManager {
    * @param receipt Optional. Information about received tokens
    * @returns The step with the updated execution object
    */
-  updateExecution(step: LiFiStep, status: Status, receipt?: Receipt): LiFiStep {
+  updateExecution(
+    step: LiFiStepExtended,
+    status: Status,
+    receipt?: Receipt
+  ): LiFiStep {
     if (!step.execution) {
       throw Error("Can't update empty execution.")
     }
@@ -99,7 +104,7 @@ export class StatusManager {
    * @returns Returns process.
    */
   findOrCreateProcess = (
-    step: LiFiStep,
+    step: LiFiStepExtended,
     type: ProcessType,
     status?: Status
   ): Process => {
@@ -138,7 +143,7 @@ export class StatusManager {
    * @returns The update process
    */
   updateProcess = (
-    step: LiFiStep,
+    step: LiFiStepExtended,
     type: ProcessType,
     status: Status,
     params?: OptionalParameters
@@ -199,7 +204,7 @@ export class StatusManager {
    * @param step The step where the process should be removed from
    * @param type  The process type to remove
    */
-  removeProcess = (step: LiFiStep, type: ProcessType): void => {
+  removeProcess = (step: LiFiStepExtended, type: ProcessType): void => {
     if (!step.execution) {
       throw new Error("Execution hasn't been initialized.")
     }

package/src/core/execution.ts

@@ -3,7 +3,7 @@ import type { Route } from '@lifi/types'
 import { config } from '../config.js'
 import { executionState } from './executionState.js'
 import { prepareRestart } from './prepareRestart.js'
-import type { ExecutionOptions } from './types.js'
+import type { ExecutionOptions, RouteExtended } from './types.js'
 
 /**
  * Execute a route.
@@ -15,7 +15,7 @@ import type { ExecutionOptions } from './types.js'
 export const executeRoute = async (
   route: Route,
   executionOptions?: ExecutionOptions
-): Promise<Route> => {
+): Promise<RouteExtended> => {
   // Deep clone to prevent side effects
   const clonedRoute = structuredClone<Route>(route)
 
@@ -42,7 +42,7 @@ export const executeRoute = async (
 export const resumeRoute = async (
   route: Route,
   executionOptions?: ExecutionOptions
-): Promise<Route> => {
+): Promise<RouteExtended> => {
   // Deep clone to prevent side effects
   const clonedRoute = structuredClone<Route>(route)
 
@@ -74,9 +74,9 @@ export const resumeRoute = async (
 }
 
 const executeSteps = async (
-  route: Route,
+  route: RouteExtended,
   executionOptions?: ExecutionOptions
-): Promise<Route> => {
+): Promise<RouteExtended> => {
   executionState.create(route, executionOptions)
 
   // Loop over steps and execute them
@@ -195,17 +195,17 @@ export const stopRouteExecution = (route: Route): Route => {
     })
   }
   executionState.delete(route.id)
-  return route
+  return execution.route
 }
 
 /**
  * Get the list of active routes.
  * @returns A list of routes.
  */
-export const getActiveRoutes = (): Route[] => {
+export const getActiveRoutes = (): RouteExtended[] => {
   return Object.values(executionState.state)
     .map((dict) => dict?.route)
-    .filter(Boolean) as Route[]
+    .filter(Boolean) as RouteExtended[]
 }
 
 /**
@@ -213,6 +213,6 @@ export const getActiveRoutes = (): Route[] => {
  * @param routeId - A route id.
  * @returns The updated route.
  */
-export const getActiveRoute = (routeId: string): Route | undefined => {
+export const getActiveRoute = (routeId: string): RouteExtended | undefined => {
   return executionState.get(routeId)?.route
 }

package/src/core/executionState.ts

@@ -1,20 +1,19 @@
-import type { Route } from '@lifi/types'
-import type { ExecutionOptions, StepExecutor } from './types.js'
+import type { ExecutionOptions, RouteExtended, StepExecutor } from './types.js'
 
 export interface ExecutionData {
-  route: Route
+  route: RouteExtended
   executors: StepExecutor[]
   executionOptions?: ExecutionOptions
-  promise?: Promise<Route>
+  promise?: Promise<RouteExtended>
 }
 
 export interface ExecutionState {
   state: Partial<Record<string, ExecutionData>>
   get(routeId: string): ExecutionData | undefined
   create(
-    route: Route,
+    route: RouteExtended,
     executionOptions?: ExecutionOptions,
-    promise?: Promise<Route>
+    promise?: Promise<RouteExtended>
   ): ExecutionData
   delete(routeId: string): void
 }

package/src/core/prepareRestart.ts

@@ -1,6 +1,7 @@
-import type { LiFiStep, Route } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
+import type { LiFiStepExtended, RouteExtended } from './types.js'
 
-export const prepareRestart = async (route: Route) => {
+export const prepareRestart = async (route: RouteExtended) => {
   for (let index = 0; index < route.steps.length; index++) {
     const step = route.steps[index]
     const stepHasFailed = step.execution?.status === 'FAILED'
@@ -68,7 +69,7 @@ export const prepareRestart = async (route: Route) => {
 // }
 // }
 
-const deleteFailedProcesses = (step: LiFiStep) => {
+const deleteFailedProcesses = (step: LiFiStepExtended) => {
   if (step.execution) {
     step.execution.process = step.execution.process.filter(
       (process) => process.status === 'DONE'

package/src/core/types.ts

@@ -1,5 +1,6 @@
 import type {
   ChainType,
+  Execution,
   LiFiStep,
   Route,
   Token,
@@ -29,7 +30,15 @@ export interface StepExecutor {
   allowUserInteraction: boolean
   allowExecution: boolean
   setInteraction(settings?: InteractionSettings): void
-  executeStep(step: LiFiStep): Promise<LiFiStep>
+  executeStep(step: LiFiStepExtended): Promise<LiFiStepExtended>
+}
+
+export interface RouteExtended extends Omit<Route, 'steps'> {
+  steps: LiFiStepExtended[]
+}
+
+export interface LiFiStepExtended extends LiFiStep {
+  execution?: Execution
 }
 
 export type TransactionParameters = {

package/src/createConfig.ts

@@ -20,27 +20,29 @@ function createBaseConfig(options: SDKOptions) {
 export async function createChainsConfig() {
   const _config = config.get()
   const chainTypes = _config.providers?.map((provider) => provider.type)
-  config.loading = getChains({ chainTypes: chainTypes }).then((chains) => {
-    config.chains = chains
-    const evmProvider = _config.providers?.find(isEVM)
-    const multicallAddresses: Partial<Record<ChainId, string>> = {}
-    for (const chain of chains) {
-      const chainId = chain.id as ChainId
+  config.loading = getChains({ chainTypes: chainTypes })
+    .then((chains) => {
+      config.chains = chains
+      const evmProvider = _config.providers?.find(isEVM)
+      const multicallAddresses: Partial<Record<ChainId, string>> = {}
+      for (const chain of chains) {
+        const chainId = chain.id as ChainId
 
-      // set RPCs if they were not configured by the user before
-      if (!_config.rpcUrls[chainId]?.length) {
-        _config.rpcUrls[chainId] = chain.metamask.rpcUrls
-      }
+        // set RPCs if they were not configured by the user before
+        if (!_config.rpcUrls[chainId]?.length) {
+          _config.rpcUrls[chainId] = chain.metamask.rpcUrls
+        }
 
-      // set multicall addresses if they exist and were not configured by the user before
-      if (chain.multicallAddress && !evmProvider?.multicall?.[chainId]) {
-        multicallAddresses[chainId] = chain.multicallAddress
+        // set multicall addresses if they exist and were not configured by the user before
+        if (chain.multicallAddress && !evmProvider?.multicall?.[chainId]) {
+          multicallAddresses[chainId] = chain.multicallAddress
+        }
       }
-    }
-    evmProvider?.setOptions({
-      multicall: multicallAddresses,
+      evmProvider?.setOptions({
+        multicall: multicallAddresses,
+      })
     })
-  })
+    .catch()
   await config.loading
 }
 

package/src/request.ts

@@ -29,35 +29,35 @@ export const request = async <T = Response>(
     if (!options.skipTrackingHeaders) {
       if (apiKey) {
         options.headers = {
-          ...options?.headers,
+          ...options.headers,
           'x-lifi-api-key': apiKey,
         }
       }
 
       if (userId) {
         options.headers = {
-          ...options?.headers,
+          ...options.headers,
           'x-lifi-userid': userId,
         }
       }
 
       if (widgetVersion) {
         options.headers = {
-          ...options?.headers,
+          ...options.headers,
           'x-lifi-widget': widgetVersion,
         }
       }
 
       if (version) {
         options.headers = {
-          ...options?.headers,
+          ...options.headers,
           'x-lifi-sdk': version,
         }
       }
 
       // integrator is mandatory during SDK initialization
       options.headers = {
-        ...options?.headers,
+        ...options.headers,
         'x-lifi-integrator': integrator,
       }
     }

package/src/services/api.ts

@@ -21,13 +21,14 @@ import type {
   TokensResponse,
   ToolsRequest,
   ToolsResponse,
+  WalletAnalytics,
+  WalletAnalyticsRequest,
 } from '@lifi/types'
 import { config } from '../config.js'
 import { request } from '../request.js'
 import { isRoutesRequest, isStep } from '../typeguards.js'
 import { ValidationError } from '../utils/errors.js'
 import { parseBackendError } from '../utils/parseBackendError.js'
-
 /**
  * Fetch information about a Token
  * @param chain - Id or key of the chain that contains the token
@@ -470,3 +471,37 @@ export const getConnections = async (
     throw await parseBackendError(e)
   }
 }
+
+export const getTransactionHistory = async (
+  walletAnalyticsRequest: WalletAnalyticsRequest
+): Promise<WalletAnalytics> => {
+  const _config = config.get()
+
+  if (!walletAnalyticsRequest.fromTimestamp) {
+    throw new ValidationError('Required parameter "fromTimestamp" is missing.')
+  }
+
+  if (!walletAnalyticsRequest.toTimestamp) {
+    throw new ValidationError('Required parameter "toTimestamp" is missing.')
+  }
+
+  const url = new URL(
+    `${_config.apiUrl}/analytics/wallets/${walletAnalyticsRequest.walletAddress}`
+  )
+
+  url.searchParams.append(
+    'fromTimestamp',
+    walletAnalyticsRequest.fromTimestamp.toString()
+  )
+
+  url.searchParams.append(
+    'toTimestamp',
+    walletAnalyticsRequest.toTimestamp.toString()
+  )
+  try {
+    const response = await request<WalletAnalytics>(url)
+    return response
+  } catch (e) {
+    throw await parseBackendError(e)
+  }
+}

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.0.0-alpha.27'
+export const version = '3.0.0-alpha.29'