@lifi/sdk 3.3.0-beta.2 → 3.3.0-beta.4

package/src/core/UTXO/isUTXOAddress.ts

@@ -1,165 +0,0 @@
-import { sha256 } from '@noble/hashes/sha256'
-import { type Decoded, 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 }
-} = {
-  0: {
-    type: UTXOAddressType.p2pkh,
-    network: UTXONetwork.Mainnet,
-  },
-  111: {
-    type: UTXOAddressType.p2pkh,
-    network: UTXONetwork.Testnet,
-  },
-  5: {
-    type: UTXOAddressType.p2sh,
-    network: UTXONetwork.Mainnet,
-  },
-  196: {
-    type: UTXOAddressType.p2sh,
-    network: UTXONetwork.Testnet,
-  },
-}
-
-const parseBech32 = (address: string): UTXOAddress => {
-  let decoded: 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: UTXOAddressType
-  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/utxo-stack/actions/getBalance.ts

@@ -1,26 +0,0 @@
-import type { Account, Chain, Client, 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/getBlock.ts

@@ -1,58 +0,0 @@
-import { Block } from 'bitcoinjs-lib'
-import {
-  type Account,
-  BlockNotFoundError,
-  type Chain,
-  type Client,
-  type Transport,
-} from 'viem'
-import type { UTXOSchema } from '../transports/utxo/types.js'
-
-export type GetBlockParameters =
-  | {
-      blockHash: string
-      blockNumber?: never
-    }
-  | {
-      blockHash?: never
-      blockNumber: number
-    }
-
-export type GetBlockReturnType = Block
-
-export async function getBlock<
-  C extends Chain | undefined,
-  A extends Account | undefined = Account | undefined,
->(
-  client: Client<Transport, C, A, UTXOSchema>,
-  { blockHash, blockNumber }: GetBlockParameters
-): Promise<GetBlockReturnType> {
-  let blockHex: string | undefined
-  try {
-    let _blockHash = blockHash
-    if (!_blockHash && blockNumber) {
-      _blockHash = await client.request(
-        {
-          method: 'getblockhash',
-          params: [blockNumber],
-        },
-        { dedupe: true }
-      )
-    }
-    if (_blockHash) {
-      blockHex = await client.request(
-        {
-          method: 'getblock',
-          params: [_blockHash, 0],
-        },
-        { dedupe: true }
-      )
-    }
-  } catch (_error) {
-    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
-  }
-  if (!blockHex) {
-    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
-  }
-  return Block.fromHex(blockHex)
-}

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

@@ -1,20 +0,0 @@
-import type { Account, Chain, Client, 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/getBlockStats.ts

@@ -1,55 +0,0 @@
-import {
-  type Account,
-  BlockNotFoundError,
-  type Chain,
-  type Client,
-  type Transport,
-} from 'viem'
-import type { UTXOSchema } from '../transports/utxo/types.js'
-import type { BlockStats, BlockStatsKeys } from '../types/blockStats.js'
-
-export type GetBlockStatsParameters = (
-  | {
-      blockHash: string
-      blockNumber?: never
-    }
-  | {
-      blockHash?: never
-      blockNumber: number
-    }
-) & {
-  stats?: Array<BlockStatsKeys>
-}
-
-export type GetBlockStatsReturnType = BlockStats
-
-export async function getBlockStats<
-  C extends Chain | undefined,
-  A extends Account | undefined = Account | undefined,
->(
-  client: Client<Transport, C, A, UTXOSchema>,
-  { blockHash, blockNumber, stats }: GetBlockStatsParameters
-): Promise<GetBlockStatsReturnType> {
-  const blockHashOrNumber = blockHash || blockNumber
-  if (!blockHashOrNumber) {
-    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
-  }
-  try {
-    const params: [string | number, Array<BlockStatsKeys>?] = [
-      blockHashOrNumber,
-    ]
-    if (stats) {
-      params.push(stats)
-    }
-    const data = await client.request(
-      {
-        method: 'getblockstats',
-        params: params,
-      },
-      { dedupe: true }
-    )
-    return data
-  } catch (_error) {
-    throw new BlockNotFoundError({ blockHash, blockNumber } as never)
-  }
-}

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

@@ -1,43 +0,0 @@
-import {
-  type Account,
-  type Chain,
-  type Client,
-  TransactionNotFoundError,
-  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> {
-  try {
-    const params: [string, boolean, string?] = [txId, true]
-    if (blockHash) {
-      params.push(blockHash)
-    }
-    const data = await client.request({
-      method: 'getrawtransaction',
-      params: params,
-    })
-    return data
-  } catch (_error) {
-    throw new TransactionNotFoundError({
-      blockHash: blockHash as never,
-      hash: txId as never,
-    })
-  }
-}

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

@@ -1,29 +0,0 @@
-import type { Account, Chain, Client, 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

@@ -1,23 +0,0 @@
-import type { Account, Chain, Client, 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
-}