@lifi/sdk 3.2.0 → 3.3.0-alpha.0

package/src/core/UTXO/blockchairApi.ts

@@ -0,0 +1,273 @@
+import type {
+  BlockchairAddressResponse,
+  BlockchairMultipleBalancesResponse,
+  BlockchairOutputsResponse,
+  BlockchairRawTransactionResponse,
+  BlockchairResponse,
+  UTXOChain,
+  UTXOType,
+} from './blockchairApiTypes.js'
+import { Chain } from './blockchairApiTypes.js'
+import { RequestClient } from './requestClient.js'
+
+type BlockchairParams<T> = T & { chain: Chain; apiKey?: string }
+
+const baseUrl = (chain: Chain) =>
+  `https://api.blockchair.com/${mapChainToBlockchairChain(chain)}`
+
+const getDefaultTxFeeByChain = (chain: Chain) => {
+  switch (chain) {
+    case Chain.Bitcoin:
+      return 5
+    case Chain.Dogecoin:
+      return 10000
+    case Chain.Litecoin:
+      return 1
+    default:
+      return 2
+  }
+}
+
+const mapChainToBlockchairChain = (chain: Chain) => {
+  switch (chain) {
+    case Chain.BitcoinCash:
+      return 'bitcoin-cash'
+    case Chain.Litecoin:
+      return 'litecoin'
+    case Chain.Dash:
+      return 'dash'
+    case Chain.Dogecoin:
+      return 'dogecoin'
+    case Chain.Polkadot:
+      return 'polkadot'
+    default:
+      return 'bitcoin'
+  }
+}
+
+const getSuggestedTxFee = async (chain: Chain) => {
+  try {
+    //Use Bitgo API for fee estimation
+    //Refer: https://app.bitgo.com/docs/#operation/v2.tx.getfeeestimate
+    const { feePerKb } = await RequestClient.get<{
+      feePerKb: number
+      cpfpFeePerKb: number
+      numBlocks: number
+      feeByBlockTarget: { 1: number; 3: number }
+    }>(`https://app.bitgo.com/api/v2/${chain.toLowerCase()}/tx/fee`)
+    const suggestedFee = feePerKb / 1000
+
+    return Math.max(suggestedFee, getDefaultTxFeeByChain(chain))
+  } catch (_error) {
+    return getDefaultTxFeeByChain(chain)
+  }
+}
+
+const blockchairRequest = async <T>(
+  url: string,
+  apiKey?: string
+): Promise<T> => {
+  try {
+    const response = await RequestClient.get<BlockchairResponse<T>>(url)
+    if (!response || response.context.code !== 200) {
+      throw new Error(`failed to query ${url}`)
+    }
+
+    return response.data as T
+  } catch (error) {
+    if (!apiKey) {
+      throw error
+    }
+    const response = await RequestClient.get<BlockchairResponse<T>>(
+      `${url}${apiKey ? `&key=${apiKey}` : ''}`
+    )
+
+    if (!response || response.context.code !== 200) {
+      throw new Error(`failed to query ${url}`)
+    }
+
+    return response.data as T
+  }
+}
+
+const baseAddressData = {
+  utxo: [],
+  address: { balance: 0, transaction_count: 0 },
+}
+const getAddressData = async ({
+  address,
+  chain,
+  apiKey,
+}: BlockchairParams<{ address?: string }>) => {
+  if (!address) {
+    throw new Error('address is required')
+  }
+
+  try {
+    const response = await blockchairRequest<BlockchairAddressResponse>(
+      `${baseUrl(chain)}/dashboards/address/${address}?transaction_details=true`,
+      apiKey
+    )
+
+    return response[address]
+  } catch (_error) {
+    return baseAddressData
+  }
+}
+
+const getUnconfirmedBalance = async ({
+  address,
+  chain,
+  apiKey,
+}: BlockchairParams<{ address?: string }>) => {
+  const response = await getAddressData({ address, chain, apiKey })
+
+  return response?.address.balance
+}
+
+const getConfirmedBalance = async ({
+  chain,
+  address,
+  apiKey,
+}: BlockchairParams<{ address?: string }>) => {
+  if (!address) {
+    throw new Error('address is required')
+  }
+  try {
+    const response =
+      await blockchairRequest<BlockchairMultipleBalancesResponse>(
+        `${baseUrl(chain)}/addresses/balances?addresses=${address}`,
+        apiKey
+      )
+
+    return response[address] || 0
+  } catch (_error) {
+    return 0
+  }
+}
+
+const getRawTx = async ({
+  chain,
+  apiKey,
+  txHash,
+}: BlockchairParams<{ txHash?: string }>) => {
+  if (!txHash) {
+    throw new Error('txHash is required')
+  }
+
+  try {
+    const rawTxResponse =
+      await blockchairRequest<BlockchairRawTransactionResponse>(
+        `${baseUrl(chain)}/raw/transaction/${txHash}`,
+        apiKey
+      )
+    return rawTxResponse?.[txHash]?.raw_transaction
+  } catch (error) {
+    console.error(error)
+    return ''
+  }
+}
+
+const getUnspentTxs = async ({
+  chain,
+  address,
+  apiKey,
+  offset = 0,
+}: BlockchairParams<{ offset?: number; address: string }>): Promise<
+  (UTXOType & { script_hex: string; is_confirmed: boolean })[]
+> => {
+  if (!address) {
+    throw new Error('address is required')
+  }
+  try {
+    const response = await blockchairRequest<BlockchairOutputsResponse[]>(
+      `${baseUrl(
+        chain
+      )}/outputs?q=is_spent(false),recipient(${address})&limit=100&offset=${offset}`,
+      apiKey
+    )
+
+    const txs = response
+      .filter(({ is_spent }) => !is_spent)
+      .map(
+        ({
+          script_hex,
+          block_id,
+          transaction_hash,
+          index,
+          value,
+          spending_signature_hex,
+        }) => ({
+          hash: transaction_hash,
+          index,
+          value,
+          txHex: spending_signature_hex,
+          script_hex,
+          is_confirmed: block_id !== -1,
+        })
+      ) as (UTXOType & { script_hex: string; is_confirmed: boolean })[]
+
+    if (response.length !== 100) {
+      return txs
+    }
+
+    const nextBatch = await getUnspentTxs({
+      address,
+      chain,
+      apiKey,
+      offset: response?.[99]?.transaction_id,
+    })
+
+    return txs.concat(nextBatch)
+  } catch (error) {
+    console.error(error)
+    return []
+  }
+}
+
+const scanUTXOs = async ({
+  address,
+  chain,
+  apiKey,
+  fetchTxHex = true,
+}: BlockchairParams<{ address: string; fetchTxHex?: boolean }>) => {
+  const utxos = await getUnspentTxs({ chain, address, apiKey })
+  const results = []
+
+  for (const { hash, index, script_hex, value } of utxos) {
+    let txHex: string | undefined
+    if (fetchTxHex) {
+      txHex = await getRawTx({ txHash: hash, chain, apiKey })
+    }
+    results.push({
+      address,
+      hash,
+      index,
+      txHex,
+      value,
+      witnessUtxo: { value, script: Buffer.from(script_hex, 'hex') },
+    })
+  }
+  return results
+}
+
+export const blockchairApi = ({
+  apiKey,
+  chain,
+}: {
+  apiKey?: string
+  chain: UTXOChain
+}) => ({
+  getConfirmedBalance: (address: string) =>
+    getConfirmedBalance({ chain, address, apiKey }),
+  getRawTx: (txHash: string) => getRawTx({ txHash, chain, apiKey }),
+  getSuggestedTxFee: () => getSuggestedTxFee(chain),
+  getBalance: (address: string) =>
+    getUnconfirmedBalance({ address, chain, apiKey }),
+  getAddressData: (address: string) =>
+    getAddressData({ address, chain, apiKey }),
+  scanUTXOs: (params: { address: string; fetchTxHex?: boolean }) =>
+    scanUTXOs({ ...params, chain, apiKey }),
+})
+
+export type BlockchairApiType = ReturnType<typeof blockchairApi>

