@lifi/sdk 3.3.0-alpha.3 → 3.3.0-beta.1

package/src/core/UTXO/utxo-stack/actions/watchBlockNumber.ts

@@ -0,0 +1,105 @@
+import { type Chain, type Client, type Transport, stringify } from 'viem'
+import { getAction } from 'viem/utils'
+import { observe } from '../utils/observe.js'
+import { poll } from '../utils/poll.js'
+import { type GetBlockCountReturnType, getBlockCount } from './getBlockCount.js'
+
+export type OnBlockNumberParameter = GetBlockCountReturnType
+export type OnBlockNumberFn = (
+  blockNumber: OnBlockNumberParameter,
+  prevBlockNumber: OnBlockNumberParameter | undefined
+) => Promise<void>
+
+export type WatchBlockNumberParameters = {
+  /** The callback to call when a new block number is received. */
+  onBlockNumber: OnBlockNumberFn
+  /** The callback to call when an error occurred when trying to get for a new block. */
+  onError?: ((error: Error) => void) | undefined
+} & {
+  /** Whether or not to emit the missed block numbers to the callback. */
+  emitMissed?: boolean | undefined
+  /** Whether or not to emit the latest block number to the callback when the subscription opens. */
+  emitOnBegin?: boolean | undefined
+  /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+  pollingInterval?: number | undefined
+}
+
+export type WatchBlockNumberReturnType = () => void
+
+/**
+ * Watches and returns incoming block numbers.
+ * @param client - Client to use
+ * @param parameters - {@link WatchBlockNumberParameters}
+ * @returns A function that can be invoked to stop watching for new block numbers. {@link WatchBlockNumberReturnType}
+ */
+export function watchBlockNumber<
+  chain extends Chain | undefined,
+  transport extends Transport,
+>(
+  client: Client<transport, chain>,
+  {
+    emitOnBegin = false,
+    emitMissed = false,
+    onBlockNumber,
+    onError,
+    pollingInterval = client.pollingInterval,
+  }: WatchBlockNumberParameters
+): WatchBlockNumberReturnType {
+  let prevBlockNumber: GetBlockCountReturnType | undefined
+
+  const observerId = stringify([
+    'watchBlockNumber',
+    client.uid,
+    emitOnBegin,
+    emitMissed,
+    pollingInterval,
+  ])
+
+  // TODO (edge cases):
+  // 1) Stop iterating block numbers if we are happy with the result of one onBlockNumber execution but there is more in the queue.
+  // 2) If we missed some time - user closed the page and came back when the block is already mined.
+  // In this case we probably want to save the block when we send the transaction and track the currently checked blocks until we find the relevant one.
+  return observe(observerId, { onBlockNumber, onError }, (emit) =>
+    poll(
+      async () => {
+        try {
+          const blockNumber = await getAction(
+            client,
+            getBlockCount,
+            'getBlockCount'
+          )({ cacheTime: 0 })
+
+          if (prevBlockNumber) {
+            // If the current block number is the same as the previous,
+            // we can skip.
+            if (blockNumber === prevBlockNumber) {
+              return
+            }
+
+            // If we have missed out on some previous blocks, and the
+            // `emitMissed` flag is truthy, let's emit those blocks.
+            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
+              for (let i = prevBlockNumber + 1; i < blockNumber; i++) {
+                await emit.onBlockNumber(i, prevBlockNumber)
+                prevBlockNumber = i
+              }
+            }
+          }
+
+          // If the next block number is greater than the previous,
+          // it is not in the past, and we can emit the new block number.
+          if (!prevBlockNumber || blockNumber > prevBlockNumber) {
+            await emit.onBlockNumber(blockNumber, prevBlockNumber)
+            prevBlockNumber = blockNumber
+          }
+        } catch (err) {
+          emit.onError?.(err as Error)
+        }
+      },
+      {
+        emitOnBegin,
+        interval: pollingInterval,
+      }
+    )
+  )
+}

package/src/core/UTXO/utxo-stack/decorators/UTXOAPIActions.ts

