@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/core/UTXO/UTXOStepExecutor.ts

@@ -1,338 +0,0 @@
-import type { Client, ReplacementReason } from '@bigmi/core'
-import {
-  AddressType,
-  getAddressInfo,
-  hexToUnit8Array,
-  signPsbt,
-  waitForTransaction,
-  withTimeout,
-} from '@bigmi/core'
-import * as ecc from '@bitcoinerlab/secp256k1'
-import { ChainId } from '@lifi/types'
-import { address, initEccLib, networks, Psbt } from 'bitcoinjs-lib'
-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,
-  StepExecutorOptions,
-  TransactionParameters,
-} from '../types.js'
-import { waitForDestinationChainTransaction } from '../waitForDestinationChainTransaction.js'
-import { getUTXOPublicClient } from './getUTXOPublicClient.js'
-import { parseUTXOErrors } from './parseUTXOErrors.js'
-import { generateRedeemScript, isPsbtFinalized, toXOnly } from './utils.js'
-
-interface UTXOStepExecutorOptions extends StepExecutorOptions {
-  client: Client
-}
-
-export class UTXOStepExecutor extends BaseStepExecutor {
-  private client: Client
-
-  constructor(options: UTXOStepExecutorOptions) {
-    super(options)
-    this.client = options.client
-  }
-
-  checkClient = (step: LiFiStepExtended) => {
-    // TODO: check chain and possibly implement chain switch?
-    // Prevent execution of the quote by wallet different from the one which requested the quote
-    if (this.client.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,
-    })
-
-    const publicClient = await getUTXOPublicClient(ChainId.BTC)
-
-    if (process.status !== 'DONE') {
-      try {
-        let txHash: string
-        let txHex: string
-        if (process.txHash) {
-          // Make sure that the chain is still correct
-          this.checkClient(step)
-
-          // Wait for exiting transaction
-          txHash = process.txHash
-          txHex = process.txHex
-        } else {
-          process = this.statusManager.updateProcess(
-            step,
-            process.type,
-            'STARTED'
-          )
-
-          // Check balance
-          await checkBalance(this.client.account!.address, step)
-
-          // Create new transaction
-          if (!step.transactionRequest) {
-            // biome-ignore lint/correctness/noUnusedVariables: destructuring
-            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,
-            }
-          }
-
-          if (!transactionRequest.data) {
-            throw new TransactionError(
-              LiFiErrorCode.TransactionUnprepared,
-              'Unable to prepare transaction.'
-            )
-          }
-
-          this.checkClient(step)
-
-          const psbtHex = transactionRequest.data
-
-          // Initialize ECC library required for Taproot operations
-          // https://github.com/bitcoinjs/bitcoinjs-lib?tab=readme-ov-file#using-taproot
-          initEccLib(ecc)
-
-          const psbt = Psbt.fromHex(psbtHex, { network: networks.bitcoin })
-
-          psbt.data.inputs.forEach((input, index) => {
-            const accountAddress = input.witnessUtxo
-              ? address.fromOutputScript(
-                  input.witnessUtxo.script,
-                  networks.bitcoin
-                )
-              : (this.client.account?.address as string)
-            const addressInfo = getAddressInfo(accountAddress)
-            if (addressInfo.type === AddressType.p2tr) {
-              // Taproot (P2TR) addresses require specific PSBT fields for proper signing
-
-              // tapInternalKey: Required for Taproot key-path spending
-              // Most wallets  / libraries usually handle this already
-              if (!input.tapInternalKey) {
-                const pubKey = this.client.account?.publicKey
-                if (pubKey) {
-                  const tapInternalKey = toXOnly(hexToUnit8Array(pubKey))
-                  psbt.updateInput(index, {
-                    tapInternalKey,
-                  })
-                }
-              }
-              // sighashType: Required by bitcoinjs-lib even though the bitcoin protocol allows defaults
-              // check if sighashType is default (0) or not set (undefined)
-              if (!input.sighashType) {
-                psbt.updateInput(index, {
-                  sighashType: 1, // Default to Transaction.SIGHASH_ALL - 1
-                })
-              }
-            }
-            // redeemScript: Required by Pay-to-Script-Hash (P2SH) addresses for proper spending
-            if (addressInfo.type === AddressType.p2sh) {
-              if (!input.redeemScript) {
-                const pubKey = this.client.account?.publicKey
-                if (pubKey) {
-                  psbt.updateInput(index, {
-                    redeemScript: generateRedeemScript(hexToUnit8Array(pubKey)),
-                  })
-                }
-              }
-            }
-          })
-
-          const inputsToSign = Array.from(
-            psbt.data.inputs
-              .reduce((map, input, index) => {
-                const accountAddress = input.witnessUtxo
-                  ? address.fromOutputScript(
-                      input.witnessUtxo.script,
-                      networks.bitcoin
-                    )
-                  : (this.client.account?.address as string)
-                if (map.has(accountAddress)) {
-                  map.get(accountAddress).signingIndexes.push(index)
-                } else {
-                  map.set(accountAddress, {
-                    address: accountAddress,
-                    sigHash: 1, // Default to Transaction.SIGHASH_ALL - 1
-                    signingIndexes: [index],
-                  })
-                }
-                return map
-              }, new Map())
-              .values()
-          )
-
-          // We give users 10 minutes to sign the transaction or it should be considered expired
-          const signedPsbtHex = await withTimeout(
-            () =>
-              signPsbt(this.client, {
-                psbt: psbt.toHex(),
-                inputsToSign: inputsToSign,
-                finalize: false,
-              }),
-            {
-              timeout: 600_000,
-              errorInstance: new TransactionError(
-                LiFiErrorCode.TransactionExpired,
-                'Transaction has expired.'
-              ),
-            }
-          )
-
-          const signedPsbt = Psbt.fromHex(signedPsbtHex)
-
-          if (!isPsbtFinalized(signedPsbt)) {
-            signedPsbt.finalizeAllInputs()
-          }
-
-          txHex = signedPsbt.extractTransaction().toHex()
-
-          txHash = await publicClient.sendUTXOTransaction({
-            hex: txHex,
-          })
-
-          process = this.statusManager.updateProcess(
-            step,
-            process.type,
-            'PENDING',
-            {
-              txHash: txHash,
-              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${txHash}`,
-              txHex,
-            }
-          )
-        }
-
-        let replacementReason: ReplacementReason | undefined
-        const transaction = await waitForTransaction(publicClient, {
-          txId: txHash,
-          txHex,
-          senderAddress: this.client.account?.address,
-          onReplaced: (response) => {
-            replacementReason = response.reason
-            process = this.statusManager.updateProcess(
-              step,
-              process.type,
-              'PENDING',
-              {
-                txHash: response.transaction.txid,
-                txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${response.transaction.txid}`,
-              }
-            )
-          },
-        })
-
-        if (replacementReason === 'cancelled') {
-          throw new TransactionError(
-            LiFiErrorCode.TransactionCanceled,
-            'User canceled transaction.'
-          )
-        }
-
-        if (transaction.txid !== txHash) {
-          process = this.statusManager.updateProcess(
-            step,
-            process.type,
-            'PENDING',
-            {
-              txHash: transaction.txid,
-              txLink: `${fromChain.metamask.blockExplorerUrls[0]}tx/${transaction.txid}`,
-            }
-          )
-        }
-
-        if (isBridgeExecution) {
-          process = this.statusManager.updateProcess(step, process.type, 'DONE')
-        }
-      } catch (e: any) {
-        const error = await parseUTXOErrors(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,
-      10_000
-    )
-
-    // DONE
-    return step
-  }
-}