package/src/core/UTXO/blockchairApiTypes.ts

@@ -0,0 +1,253 @@
+export enum Chain {
+  Arbitrum = 'ARB',
+  Avalanche = 'AVAX',
+  BinanceSmartChain = 'BSC',
+  Bitcoin = 'BTC',
+  BitcoinCash = 'BCH',
+  Cosmos = 'GAIA',
+  Dash = 'DASH',
+  Dogecoin = 'DOGE',
+  Ethereum = 'ETH',
+  Kujira = 'KUJI',
+  Litecoin = 'LTC',
+  Maya = 'MAYA',
+  Optimism = 'OP',
+  Polkadot = 'DOT',
+  Chainflip = 'FLIP',
+  Polygon = 'MATIC',
+  Radix = 'XRD',
+  THORChain = 'THOR',
+  Solana = 'SOL',
+}
+
+export type UTXOChain =
+  | Chain.Bitcoin
+  | Chain.BitcoinCash
+  | Chain.Dash
+  | Chain.Dogecoin
+  | Chain.Litecoin
+
+export type UTXOType = {
+  hash: string
+  index: number
+  value: number
+  txHex?: string
+  witnessUtxo?: any
+}
+
+export type BlockchairApiParams<T> = T & {
+  chain: Chain
+  apiKey: string
+}
+
+export interface BlockchairMultipleBalancesResponse {
+  [key: string]: number
+}
+
+export interface BlockchairVin {
+  txid: string
+  vout: number
+  scriptSig: {
+    asm: string
+    hex: string
+  }
+  sequence: number
+}
+
+export interface BlockchairVout {
+  value: number
+  n: number
+  scriptPubKey: {
+    asm: string
+    hex: string
+    address: string
+    type: string
+    addresses: string[]
+    reqSigs: number
+  }
+}
+
+export interface BlockchairTransaction {
+  block_id: number
+  hash: string
+  time: string
+  balance_change: number
+}
+
+export interface BlockchairUtxo {
+  block_id: number
+  transaction_hash: string
+  index: number
+  value: number
+}
+
+export interface BlockchairAddressCoreData {
+  type: string
+  script_hex: string
+  balance: number
+  balance_usd: number
+  received: number
+  received_usd: number
+  spent: number
+  spent_usd: number
+  output_count: number
+  unspent_output_count: number
+  first_seen_receiving: string
+  last_seen_receiving: string
+  first_seen_spending: null | string
+  last_seen_spending: null | string
+  transaction_count: number
+  scripthash_type: null | string
+}
+
+export interface BlockchairInputOutputCommonData {
+  block_id: number
+  transaction_id: number
+  index: number
+  transaction_hash: string
+  date: string
+  time: string
+  value: number
+  value_usd: number
+  recipient: string
+  type: string
+  script_hex: string
+  is_from_coinbase: boolean
+  is_spendable: boolean | null
+  is_spent: boolean
+  lifespan: number | null
+  cdd: number | null
+}
+export interface BlockchairTransactionInputOutput
+  extends BlockchairSpendingBlockData,
+    BlockchairInputOutputCommonData {
+  scripthash_type: null | string
+}
+
+export interface BlockchairSpendingBlockData {
+  spending_block_id: number | null
+  spending_transaction_id: number | null
+  spending_index: number | null
+  spending_transaction_hash: string | null
+  spending_date: string | null
+  spending_time: string | null
+  spending_value_usd: number | null
+  spending_sequence: number | null
+  spending_signature_hex: string | null
+  spending_witness: string | null
+}
+
+export interface BlockchairAddressResponse {
+  [key: string]: {
+    address: BlockchairAddressCoreData
+    transactions: BlockchairTransaction[]
+    utxo: BlockchairUtxo[]
+  }
+}
+
+export interface BlockchairOutputsResponse
+  extends BlockchairSpendingBlockData,
+    BlockchairInputOutputCommonData {}
+
+export interface BlockchairRawTransactionResponse {
+  [key: string]: {
+    raw_transaction: string
+    decoded_raw_transaction: {
+      txid: string
+      hash: string
+      version: number
+      size: number
+      vsize: number
+      weight: number
+      locktime: number
+      vin: BlockchairVin[]
+      vout: BlockchairVout[]
+    }
+  }
+}
+
+export interface BlockchairMultipleAddressesResponse {
+  addresses: {
+    [key: string]: BlockchairAddressCoreData
+  }
+  transactions: BlockchairTransaction[]
+  utxo: BlockchairUtxo[]
+  set: {
+    address_count: number
+    balance: number
+    balance_usd: number
+    received: number
+    spent: number
+    output_count: number
+    unspent_output_count: number
+    first_seen_receiving: string
+    last_seen_receiving: string
+    first_seen_spending: null | string
+    last_seen_spending: null | string
+    transaction_count: number
+  }
+}
+
+export interface BlockchairResponse<T> {
+  data: T
+  context: {
+    code: number
+    source: string
+    results: number
+    state: number
+    market_price_usd: number
+    cache: {
+      live: boolean
+      duration: number
+      since: string
+      until: string
+      time: any
+    }
+    api: {
+      version: string
+      last_major_update: string
+      next_major_update: null | string
+      documentation: string
+      notice: string
+    }
+    servers: string
+    time: number
+    render_time: number
+    full_time: number
+    request_cost: number
+  }
+}
+
+export interface BlockchairDashboardTransactionResponse {
+  [key: string]: {
+    transaction: {
+      block_id: number
+      id: number
+      hash: string
+      date: string
+      time: string
+      size: number
+      weight: number
+      version: number
+      lock_time: number
+      is_coinbase: boolean
+      has_witness: boolean
+      input_count: number
+      output_count: number
+      input_total: number
+      input_total_usd: number
+      output_total: number
+      output_total_usd: number
+      fee: number
+      fee_usd: number
+      fee_per_kb: number
+      fee_per_kb_usd: number
+      fee_per_kwu: number
+      fee_per_kwu_usd: number
+      cdd_total: number
+      is_rbf: boolean
+    }
+    inputs: BlockchairTransactionInputOutput[]
+    outputs: BlockchairTransactionInputOutput[]
+  }
+}

