@lifi/sdk 3.2.0 → 3.3.0-alpha.0

package/src/core/UTXO/isUTXOAddress.ts

@@ -0,0 +1,166 @@
+import { sha256 } from '@noble/hashes/sha256'
+import { bech32, bech32m } from 'bech32'
+import bs58 from 'bs58'
+
+export enum UTXONetwork {
+  Mainnet = 'mainnet',
+  Testnet = 'testnet',
+  Regtest = 'regtest',
+}
+
+export enum UTXOAddressType {
+  p2pkh = 'p2pkh',
+  p2sh = 'p2sh',
+  p2wpkh = 'p2wpkh',
+  p2wsh = 'p2wsh',
+  p2tr = 'p2tr',
+}
+
+export type UTXOAddress = {
+  bech32: boolean
+  network: UTXONetwork
+  address: string
+  type: UTXOAddressType
+}
+
+const addressTypes: {
+  [key: number]: { type: UTXOAddressType; network: UTXONetwork }
+} = {
+  0x00: {
+    type: UTXOAddressType.p2pkh,
+    network: UTXONetwork.Mainnet,
+  },
+  0x6f: {
+    type: UTXOAddressType.p2pkh,
+    network: UTXONetwork.Testnet,
+  },
+  0x05: {
+    type: UTXOAddressType.p2sh,
+    network: UTXONetwork.Mainnet,
+  },
+  0xc4: {
+    type: UTXOAddressType.p2sh,
+    network: UTXONetwork.Testnet,
+  },
+}
+
+const parseBech32 = (address: string): UTXOAddress => {
+  let decoded
+
+  try {
+    if (
+      address.startsWith('bc1p') ||
+      address.startsWith('tb1p') ||
+      address.startsWith('bcrt1p')
+    ) {
+      decoded = bech32m.decode(address)
+    } else {
+      decoded = bech32.decode(address)
+    }
+  } catch (error) {
+    throw new Error('Invalid address')
+  }
+
+  const mapPrefixToNetwork: { [key: string]: UTXONetwork } = {
+    bc: UTXONetwork.Mainnet,
+    tb: UTXONetwork.Testnet,
+    bcrt: UTXONetwork.Regtest,
+  }
+
+  const network: UTXONetwork = mapPrefixToNetwork[decoded.prefix]
+
+  if (network === undefined) {
+    throw new Error('Invalid address')
+  }
+
+  const witnessVersion = decoded.words[0]
+
+  if (witnessVersion < 0 || witnessVersion > 16) {
+    throw new Error('Invalid address')
+  }
+  const data = bech32.fromWords(decoded.words.slice(1))
+
+  let type
+
+  if (data.length === 20) {
+    type = UTXOAddressType.p2wpkh
+  } else if (witnessVersion === 1) {
+    type = UTXOAddressType.p2tr
+  } else {
+    type = UTXOAddressType.p2wsh
+  }
+
+  return {
+    bech32: true,
+    network,
+    address,
+    type,
+  }
+}
+
+export const getUTXOAddress = (address: string): UTXOAddress => {
+  let decoded: Uint8Array
+  const prefix = address.substring(0, 2).toLowerCase()
+
+  if (prefix === 'bc' || prefix === 'tb') {
+    return parseBech32(address)
+  }
+
+  try {
+    decoded = bs58.decode(address)
+  } catch (error) {
+    throw new Error('Invalid address')
+  }
+
+  const { length } = decoded
+
+  if (length !== 25) {
+    throw new Error('Invalid address')
+  }
+
+  const version = decoded[0]
+
+  const checksum = decoded.slice(length - 4, length)
+  const body = decoded.slice(0, length - 4)
+
+  const expectedChecksum = sha256(sha256(body)).slice(0, 4)
+
+  if (
+    checksum.some(
+      (value: number, index: number) => value !== expectedChecksum[index]
+    )
+  ) {
+    throw new Error('Invalid address')
+  }
+
+  const validVersions = Object.keys(addressTypes).map(Number)
+
+  if (!validVersions.includes(version)) {
+    throw new Error('Invalid address')
+  }
+
+  const addressType = addressTypes[version]
+
+  return {
+    ...addressType,
+    address,
+    bech32: false,
+  }
+}
+
+export const isUTXOAddress = (
+  address: string,
+  network?: UTXONetwork
+): boolean => {
+  try {
+    const utxoAddress = getUTXOAddress(address)
+
+    if (network) {
+      return network === utxoAddress.network
+    }
+
+    return true
+  } catch (error) {
+    return false
+  }
+}

