@lifi/sdk 3.6.0-beta.3 → 3.6.0-beta.5

package/src/core/EVM/checkAllowance.ts

@@ -1,8 +1,8 @@
-import type { ExtendedChain, LiFiStep, Process, ProcessType } from '@lifi/types'
+import type { ExtendedChain, LiFiStep } from '@lifi/types'
 import type { Address, Client, Hash } from 'viem'
 import { MaxUint256 } from '../../constants.js'
 import type { StatusManager } from '../StatusManager.js'
-import type { ExecutionOptions } from '../types.js'
+import type { ExecutionOptions, Process, ProcessType } from '../types.js'
 import { getAllowance } from './getAllowance.js'
 import { parseEVMErrors } from './parseEVMErrors.js'
 import { setAllowance } from './setAllowance.js'

package/src/core/EVM/parseEVMErrors.ts

@@ -1,9 +1,10 @@
-import type { LiFiStep, Process } from '@lifi/types'
+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 { fetchTxErrorDetails } from '../../utils/fetchTxErrorDetails.js'
+import type { Process } from '../types.js'
 
 export const parseEVMErrors = async (
   e: Error,
@@ -26,7 +27,10 @@ const handleSpecificErrors = async (
   step?: LiFiStep,
   process?: Process
 ) => {
-  if (e.cause?.name === 'UserRejectedRequestError') {
+  if (
+    e.name === 'UserRejectedRequestError' ||
+    e.cause?.name === 'UserRejectedRequestError'
+  ) {
     return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
   }
   // Safe Wallet via WalletConnect returns -32000 code when user rejects the signature

package/src/core/EVM/typeguards.ts

@@ -1,7 +1,7 @@
 import type { LiFiStepExtended } from '../types.js'
 import type { EVMPermitStep } from './types.js'
 
-export function isEVMPermitStep(step: LiFiStepExtended): step is EVMPermitStep {
+export function isRelayerStep(step: LiFiStepExtended): step is EVMPermitStep {
   const evmStep = step as EVMPermitStep
   return 'permit' in evmStep && 'permitData' in evmStep && 'witness' in evmStep
 }

package/src/core/EVM/utils.ts

@@ -1,9 +1,60 @@
-import type { ChainId } from '@lifi/types'
-import type { Address, Client, Transaction } from 'viem'
+import type { ChainId, ExtendedChain } from '@lifi/types'
+import type { Address, Chain, Client, Transaction } from 'viem'
 import { getBlock } from 'viem/actions'
 import { config } from '../../config.js'
 import { median } from '../../utils/median.js'
 
+type ChainBlockExplorer = {
+  name: string
+  url: string
+}
+
+type ChainBlockExplorers = {
+  [key: string]: ChainBlockExplorer
+  default: ChainBlockExplorer
+}
+
+export const convertExtendedChain = (chain: ExtendedChain): Chain => ({
+  ...chain,
+  ...chain.metamask,
+  blockExplorers: chain.metamask.blockExplorerUrls.reduce(
+    (blockExplorers, blockExplorer, index) => {
+      blockExplorers[index === 0 ? 'default' : `${index}`] = {
+        name: blockExplorer,
+        url: blockExplorer,
+      }
+      return blockExplorers
+    },
+    {} as ChainBlockExplorers
+  ),
+  name: chain.metamask.chainName,
+  rpcUrls: {
+    default: { http: chain.metamask.rpcUrls },
+    public: { http: chain.metamask.rpcUrls },
+  },
+  contracts: {
+    ...(chain.multicallAddress
+      ? { multicall3: { address: chain.multicallAddress as Address } }
+      : undefined),
+  },
+})
+
+export function isExtendedChain(chain: any): chain is ExtendedChain {
+  return (
+    typeof chain === 'object' &&
+    chain !== null &&
+    'key' in chain &&
+    'chainType' in chain &&
+    'coin' in chain &&
+    'mainnet' in chain &&
+    'logoURI' in chain &&
+    typeof chain.metamask === 'object' &&
+    chain.metamask !== null &&
+    typeof chain.nativeToken === 'object' &&
+    chain.nativeToken !== null
+  )
+}
+
 export const getMaxPriorityFeePerGas = async (
   client: Client
 ): Promise<bigint | undefined> => {

package/src/core/Solana/SolanaStepExecutor.ts

@@ -217,24 +217,10 @@ export class SolanaStepExecutor extends BaseStepExecutor {
       }
     }
 
-    // Wait for the transaction status on the destination chain
-    const transactionHash = process.txHash
-    if (!transactionHash) {
-      throw new Error('Transaction hash is undefined.')
-    }
-    if (isBridgeExecution) {
-      process = this.statusManager.findOrCreateProcess({
-        step,
-        type: 'RECEIVING_CHAIN',
-        status: 'PENDING',
-        chainId: toChain.id,
-      })
-    }
-
     await waitForDestinationChainTransaction(
       step,
-      process.type,
-      transactionHash,
+      process,
+      fromChain,
       toChain,
       this.statusManager
     )

package/src/core/Solana/parseSolanaErrors.ts

@@ -1,8 +1,9 @@
-import type { LiFiStep, Process } from '@lifi/types'
+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 parseSolanaErrors = async (
   e: Error,

package/src/core/StatusManager.ts

@@ -1,15 +1,14 @@
+import type { ChainId, LiFiStep } from '@lifi/types'
+import { executionState } from './executionState.js'
+import { getProcessMessage } from './processMessages.js'
 import type {
-  ChainId,
   Execution,
   ExecutionStatus,
-  LiFiStep,
+  LiFiStepExtended,
   Process,
   ProcessStatus,
   ProcessType,
-} from '@lifi/types'
-import { executionState } from './executionState.js'
-import { getProcessMessage } from './processMessages.js'
-import type { LiFiStepExtended } from './types.js'
+} from './types.js'
 
 export type FindOrCreateProcessProps = {
   step: LiFiStepExtended
@@ -80,17 +79,38 @@ export class StatusManager {
     return step
   }
 
+  /**
+   * Finds a process of the specified type in the step's execution
+   * @param step The step to search in
+   * @param type The process type to find
+   * @param status Optional status to update the process with if found
+   * @returns The found process or undefined if not found
+   */
+  findProcess(
+    step: LiFiStepExtended,
+    type: ProcessType,
+    status?: ProcessStatus
+  ): Process | undefined {
+    if (!step.execution?.process) {
+      throw new Error("Execution hasn't been initialized.")
+    }
+
+    const process = step.execution.process.find((p) => p.type === type)
+
+    if (process && status && process.status !== status) {
+      process.status = status
+      this.updateStepInRoute(step)
+    }
+
+    return process
+  }
+
   /**
    * Create and push a new process into the execution.
-   * @param step.step The step that should contain the new process.
-   * @param step.type Type of the process. Used to identify already existing processes.
-   * @param step.chainId Chain Id of the process.
-   * @param step.status By default created procces is set to the STARTED status. We can override new process with the needed status.
-   * @param root0
-   * @param root0.step
-   * @param root0.type
-   * @param root0.chainId
-   * @param root0.status
+   * @param step The step that should contain the new process.
+   * @param type Type of the process. Used to identify already existing processes.
+   * @param chainId Chain Id of the process.
+   * @param status By default created procces is set to the STARTED status. We can override new process with the needed status.
    * @returns Returns process.
    */
   findOrCreateProcess = ({
@@ -99,17 +119,9 @@ export class StatusManager {
     chainId,
     status,
   }: FindOrCreateProcessProps): Process => {
-    if (!step.execution?.process) {
-      throw new Error("Execution hasn't been initialized.")
-    }
-
-    const process = step.execution.process.find((p) => p.type === type)
+    const process = this.findProcess(step, type, status)
 
     if (process) {
-      if (status && process.status !== status) {
-        process.status = status
-        this.updateStepInRoute(step)
-      }
       return process
     }
 
@@ -121,7 +133,7 @@ export class StatusManager {
       chainId: chainId,
     }
 
-    step.execution.process.push(newProcess)
+    step.execution!.process.push(newProcess)
     this.updateStepInRoute(step)
     return newProcess
   }
@@ -143,7 +155,7 @@ export class StatusManager {
     if (!step.execution) {
       throw new Error("Can't update an empty step execution.")
     }
-    const currentProcess = step?.execution?.process.find((p) => p.type === type)
+    const currentProcess = this.findProcess(step, type)
 
     if (!currentProcess) {
       throw new Error("Can't find a process for the given type.")

package/src/core/UTXO/UTXOStepExecutor.ts

@@ -263,24 +263,10 @@ export class UTXOStepExecutor extends BaseStepExecutor {
       }
     }
 
-    // Wait for the transaction status on the destination chain
-    const transactionHash = process.txHash
-    if (!transactionHash) {
-      throw new Error('Transaction hash is undefined.')
-    }
-    if (isBridgeExecution) {
-      process = this.statusManager.findOrCreateProcess({
-        step,
-        type: 'RECEIVING_CHAIN',
-        status: 'PENDING',
-        chainId: toChain.id,
-      })
-    }
-
     await waitForDestinationChainTransaction(
       step,
-      process.type,
-      transactionHash,
+      process,
+      fromChain,
       toChain,
       this.statusManager,
       10_000

package/src/core/UTXO/parseUTXOErrors.ts

@@ -1,8 +1,9 @@
-import type { LiFiStep, Process } from '@lifi/types'
+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 parseUTXOErrors = async (
   e: Error,

package/src/core/processMessages.ts

@@ -1,38 +1,42 @@
-import type {
-  ProcessStatus,
-  ProcessType,
-  StatusMessage,
-  Substatus,
-} from '@lifi/types'
+import type { StatusMessage, Substatus } from '@lifi/types'
+import type { ProcessStatus } from './types.js'
+import type { ProcessType } from './types.js'
 
 const processMessages: Record<
   ProcessType,
   Partial<Record<ProcessStatus, string>>
 > = {
   TOKEN_ALLOWANCE: {
-    STARTED: 'Setting token allowance.',
-    PENDING: 'Waiting for token allowance.',
-    DONE: 'Token allowance set.',
+    STARTED: 'Setting token allowance',
+    PENDING: 'Waiting for token allowance',
+    DONE: 'Token allowance set',
   },
   SWITCH_CHAIN: {
-    PENDING: 'Chain switch required.',
-    DONE: 'Chain switched successfully.',
+    ACTION_REQUIRED: 'Chain switch required',
+    PENDING: 'Waiting for chain switch',
+    DONE: 'Chain switched',
   },
   SWAP: {
-    STARTED: 'Preparing swap transaction.',
-    ACTION_REQUIRED: 'Please sign the transaction.',
-    PENDING: 'Waiting for swap transaction.',
-    DONE: 'Swap completed.',
+    STARTED: 'Preparing swap transaction',
+    ACTION_REQUIRED: 'Please sign the transaction',
+    PENDING: 'Waiting for swap transaction',
+    DONE: 'Swap completed',
   },
   CROSS_CHAIN: {
-    STARTED: 'Preparing bridge transaction.',
-    ACTION_REQUIRED: 'Please sign the transaction.',
-    PENDING: 'Waiting for bridge transaction.',
-    DONE: 'Bridge transaction confirmed.',
+    STARTED: 'Preparing bridge transaction',
+    ACTION_REQUIRED: 'Please sign the transaction',
+    PENDING: 'Waiting for bridge transaction',
+    DONE: 'Bridge transaction confirmed',
   },
   RECEIVING_CHAIN: {
-    PENDING: 'Waiting for destination chain.',
-    DONE: 'Bridge completed.',
+    PENDING: 'Waiting for destination chain',
+    DONE: 'Bridge completed',
+  },
+  PERMIT: {
+    STARTED: 'Preparing transaction',
+    ACTION_REQUIRED: 'Sign permit message',
+    PENDING: 'Waiting for permit message',
+    DONE: 'Permit message signed',
   },
   TRANSACTION: {},
 }

package/src/core/types.ts

@@ -1,9 +1,11 @@
 import type {
   ChainType,
-  Execution,
+  FeeCost,
+  GasCost,
   LiFiStep,
   Route,
   Step,
+  Substatus,
   Token,
   TokenAmount,
 } from '@lifi/types'
@@ -117,3 +119,54 @@ export interface ExecutionOptions {
    */
   infiniteApproval?: boolean
 }
+
+export type ExecutionStatus = 'ACTION_REQUIRED' | 'PENDING' | 'FAILED' | 'DONE'
+
+export type ProcessStatus =
+  | 'STARTED'
+  | 'ACTION_REQUIRED'
+  | 'PENDING'
+  | 'FAILED'
+  | 'DONE'
+  | 'CANCELLED'
+
+export type ProcessType =
+  | 'TOKEN_ALLOWANCE'
+  | 'PERMIT'
+  | 'SWITCH_CHAIN'
+  | 'SWAP'
+  | 'CROSS_CHAIN'
+  | 'RECEIVING_CHAIN'
+  | 'TRANSACTION'
+
+export type Process = {
+  type: ProcessType
+  status: ProcessStatus
+  substatus?: Substatus
+  chainId?: number
+  txHash?: string
+  multisigTxHash?: string
+  txLink?: string
+  startedAt: number
+  doneAt?: number
+  failedAt?: number
+  message?: string
+  error?: {
+    code: string | number
+    message: string
+    htmlMessage?: string
+  }
+
+  // additional information
+  [key: string]: any
+}
+
+export interface Execution {
+  status: ExecutionStatus
+  process: Array<Process>
+  fromAmount?: string
+  toAmount?: string
+  toToken?: Token
+  feeCosts?: FeeCost[]
+  gasCosts?: GasCost[]
+}

package/src/core/waitForDestinationChainTransaction.ts

@@ -2,23 +2,40 @@ import type {
   ExtendedChain,
   ExtendedTransactionInfo,
   FullStatusData,
-  ProcessType,
 } from '@lifi/types'
 import { LiFiErrorCode } from '../errors/constants.js'
 import { getTransactionFailedMessage } from '../utils/getTransactionMessage.js'
 import type { StatusManager } from './StatusManager.js'
-import type { LiFiStepExtended } from './types.js'
+import type { LiFiStepExtended, Process } from './types.js'
 import { waitForTransactionStatus } from './waitForTransactionStatus.js'
 
 export async function waitForDestinationChainTransaction(
   step: LiFiStepExtended,
-  processType: ProcessType,
-  transactionHash: string,
+  process: Process,
+  fromChain: ExtendedChain,
   toChain: ExtendedChain,
   statusManager: StatusManager,
   pollingInterval?: number
 ): Promise<LiFiStepExtended> {
+  const transactionHash = process.txHash
+  let processType = process.type
   try {
+    // Wait for the transaction status on the destination chain
+    if (!transactionHash) {
+      throw new Error('Transaction hash is undefined.')
+    }
+
+    const isBridgeExecution = fromChain.id !== toChain.id
+    if (isBridgeExecution) {
+      const receivingChainProcess = statusManager.findOrCreateProcess({
+        step,
+        type: 'RECEIVING_CHAIN',
+        status: 'PENDING',
+        chainId: toChain.id,
+      })
+      processType = receivingChainProcess.type
+    }
+
     const statusResponse = (await waitForTransactionStatus(
       transactionHash,
       statusManager,

package/src/core/waitForTransactionStatus.ts

@@ -1,14 +1,10 @@
-import type {
-  FullStatusData,
-  LiFiStep,
-  ProcessType,
-  StatusResponse,
-} from '@lifi/types'
+import type { FullStatusData, LiFiStep, StatusResponse } from '@lifi/types'
 import { ServerError } from '../errors/errors.js'
 import { getStatus } from '../services/api.js'
 import { waitForResult } from '../utils/waitForResult.js'
 import type { StatusManager } from './StatusManager.js'
 import { getSubstatusMessage } from './processMessages.js'
+import type { ProcessType } from './types.js'
 
 const TRANSACTION_HASH_OBSERVERS: Record<string, Promise<StatusResponse>> = {}
 

package/src/errors/SDKError.ts

@@ -1,4 +1,5 @@
-import type { LiFiStep, Process } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
+import type { Process } from '../core/types.js'
 import { version } from '../version.js'
 import type { BaseError } from './baseError.js'
 import type { ErrorCode } from './constants.js'

package/src/index.ts

@@ -12,7 +12,8 @@ export {
   setTokenAllowance,
 } from './core/EVM/setAllowance.js'
 export { isEVM } from './core/EVM/types.js'
-export { isEVMPermitStep } from './core/EVM/typeguards.js'
+export { isExtendedChain, convertExtendedChain } from './core/EVM/utils.js'
+export { isRelayerStep } from './core/EVM/typeguards.js'
 export type {
   EVMProvider,
   EVMProviderOptions,
@@ -31,9 +32,14 @@ export type {
   AcceptSlippageUpdateHook,
   AcceptSlippageUpdateHookParams,
   ExchangeRateUpdateParams,
+  Execution,
   ExecutionOptions,
+  ExecutionStatus,
   InteractionSettings,
   LiFiStepExtended,
+  Process,
+  ProcessStatus,
+  ProcessType,
   RouteExecutionData,
   RouteExecutionDataDictionary,
   RouteExecutionDictionary,

package/src/utils/getTransactionMessage.ts

@@ -1,6 +1,7 @@
-import type { LiFiStep, Process } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
 import { formatUnits } from 'viem'
 import { config } from '../config.js'
+import type { Process } from '../core/types.js'
 
 export const getTransactionNotSentMessage = async (
   step?: LiFiStep,

package/src/version.ts

@@ -1,2 +1,2 @@
 export const name = '@lifi/sdk'
-export const version = '3.6.0-beta.3'
+export const version = '3.6.0-beta.5'