package/src/core/UTXO/getUTXOAPIPublicClient.ts

@@ -0,0 +1,71 @@
+import {
+  createClient,
+  fallback,
+  rpcSchema,
+  type Chain,
+  type Client,
+  type FallbackTransport,
+  type HttpTransport,
+} from 'viem'
+import { config } from '../../config.js'
+import { UTXOAPIActions } from './utxo-stack/decorators/UTXOAPIActions.js'
+import type { UTXOAPISchema } from './utxo-stack/transports/utxo/types.js'
+import { utxo } from './utxo-stack/transports/utxo/utxo.js'
+
+// cached providers
+const publicAPIClients: Record<
+  number,
+  Client<
+    FallbackTransport<readonly HttpTransport[]>,
+    Chain,
+    undefined,
+    UTXOAPISchema,
+    UTXOAPIActions
+  >
+> = {}
+
+/**
+ * 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 getUTXOAPIPublicClient = async (chainId: number) => {
+  if (!publicAPIClients[chainId]) {
+    const _chain = await config.getChainById(chainId)
+    const chain: Chain = {
+      ..._chain,
+      ..._chain.metamask,
+      name: _chain.metamask.chainName,
+      rpcUrls: {
+        default: { http: _chain.metamask.rpcUrls },
+        public: { http: _chain.metamask.rpcUrls },
+      },
+    }
+    const client = createClient({
+      chain,
+      rpcSchema: rpcSchema<UTXOAPISchema>(),
+      transport: fallback([
+        utxo('https://api.blockchair.com', {
+          key: 'blockchair',
+          includeChainToURL: true,
+        }),
+        utxo('https://rpc.ankr.com/http/btc_blockbook/api/v2', {
+          key: 'ankr',
+        }),
+        utxo('https://api.blockcypher.com/v1/btc/main', {
+          key: 'blockcypher',
+        }),
+        utxo('https://mempool.space/api', {
+          key: 'mempool',
+        }),
+      ]),
+    }).extend(UTXOAPIActions)
+    publicAPIClients[chainId] = client
+  }
+
+  if (!publicAPIClients[chainId]) {
+    throw new Error(`Unable to configure provider for chain ${chainId}`)
+  }
+
+  return publicAPIClients[chainId]
+}

package/src/core/UTXO/getUTXOBalance.ts

@@ -0,0 +1,31 @@
+import { ChainId, type Token, type TokenAmount } from '@lifi/types'
+import { getUTXOAPIPublicClient } from './getUTXOAPIPublicClient.js'
+import { getUTXOPublicClient } from './getUTXOPublicClient.js'
+
+export const getUTXOBalance = async (
+  walletAddress: string,
+  tokens: Token[]
+): Promise<TokenAmount[]> => {
+  if (tokens.length === 0) {
+    return []
+  }
+  const { chainId } = tokens[0]
+  tokens.forEach((token) => {
+    if (token.chainId !== chainId) {
+      console.warn(`Requested tokens have to be on the same chain.`)
+    }
+  })
+
+  const apiClient = await getUTXOAPIPublicClient(ChainId.BTC)
+  const client = await getUTXOPublicClient(ChainId.BTC)
+  const [balance, blockCount] = await Promise.all([
+    apiClient.getBalance({ address: walletAddress }),
+    client.getBlockCount(),
+  ])
+
+  return tokens.map((token) => ({
+    ...token,
+    amount: balance,
+    blockNumber: BigInt(blockCount),
+  }))
+}

package/src/core/UTXO/getUTXOPublicClient.ts

@@ -0,0 +1,60 @@
+import {
+  createClient,
+  fallback,
+  http,
+  rpcSchema,
+  type Chain,
+  type Client,
+  type FallbackTransport,
+  type HttpTransport,
+} from 'viem'
+import { config } from '../../config.js'
+import { getRpcUrls } from '../rpc.js'
+import { UTXOActions } from './utxo-stack/decorators/UTXOActions.js'
+import type { UTXOSchema } from './utxo-stack/transports/utxo/types.js'
+
+// cached providers
+const publicClients: Record<
+  number,
+  Client<
+    FallbackTransport<readonly HttpTransport[]>,
+    Chain,
+    undefined,
+    UTXOSchema,
+    UTXOActions
+  >
+> = {}
+
+/**
+ * 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) => {
+  if (!publicClients[chainId]) {
+    const urls = await getRpcUrls(chainId)
+    const fallbackTransports = urls.map((url) => http(url))
+    const _chain = await config.getChainById(chainId)
+    const chain: Chain = {
+      ..._chain,
+      ..._chain.metamask,
+      name: _chain.metamask.chainName,
+      rpcUrls: {
+        default: { http: _chain.metamask.rpcUrls },
+        public: { http: _chain.metamask.rpcUrls },
+      },
+    }
+    const client = createClient({
+      chain,
+      rpcSchema: rpcSchema<UTXOSchema>(),
+      transport: fallback(fallbackTransports),
+    }).extend(UTXOActions)
+    publicClients[chainId] = client
+  }
+
+  if (!publicClients[chainId]) {
+    throw new Error(`Unable to configure provider for chain ${chainId}`)
+  }
+
+  return publicClients[chainId]
+}