package/src/core/UTXO/parseUTXOErrors.ts

@@ -0,0 +1,36 @@
+import type { LiFiStep, Process } 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'
+
+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) => {
+  if (e.code === 4001 || e.code === -32000) {
+    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/requestClient.ts

@@ -0,0 +1,84 @@
+type Options = Parameters<typeof fetch>[1] & {
+  headers?: Record<string, string>
+  apiKey?: string
+  method?: 'GET' | 'POST'
+  onError?: (error: any) => any
+  responseHandler?: (response: any) => any
+  searchParams?: Record<string, string>
+  json?: unknown
+}
+
+let clientConfig: Options = {}
+
+export const defaultRequestHeaders =
+  typeof window !== 'undefined'
+    ? ({} as Record<string, string>)
+    : {
+        referrer: 'https://sk.thorswap.net',
+        referer: 'https://sk.thorswap.net',
+      }
+
+export function setRequestClientConfig({ apiKey, ...config }: Options) {
+  clientConfig = { ...config, apiKey }
+}
+
+async function fetchWithConfig(url: string, options: Options) {
+  const { apiKey, ...config } = clientConfig
+  const { searchParams, json, body } = options
+  const headers = {
+    ...defaultRequestHeaders,
+    ...config.headers,
+    ...options.headers,
+  } as Record<string, string>
+
+  const bodyToSend = json ? JSON.stringify(json) : body
+
+  const urlInstance = new URL(url)
+  if (searchParams) {
+    urlInstance.search = new URLSearchParams(searchParams).toString()
+  }
+
+  if (apiKey) {
+    headers['x-api-key'] = apiKey
+  }
+
+  try {
+    const response = await fetch(urlInstance.toString(), {
+      ...config,
+      ...options,
+      body: bodyToSend,
+      headers,
+    })
+    const body = await response.json()
+
+    if (options.responseHandler) {
+      return options.responseHandler(body)
+    }
+
+    return body
+  } catch (error) {
+    if (options.onError) {
+      return options.onError(error)
+    }
+
+    console.error(error)
+  }
+}
+
+export const RequestClient = {
+  get: async <T>(url: string, options?: Options): Promise<T> =>
+    fetchWithConfig(url, { ...options, method: 'GET' }),
+  post: async <T>(url: string, options?: Options): Promise<T> =>
+    fetchWithConfig(url, { ...options, method: 'POST' }),
+  extend: (options: Options) => {
+    const extendedConfig = { ...clientConfig, ...options }
+    return {
+      get: async <T>(url: string, options?: Options): Promise<T> =>
+        fetchWithConfig(url, { ...extendedConfig, ...options, method: 'GET' }),
+      post: async <T>(url: string, options?: Options): Promise<T> =>
+        fetchWithConfig(url, { ...extendedConfig, ...options, method: 'POST' }),
+      extend: (newOptions: Options) =>
+        RequestClient.extend({ ...extendedConfig, ...newOptions }),
+    }
+  },
+}

package/src/core/UTXO/types.ts

@@ -0,0 +1,15 @@
+import { ChainType } from '@lifi/types'
+import type { Client } from 'viem'
+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/utxo-stack/actions/getBalance.ts

@@ -0,0 +1,26 @@
+import { type Account, type Chain, type Client, type Transport } from 'viem'
+import type { UTXOAPISchema } from '../transports/utxo/types.js'
+
+export type GetBalanceParameters = {
+  /** The address of the account. */
+  address: string
+}
+
+export type GetBalanceReturnType = bigint
+
+export async function getBalance<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOAPISchema>,
+  params: GetBalanceParameters
+): Promise<GetBalanceReturnType> {
+  const data = await client.request(
+    {
+      method: 'getBalance',
+      params,
+    },
+    { dedupe: true }
+  )
+  return data
+}

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

@@ -0,0 +1,20 @@
+import { type Account, type Chain, type Client, type Transport } from 'viem'
+import type { UTXOSchema } from '../transports/utxo/types.js'
+
+export type GetBlockCountReturnType = number
+
+export async function getBlockCount<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOSchema>
+): Promise<GetBlockCountReturnType> {
+  const data = await client.request(
+    {
+      method: 'getblockcount',
+      params: [],
+    },
+    { dedupe: true }
+  )
+  return data
+}

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