package/src/core/UTXO/getUTXOBalance.ts

@@ -1,28 +0,0 @@
-import { ChainId, type Token, type TokenAmount } from '@lifi/types'
-import { getUTXOPublicClient } from './getUTXOPublicClient.js'
-
-export const getUTXOBalance = async (
-  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.')
-    }
-  }
-  const client = await getUTXOPublicClient(ChainId.BTC)
-  const [balance, blockCount] = await Promise.all([
-    client.getBalance({ address: walletAddress }),
-    client.getBlockCount(),
-  ])
-
-  return tokens.map((token) => ({
-    ...token,
-    amount: balance,
-    blockNumber: BigInt(blockCount),
-  }))
-}

package/src/core/UTXO/getUTXOPublicClient.ts

@@ -1,85 +0,0 @@
-import {
-  type Account,
-  blockchair,
-  blockcypher,
-  type Chain,
-  type Client,
-  createClient,
-  type FallbackTransport,
-  fallback,
-  type HttpTransport,
-  http,
-  mempool,
-  type PublicActions,
-  publicActions,
-  rpcSchema,
-  type UTXOSchema,
-  type WalletActions,
-  walletActions,
-} from '@bigmi/core'
-
-import { config } from '../../config.js'
-import { getRpcUrls } from '../rpc.js'
-import { toBigmiChainId } from './utils.js'
-
-type PublicClient = Client<
-  FallbackTransport<readonly HttpTransport[]>,
-  Chain,
-  Account | undefined,
-  UTXOSchema,
-  PublicActions & WalletActions
->
-
-// cached providers
-const publicClients: Record<number, PublicClient> = {}
-
-/**
- * Get an instance of a provider for a specific chain
- * @param chainId - Id of the chain the provider is for
- * @returns The public client for the given chain
- */
-export const getUTXOPublicClient = async (
-  chainId: number
-): Promise<PublicClient> => {
-  if (!publicClients[chainId]) {
-    const urls = await getRpcUrls(chainId)
-    const fallbackTransports = urls.map((url) =>
-      http(url, {
-        fetchOptions: {
-          method: 'POST',
-        },
-      })
-    )
-    const _chain = await config.getChainById(chainId)
-    const chain: Chain = {
-      ..._chain,
-      ..._chain.metamask,
-      id: toBigmiChainId(_chain.id),
-      name: _chain.metamask.chainName,
-      rpcUrls: {
-        default: { http: _chain.metamask.rpcUrls },
-        public: { http: _chain.metamask.rpcUrls },
-      },
-    }
-    const client = createClient({
-      chain,
-      rpcSchema: rpcSchema<UTXOSchema>(),
-      transport: fallback([
-        blockchair(),
-        blockcypher(),
-        mempool(),
-        ...fallbackTransports,
-      ]),
-      pollingInterval: 10_000,
-    })
-      .extend(publicActions)
-      .extend(walletActions)
-    publicClients[chainId] = client
-  }
-
-  if (!publicClients[chainId]) {
-    throw new Error(`Unable to configure provider for chain ${chainId}`)
-  }
-
-  return publicClients[chainId]
-}