@@ -1,9 +1,8 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import type { Account, Chain, Client, Transport } from 'viem'
 import {
-  getBalance,
   type GetBalanceParameters,
   type GetBalanceReturnType,
+  getBalance,
 } from '../actions/getBalance.js'
 
 export type UTXOAPIActions = {

package/src/core/UTXO/utxo-stack/decorators/UTXOActions.ts

@@ -1,17 +1,17 @@
 import type { Account, Chain, Client, Transport } from 'viem'
 import {
-  getBlockCount,
   type GetBlockCountReturnType,
+  getBlockCount,
 } from '../actions/getBlockCount.js'
 import {
-  getUTXOTransaction,
   type GetUTXOTransactionParameters,
   type GetUTXOTransactionReturnType,
+  getUTXOTransaction,
 } from '../actions/getUTXOTransaction.js'
 import {
-  sendUTXOTransaction,
   type SendUTXOTransactionParameters,
   type SendUTXOTransactionReturnType,
+  sendUTXOTransaction,
 } from '../actions/sendUTXOTransaction.js'
 
 export type UTXOActions = {

package/src/core/UTXO/utxo-stack/transports/utxo/getHttpRpcClient.ts

@@ -1,4 +1,4 @@
-import { HttpRequestError, stringify, TimeoutError, withTimeout } from 'viem'
+import { HttpRequestError, TimeoutError, stringify, withTimeout } from 'viem'
 import type { HttpRequestReturnType, HttpRpcClientOptions } from 'viem/utils'
 
 export type RpcRequest = {

package/src/core/UTXO/utxo-stack/transports/utxo/types.ts

@@ -1,3 +1,4 @@
+import type { BlockStats, BlockStatsKeys } from '../../types/blockStats.js'
 import type { UTXOTransaction } from '../../types/transaction.js'
 import type { HttpRpcClient } from './getHttpRpcClient.js'
 
@@ -7,6 +8,21 @@ export type UTXOSchema = [
     Parameters: []
     ReturnType: number
   },
+  {
+    Method: 'getblockhash'
+    Parameters: [number]
+    ReturnType: string
+  },
+  {
+    Method: 'getblock'
+    Parameters: [string, number]
+    ReturnType: string
+  },
+  {
+    Method: 'getblockstats'
+    Parameters: [string | number, Array<BlockStatsKeys>?]
+    ReturnType: BlockStats
+  },
   {
     Method: 'sendrawtransaction'
     Parameters: [string, number?]

package/src/core/UTXO/utxo-stack/transports/utxo/utxo.ts

@@ -1,9 +1,9 @@
 import {
-  createTransport,
-  RpcRequestError,
-  UrlRequiredError,
   type HttpTransport,
   type HttpTransportConfig,
+  RpcRequestError,
+  UrlRequiredError,
+  createTransport,
 } from 'viem'
 import { getHttpRpcClient } from './getHttpRpcClient.js'
 import { getRpcProviderMethods } from './getRpcProviderMethods.js'

package/src/core/UTXO/utxo-stack/types/blockStats.ts

@@ -0,0 +1,35 @@
+export type BlockStats = Partial<{
+  avgfee: number
+  avgfeerate: number
+  avgtxsize: number
+  blockhash: string
+  feerate_percentiles: number[]
+  height: number
+  ins: number
+  maxfee: number
+  maxfeerate: number
+  maxtxsize: number
+  medianfee: number
+  mediantime: number
+  mediantxsize: number
+  minfee: number
+  minfeerate: number
+  mintxsize: number
+  outs: number
+  subsidy: number
+  swtotal_size: number
+  swtotal_weight: number
+  swtxs: number
+  time: number
+  total_out: number
+  total_size: number
+  total_weight: number
+  totalfee: number
+  txs: number
+  utxo_increase: number
+  utxo_size_inc: number
+  utxo_increase_actual: number
+  utxo_size_inc_actual: number
+}>
+
+export type BlockStatsKeys = keyof BlockStats

package/src/core/UTXO/utxo-stack/utils/cancelTransaction.ts

@@ -0,0 +1,75 @@
+import { Psbt, address } from 'bitcoinjs-lib'
+
+interface InputData {
+  hash: Uint8Array
+  index: number
+  nonWitnessUtxo?: Uint8Array
+  witnessUtxo?: {
+    script: Uint8Array
+    value: bigint
+  }
+  redeemScript?: Uint8Array
+  witnessScript?: Uint8Array
+}
+
+export function cancelTransaction(psbt: Psbt, accountAddress: string): Psbt {
+  const newPsbt = new Psbt()
+  const inputs = psbt.data.inputs
+  const txInputs = psbt.txInputs
+
+  // Add inputs to the new PSBT
+  for (let i = 0; i < inputs.length; i++) {
+    const input = inputs[i]
+    const txInput = txInputs[i]
+    const inputData: InputData = {
+      hash: txInput.hash,
+      index: txInput.index,
+    }
+
+    // Include UTXO information
+    if (input.nonWitnessUtxo) {
+      inputData.nonWitnessUtxo = input.nonWitnessUtxo
+    } else if (input.witnessUtxo) {
+      inputData.witnessUtxo = input.witnessUtxo
+    } else {
+      throw new Error('Input UTXO information is missing')
+    }
+
+    // Include scripts if necessary
+    if (input.redeemScript) {
+      inputData.redeemScript = input.redeemScript
+    }
+    if (input.witnessScript) {
+      inputData.witnessScript = input.witnessScript
+    }
+
+    newPsbt.addInput(inputData)
+  }
+
+  // Compute total output amount from the original transaction
+  const outputs = psbt.txOutputs
+  let totalOutputValue = BigInt(0)
+
+  for (const output of outputs) {
+    totalOutputValue += output.value
+  }
+
+  if (totalOutputValue <= BigInt(0)) {
+    throw new Error('Total output value must be greater than zero')
+  }
+
+  // Create the output to send funds back to sender's address
+  const outputScript = address.toOutputScript(accountAddress)
+  newPsbt.addOutput({
+    script: outputScript,
+    value: totalOutputValue,
+  })
+
+  // Modify the input sequence number to enable RBF
+  newPsbt.txInputs.forEach((_, index) => {
+    // Set sequence number to less than 0xfffffffe, e.g., 0xfffffffd
+    newPsbt.setInputSequence(index, 0xfffffffd)
+  })
+
+  return newPsbt
+}

package/src/core/UTXO/utxo-stack/utils/modifyFee.ts

@@ -0,0 +1,78 @@
+import { Psbt, address } from 'bitcoinjs-lib'
+
+interface InputData {
+  hash: Uint8Array
+  index: number
+  nonWitnessUtxo?: Uint8Array
+  witnessUtxo?: {
+    script: Uint8Array
+    value: bigint
+  }
+  redeemScript?: Uint8Array
+  witnessScript?: Uint8Array
+}
+
+export function modifyFee(psbt: Psbt, newFee: bigint, accountAddress: string) {
+  const newPsbt = new Psbt()
+  const inputs = psbt.data.inputs
+  const outputs = psbt.txOutputs
+
+  // Add inputs to the new PSBT
+  for (let i = 0; i < inputs.length; i++) {
+    const input = inputs[i]
+    const inputData: InputData = {
+      hash: psbt.txInputs[i].hash,
+      index: psbt.txInputs[i].index,
+    }
+
+    // Include UTXO information
+    if (input.nonWitnessUtxo) {
+      inputData.nonWitnessUtxo = input.nonWitnessUtxo
+    } else if (input.witnessUtxo) {
+      inputData.witnessUtxo = input.witnessUtxo
+    }
+
+    // Include scripts if necessary
+    if (input.redeemScript) {
+      inputData.redeemScript = input.redeemScript
+    }
+    if (input.witnessScript) {
+      inputData.witnessScript = input.witnessScript
+    }
+
+    newPsbt.addInput(inputData)
+  }
+
+  const changeOutputScript = address.toOutputScript(accountAddress)
+
+  // Add outputs to the new PSBT
+  for (const output of outputs) {
+    const outputData = {
+      script: output.script,
+      value: output.value,
+    }
+
+    const scriptsAreEqual =
+      output.script.length === changeOutputScript.length &&
+      output.script.every((value, index) => value === changeOutputScript[index])
+
+    if (scriptsAreEqual) {
+      outputData.value = output.value - newFee
+      if (outputData.value < 0) {
+        throw new Error(
+          'Insufficient funds to adjust the fee by the specified amount.'
+        )
+      }
+    }
+
+    newPsbt.addOutput(outputData)
+  }
+
+  // Modify the input sequence number to enable RBF
+  newPsbt.txInputs.forEach((_, index) => {
+    // Set sequence number to less than 0xfffffffe, e.g., 0xfffffffd
+    newPsbt.setInputSequence(index, 0xfffffffd)
+  })
+
+  return newPsbt
+}

package/src/core/UTXO/utxo-stack/utils/observe.ts

@@ -0,0 +1,81 @@
+import type { MaybePromise } from 'viem'
+
+type Callback = ((...args: any[]) => any) | undefined
+type Callbacks = Record<string, Callback>
+
+/** @internal */
+export const listenersCache = /*#__PURE__*/ new Map<
+  string,
+  { id: number; fns: Callbacks }[]
+>()
+/** @internal */
+export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
+
+type EmitFunction<callbacks extends Callbacks> = (
+  emit: callbacks
+) => MaybePromise<void | (() => void)>
+
+let callbackCount = 0
+
+/**
+ * @description Sets up an observer for a given function. If another function
+ * is set up under the same observer id, the function will only be called once
+ * for both instances of the observer.
+ */
+export function observe<callbacks extends Callbacks>(
+  observerId: string,
+  callbacks: callbacks,
+  fn: EmitFunction<callbacks>
+) {
+  const callbackId = ++callbackCount
+
+  const getListeners = () => listenersCache.get(observerId) || []
+
+  const unsubscribe = () => {
+    const listeners = getListeners()
+    listenersCache.set(
+      observerId,
+      listeners.filter((cb: any) => cb.id !== callbackId)
+    )
+  }
+
+  const unwatch = () => {
+    const cleanup = cleanupCache.get(observerId)
+    if (getListeners().length === 1 && cleanup) {
+      cleanup()
+    }
+    unsubscribe()
+  }
+
+  const listeners = getListeners()
+  listenersCache.set(observerId, [
+    ...listeners,
+    { id: callbackId, fns: callbacks },
+  ])
+
+  if (listeners && listeners.length > 0) {
+    return unwatch
+  }
+
+  const emit: callbacks = {} as callbacks
+  for (const key in callbacks) {
+    emit[key] = ((
+      ...args: Parameters<NonNullable<callbacks[keyof callbacks]>>
+    ) => {
+      const listeners = getListeners()
+      if (listeners.length === 0) {
+        return
+      }
+      for (const listener of listeners) {
+        listener.fns[key]?.(...args)
+      }
+    }) as callbacks[Extract<keyof callbacks, string>]
+  }
+
+  const cleanup = fn(emit)
+  if (typeof cleanup === 'function') {
+    cleanupCache.set(observerId, cleanup)
+  }
+
+  return unwatch
+}

package/src/core/UTXO/utxo-stack/utils/poll.ts

@@ -0,0 +1,48 @@
+import { sleep } from '../../../../utils/sleep.js'
+
+type PollOptions<T> = {
+  // Whether or not to emit when the polling starts.
+  emitOnBegin?: boolean | undefined
+  // The initial wait time (in ms) before polling.
+  initialWaitTime?: ((data: T | undefined) => Promise<number>) | undefined
+  // The interval (in ms).
+  interval: number
+}
+
+/**
+ * @description Polls a function at a specified interval.
+ */
+export function poll<T>(
+  fn: ({ unpoll }: { unpoll: () => void }) => Promise<T | undefined>,
+  { emitOnBegin, initialWaitTime, interval }: PollOptions<T>
+) {
+  let active = true
+
+  const unwatch = () => {
+    active = false
+  }
+
+  const watch = async () => {
+    let data: T | undefined = undefined
+    if (emitOnBegin) {
+      data = await fn({ unpoll: unwatch })
+    }
+
+    const initialWait = (await initialWaitTime?.(data)) ?? interval
+    await sleep(initialWait)
+
+    const poll = async () => {
+      if (!active) {
+        return
+      }
+      await fn({ unpoll: unwatch })
+      await sleep(interval)
+      poll()
+    }
+
+    poll()
+  }
+  watch()
+
+  return unwatch
+}

package/src/core/checkBalance.ts

@@ -28,16 +28,10 @@ export const checkBalance = async (
       } else {
         const neeeded = 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 ${neeeded} ${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}.`
+          _errorMessage += `If the problem consists, please delete this transfer and start a new one with a maximum of ${current} ${token.symbol}.`
         }
 
         throw new BalanceError('The balance is too low.')

package/src/core/execution.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
 import type { Route } from '@lifi/types'
 import { config } from '../config.js'
 import { executionState } from './executionState.js'

package/src/core/processMessages.ts

@@ -1,8 +1,8 @@
-import {
-  type ProcessStatus,
-  type ProcessType,
-  type StatusMessage,
-  type Substatus,
+import type {
+  ProcessStatus,
+  ProcessType,
+  StatusMessage,
+  Substatus,
 } from '@lifi/types'
 
 const processMessages: Record<

package/src/core/rpc.ts

@@ -1,4 +1,4 @@
-import { type ChainId } from '@lifi/types'
+import type { ChainId } from '@lifi/types'
 import { config } from '../config.js'
 
 export const getRpcUrl = async (chainId: ChainId): Promise<string> => {

package/src/core/stepComparison.ts

@@ -42,7 +42,7 @@ export const stepComparison = async (
     // The user declined the new exchange rate, so we are not going to proceed
     throw new TransactionError(
       LiFiErrorCode.ExchangeRateUpdateCanceled,
-      `Exchange rate has changed!\nTransaction was not sent, your funds are still in your wallet.\nThe exchange rate has changed and the previous estimation can not be fulfilled due to value loss.`
+      'Exchange rate has changed!\nTransaction was not sent, your funds are still in your wallet.\nThe exchange rate has changed and the previous estimation can not be fulfilled due to value loss.'
     )
   }
 

package/src/core/utils.ts

@@ -1,4 +1,4 @@
-import { type LiFiStep } from '@lifi/types'
+import type { LiFiStep } from '@lifi/types'
 
 /**
  * Used to check if changed exchange rate is in the range of slippage threshold.

package/src/core/waitForReceivingTransaction.ts

@@ -17,59 +17,55 @@ export async function waitForReceivingTransaction(
   statusManager: StatusManager,
   processType: ProcessType,
   step: LiFiStep,
-  interval: number = 5_000
+  interval = 5_000
 ): Promise<StatusResponse> {
-  const _getStatus = (): Promise<StatusResponse | undefined> =>
-    new Promise(async (resolve, reject) => {
-      let statusResponse: StatusResponse
-      try {
-        statusResponse = await getStatus({
-          fromChain: step.action.fromChainId,
-          toChain: step.action.toChainId,
-          txHash,
-          ...(step.tool !== 'custom' && { bridge: step.tool }),
-        })
-      } catch (e: any) {
-        console.debug('Fetching status from backend failed.', e)
-        return resolve(undefined)
-      }
-
-      switch (statusResponse.status) {
-        case 'DONE':
-          return resolve(statusResponse)
-        case 'PENDING':
-          statusManager?.updateProcess(step, processType, 'PENDING', {
-            substatus: statusResponse.substatus,
-            substatusMessage:
-              statusResponse.substatusMessage ||
-              getSubstatusMessage(
-                statusResponse.status,
-                statusResponse.substatus
-              ),
-            txLink: (statusResponse as FullStatusData).bridgeExplorerLink,
-          })
-          return resolve(undefined)
-        case 'NOT_FOUND':
-          return resolve(undefined)
-        case 'INVALID':
-        case 'FAILED':
-        default:
-          return reject()
-      }
+  const _getStatus = (): Promise<StatusResponse | undefined> => {
+    return getStatus({
+      fromChain: step.action.fromChainId,
+      toChain: step.action.toChainId,
+      txHash,
+      ...(step.tool !== 'custom' && { bridge: step.tool }),
     })
+      .then((statusResponse) => {
+        switch (statusResponse.status) {
+          case 'DONE':
+            return statusResponse
+          case 'PENDING':
+            statusManager?.updateProcess(step, processType, 'PENDING', {
+              substatus: statusResponse.substatus,
+              substatusMessage:
+                statusResponse.substatusMessage ||
+                getSubstatusMessage(
+                  statusResponse.status,
+                  statusResponse.substatus
+                ),
+              txLink: (statusResponse as FullStatusData).bridgeExplorerLink,
+            })
+            return undefined
+          case 'NOT_FOUND':
+            return undefined
+          default:
+            return Promise.reject()
+        }
+      })
+      .catch((e) => {
+        console.debug('Fetching status from backend failed.', e)
+        return undefined
+      })
+  }
 
-  let status
+  let status = TRANSACTION_HASH_OBSERVERS[txHash]
 
-  if (txHash in TRANSACTION_HASH_OBSERVERS) {
-    status = await TRANSACTION_HASH_OBSERVERS[txHash]
-  } else {
-    TRANSACTION_HASH_OBSERVERS[txHash] = waitForResult(_getStatus, interval)
-    status = await TRANSACTION_HASH_OBSERVERS[txHash]
+  if (!status) {
+    status = waitForResult(_getStatus, interval)
+    TRANSACTION_HASH_OBSERVERS[txHash] = status
   }
 
-  if (!('receiving' in status)) {
+  const resolvedStatus = await status
+
+  if (!('receiving' in resolvedStatus)) {
     throw new ServerError("Status doesn't contain receiving information.")
   }
 
-  return status
+  return resolvedStatus
 }

package/src/createConfig.ts

@@ -1,9 +1,8 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
 import { ChainType } from '@lifi/types'
 import { config } from './config.js'
 import { checkPackageUpdates } from './helpers.js'
 import { getChains } from './services/api.js'
-import type { SDKConfig } from './types/index.js'
+import type { SDKConfig } from './types/internal.js'
 import { name, version } from './version.js'
 
 function createBaseConfig(options: SDKConfig) {