@@ -0,0 +1,30 @@
+import { type Account, type Chain, type Client, type Transport } from 'viem'
+import type { UTXOSchema } from '../transports/utxo/types.js'
+import type { UTXOTransaction } from '../types/transaction.js'
+
+export type GetUTXOTransactionParameters = {
+  /** The Id of the transaction */
+  txId: string
+  /** The block in which to look for the transaction */
+  blockhash?: string
+}
+
+export type GetUTXOTransactionReturnType = UTXOTransaction
+
+export async function getUTXOTransaction<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOSchema>,
+  { txId, blockhash }: GetUTXOTransactionParameters
+): Promise<GetUTXOTransactionReturnType> {
+  const params: [string, boolean, string?] = [txId, true]
+  if (blockhash) {
+    params.push(blockhash)
+  }
+  const data = await client.request({
+    method: 'getrawtransaction',
+    params: params,
+  })
+  return data
+}

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

@@ -0,0 +1,29 @@
+import { type Account, type Chain, type Client, type Transport } from 'viem'
+import type { UTXOSchema } from '../transports/utxo/types.js'
+
+export type SendUTXOTransactionParameters = {
+  /** The hex string of the raw transaction */
+  hex: string
+  /** Rejects transactions whose fee rate is higher than the specified value, expressed in BTC/kB. Set to 0 to accept any fee rate. Default = 0.10 */
+  maxFeeRate?: number
+}
+
+export type SendUTXOTransactionReturnType = string
+
+export async function sendUTXOTransaction<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOSchema>,
+  { hex, maxFeeRate }: SendUTXOTransactionParameters
+): Promise<SendUTXOTransactionReturnType> {
+  const params: [string, number?] = [hex]
+  if (maxFeeRate) {
+    params.push(maxFeeRate)
+  }
+  const data = await client.request({
+    method: 'sendrawtransaction',
+    params: params,
+  })
+  return data
+}

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

@@ -0,0 +1,23 @@
+import { type Account, type Chain, type Client, type Transport } from 'viem'
+import type {
+  SignPsbtParameters,
+  SignPsbtReturnType,
+  UTXOWalletSchema,
+} from '../clients/types.js'
+
+export async function signPsbt<
+  C extends Chain | undefined,
+  A extends Account | undefined = Account | undefined,
+>(
+  client: Client<Transport, C, A, UTXOWalletSchema>,
+  params: SignPsbtParameters
+): Promise<SignPsbtReturnType> {
+  const data = await client.request(
+    {
+      method: 'signPsbt',
+      params: params,
+    },
+    { dedupe: true }
+  )
+  return data
+}

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

@@ -0,0 +1,48 @@
+import type { EIP1193RequestFn } from 'viem'
+
+export type UTXOWalletSchema = readonly [
+  {
+    Method: 'signPsbt'
+    Parameters: SignPsbtParameters
+    ReturnType: SignPsbtReturnType
+  },
+]
+
+export type SignPsbtParameters = {
+  /** The PSBT encoded as a hexadecimal string */
+  psbt: string
+  /**
+   * Array of objects specifying details about the inputs to be signed
+   */
+  inputsToSign: {
+    /**
+     * The SigHash type to use for signing (e.g., SIGHASH_ALL).
+     * If not specified, a default value is used.
+     */
+    sigHash?: number
+    /** The Bitcoin address associated with the input that will be signed */
+    address: string
+    /** An array of indexes in the PSBT corresponding to the inputs that need to be signed */
+    signingIndexes: number[]
+  }[]
+  /**
+   * Whether to finalize the PSBT after signing.
+   * If `true`, the PSBT will be completed and ready for broadcasting.
+   * If `false` or omitted, the PSBT remains partially signed.
+   * Some wallets does not support it.
+   */
+  finalize?: boolean
+}
+
+export type SignPsbtReturnType = string
+
+export type UTXOWalletProvider = {
+  request: EIP1193RequestFn<UTXOWalletSchema>
+}
+
+export type BtcAccount = {
+  address: string
+  addressType: 'p2tr' | 'p2wpkh' | 'p2wsh' | 'p2sh' | 'p2pkh'
+  publicKey: string
+  purpose: 'payment' | 'ordinals'
+}

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

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { Account, Chain, Client, Transport } from 'viem'
+import {
+  getBalance,
+  type GetBalanceParameters,
+  type GetBalanceReturnType,
+} from '../actions/getBalance.js'
+
+export type UTXOAPIActions = {
+  getBalance: (args: GetBalanceParameters) => Promise<GetBalanceReturnType>
+}
+
+export function UTXOAPIActions<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>(client: Client<transport, chain, account>): UTXOAPIActions {
+  return {
+    getBalance: (args) => getBalance(client, args),
+  }
+}

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