package/src/core/UTXO/parseUTXOErrors.ts

@@ -1,48 +0,0 @@
-import type { LiFiStep } from '@lifi/types'
-import { BaseError } from '../../errors/baseError.js'
-import { ErrorMessage, LiFiErrorCode } from '../../errors/constants.js'
-import { TransactionError, UnknownError } from '../../errors/errors.js'
-import { SDKError } from '../../errors/SDKError.js'
-import type { Process } from '../types.js'
-
-export const parseUTXOErrors = 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) => {
-  // txn-mempool-conflict
-  if (
-    e.details?.includes?.('conflict') ||
-    e.cause?.message?.includes?.('conflict')
-  ) {
-    return new TransactionError(
-      LiFiErrorCode.TransactionConflict,
-      'Your transaction conflicts with another transaction already in the mempool. One or more inputs have been spent by another transaction.',
-      e
-    )
-  }
-  if (e.code === 4001 || e.code === -32000 || e.cause?.includes?.('rejected')) {
-    return new TransactionError(LiFiErrorCode.SignatureRejected, e.message, e)
-  }
-  if (e.code === -5 || e.code === -32700 || e.code === -32064) {
-    return new TransactionError(LiFiErrorCode.NotFound, e.message, e)
-  }
-
-  if (e instanceof BaseError) {
-    return e
-  }
-
-  return new UnknownError(e.message || ErrorMessage.UnknownError, e)
-}

package/src/core/UTXO/resolveUTXOAddress.ts

@@ -1,6 +0,0 @@
-export async function resolveUTXOAddress(
-  name: string
-): Promise<string | undefined> {
-  // Not supported on UTXO yet
-  return name
-}

package/src/core/UTXO/types.ts

@@ -1,16 +0,0 @@
-import type { Client } from '@bigmi/core'
-
-import { ChainType } from '@lifi/types'
-import type { SDKProvider } from '../types.js'
-
-export interface UTXOProviderOptions {
-  getWalletClient?: () => Promise<Client>
-}
-
-export interface UTXOProvider extends SDKProvider {
-  setOptions(options: UTXOProviderOptions): void
-}
-
-export function isUTXO(provider: SDKProvider): provider is UTXOProvider {
-  return provider.type === ChainType.UTXO
-}

package/src/core/UTXO/utils.ts

@@ -1,34 +0,0 @@
-import { ChainId as BigmiChainId } from '@bigmi/core'
-import { ChainId } from '@lifi/types'
-import { type Psbt, payments } from 'bitcoinjs-lib'
-
-export function isPsbtFinalized(psbt: Psbt): boolean {
-  try {
-    psbt.extractTransaction()
-    return true
-  } catch (_) {
-    return false
-  }
-}
-
-// helper function to convert full public key (33 bytes) to x-only compressed format (32 bytes) required after taproot update
-export const toXOnly = (pubKey: Uint8Array) =>
-  pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33)
-
-export const toBigmiChainId = (chainId: ChainId): BigmiChainId => {
-  switch (chainId) {
-    case ChainId.BTC:
-      return BigmiChainId.BITCOIN_MAINNET
-    default:
-      throw new Error(`Unsupported chainId mapping: ${chainId}`)
-  }
-}
-
-/**
- * Generate redeem script for P2SH addresses
- * @param publicKey
- * @returns redeem script
- */
-export const generateRedeemScript = (publicKey: Uint8Array) =>
-  // P2SH addresses are created by hashing the public key and using the result as the script
-  payments.p2wpkh({ pubkey: publicKey }).output

package/src/core/rpc.ts

@@ -1,10 +0,0 @@
-import type { ChainId } from '@lifi/types'
-import { config } from '../config.js'
-
-export const getRpcUrls = async (chainId: ChainId): Promise<string[]> => {
-  const rpcUrls = (await config.getRPCUrls())[chainId]
-  if (!rpcUrls?.length) {
-    throw new Error(`RPC URL not found for chainId: ${chainId}`)
-  }
-  return rpcUrls
-}