@@ -0,0 +1,37 @@
+import type { Account, Chain, Client, Transport } from 'viem'
+import {
+  getBlockCount,
+  type GetBlockCountReturnType,
+} from '../actions/getBlockCount.js'
+import {
+  getUTXOTransaction,
+  type GetUTXOTransactionParameters,
+  type GetUTXOTransactionReturnType,
+} from '../actions/getUTXOTransaction.js'
+import {
+  sendUTXOTransaction,
+  type SendUTXOTransactionParameters,
+  type SendUTXOTransactionReturnType,
+} from '../actions/sendUTXOTransaction.js'
+
+export type UTXOActions = {
+  getBlockCount: () => Promise<GetBlockCountReturnType>
+  sendUTXOTransaction: (
+    args: SendUTXOTransactionParameters
+  ) => Promise<SendUTXOTransactionReturnType>
+  getUTXOTransaction: (
+    args: GetUTXOTransactionParameters
+  ) => Promise<GetUTXOTransactionReturnType>
+}
+
+export function UTXOActions<
+  transport extends Transport = Transport,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+>(client: Client<transport, chain, account>): UTXOActions {
+  return {
+    getBlockCount: () => getBlockCount(client),
+    sendUTXOTransaction: (args) => sendUTXOTransaction(client, args),
+    getUTXOTransaction: (args) => getUTXOTransaction(client, args),
+  }
+}

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

@@ -0,0 +1,30 @@
+import type { RpcMethods } from './types.js'
+
+type AnkrBalanceResponse = {
+  address: string
+  balance: string
+  totalReceived: string
+  totalSent: string
+  unconfirmedBalance: string
+  unconfirmedTxs: number
+  txs: number
+  error: string
+}
+
+export const ankrMethods: RpcMethods = {
+  getBalance: async (client, baseUrl, { address }) => {
+    const apiUrl = `${baseUrl}/address/${address}?details=basic`
+    const response = (await client.request({
+      url: apiUrl,
+      fetchOptions: { method: 'GET' },
+    })) as unknown as AnkrBalanceResponse
+    if (response.error) {
+      return {
+        error: { code: -1, message: response.error },
+      }
+    }
+    return {
+      result: BigInt(response.balance),
+    }
+  },
+}

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

@@ -0,0 +1,27 @@
+import type { RpcMethods } from './types.js'
+
+type BlockchairBalanceResponse = {
+  data: Record<string, any>
+  context: { code: number; error: string }
+}
+
+export const blockchairMethods: RpcMethods = {
+  getBalance: async (client, baseUrl, { address }) => {
+    const apiUrl = `${baseUrl}/addresses/balances/?addresses=${address}`
+    const response = (await client.request({
+      url: apiUrl,
+      fetchOptions: { method: 'GET' },
+    })) as unknown as BlockchairBalanceResponse
+    if (response.context?.code !== 200) {
+      return {
+        error: {
+          code: response.context?.code,
+          message: response.context?.error,
+        },
+      }
+    }
+    return {
+      result: BigInt(response.data[address]),
+    }
+  },
+}

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

@@ -0,0 +1,32 @@
+import type { RpcMethods } from './types.js'
+
+type BlockcypherBalanceResponse = {
+  address: string
+  total_received: number
+  total_sent: number
+  balance: number
+  unconfirmed_balance: number
+  final_balance: number
+  n_tx: number
+  unconfirmed_n_tx: number
+  final_n_tx: number
+  error?: string
+}
+
+export const blockcypherMethods: RpcMethods = {
+  getBalance: async (client, baseUrl, { address }) => {
+    const apiUrl = `${baseUrl}/addrs/${address}`
+    const response = (await client.request({
+      url: apiUrl,
+      fetchOptions: { method: 'GET' },
+    })) as unknown as BlockcypherBalanceResponse
+    if (response.error) {
+      return {
+        error: { code: -1, message: response.error },
+      }
+    }
+    return {
+      result: BigInt(response.balance),
+    }
+  },
+}