npm - @lifi/sdk - Versions diffs - 3.3.0-beta.1 → 3.3.0-beta.3 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (232) hide show

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

@@ -1,122 +0,0 @@
-import { HttpRequestError, TimeoutError, stringify, withTimeout } from 'viem'
-import type { HttpRequestReturnType, HttpRpcClientOptions } from 'viem/utils'
-export type RpcRequest = {
-  jsonrpc?: '2.0'
-  method: string
-  params?: any
-  id?: number
-}
-export type HttpRequestParameters<
-  body extends RpcRequest | RpcRequest[] = RpcRequest,
-> = {
-  url?: string
-  /** The RPC request body. */
-  body?: body
-  /** Request configuration to pass to `fetch`. */
-  fetchOptions?: HttpRpcClientOptions['fetchOptions'] | undefined
-  /** A callback to handle the response. */
-  onRequest?: ((request: Request) => Promise<void> | void) | undefined
-  /** A callback to handle the response. */
-  onResponse?: ((response: Response) => Promise<void> | void) | undefined
-  /** The timeout (in ms) for the request. */
-  timeout?: HttpRpcClientOptions['timeout'] | undefined
-}
-export type HttpRpcClient = {
-  request<body extends RpcRequest | RpcRequest[]>(
-    params: HttpRequestParameters<body>
-  ): Promise<HttpRequestReturnType<body>>
-}
-export function getHttpRpcClient(
-  url: string,
-  options: HttpRpcClientOptions = {}
-): HttpRpcClient {
-  return {
-    async request(params) {
-      const {
-        body,
-        onRequest = options.onRequest,
-        onResponse = options.onResponse,
-        timeout = options.timeout ?? 10_000,
-      } = params
-      const fetchOptions = {
-        ...(options.fetchOptions ?? {}),
-        ...(params.fetchOptions ?? {}),
-      }
-      const { headers, method, signal: signal_ } = fetchOptions
-      try {
-        const response = await withTimeout(
-          async ({ signal }) => {
-            const init: RequestInit = {
-              ...fetchOptions,
-              body: body ? stringify(body) : undefined,
-              headers: {
-                ...(method !== 'GET'
-                  ? { 'Content-Type': 'application/json' }
-                  : undefined),
-                ...headers,
-              },
-              method: method,
-              signal: signal_ || (timeout > 0 ? signal : null),
-            }
-            const request = new Request(params.url ?? url, init)
-            if (onRequest) {
-              await onRequest(request)
-            }
-            const response = await fetch(params.url ?? url, init)
-            return response
-          },
-          {
-            errorInstance: new TimeoutError({ body: body ?? {}, url }),
-            timeout,
-            signal: true,
-          }
-        )
-        if (onResponse) {
-          await onResponse(response)
-        }
-        let data: any
-        if (
-          response.headers.get('Content-Type')?.startsWith('application/json')
-        ) {
-          data = await response.json()
-        } else {
-          data = await response.text()
-          data = JSON.parse(data || '{}')
-        }
-        if (!response.ok) {
-          throw new HttpRequestError({
-            body,
-            details: stringify(data.error) || response.statusText,
-            headers: response.headers,
-            status: response.status,
-            url,
-          })
-        }
-        return data
-      } catch (err) {
-        if (err instanceof HttpRequestError) {
-          throw err
-        }
-        if (err instanceof TimeoutError) {
-          throw err
-        }
-        throw new HttpRequestError({
-          body,
-          cause: err as Error,
-          url,
-        })
-      }
-    },
-  }
-}

package/src/core/UTXO/utxo-stack/transports/utxo/getRpcProviderMethods.ts DELETED Viewed

@@ -1,22 +0,0 @@
-import { ankrMethods } from './ankr.js'
-import { blockchairMethods } from './blockchair.js'
-import { blockcypherMethods } from './blockcypher.js'
-import { mempoolMethods } from './mempool.js'
-import type { RpcMethods } from './types.js'
-export function getRpcProviderMethods(
-  key: 'blockchair' | 'ankr' | 'blockcypher' | 'mempool' | string
-): RpcMethods | null {
-  switch (key) {
-    case 'blockchair':
-      return blockchairMethods
-    case 'ankr':
-      return ankrMethods
-    case 'blockcypher':
-      return blockcypherMethods
-    case 'mempool':
-      return mempoolMethods
-    default:
-      return null
-  }
-}

package/src/core/UTXO/utxo-stack/transports/utxo/mempool.ts DELETED Viewed

@@ -1,34 +0,0 @@
-import type { RpcMethods } from './types.js'
-type MempoolBalanceResponse = {
-  address: string
-  chain_stats: {
-    funded_txo_count: number
-    funded_txo_sum: number
-    spent_txo_count: number
-    spent_txo_sum: number
-    tx_count: number
-  }
-  mempool_stats: {
-    funded_txo_count: number
-    funded_txo_sum: number
-    spent_txo_count: number
-    spent_txo_sum: number
-    tx_count: number
-  }
-}
-export const mempoolMethods: RpcMethods = {
-  getBalance: async (client, baseUrl, { address }) => {
-    const apiUrl = `${baseUrl}/address/${address}`
-    const response = (await client.request({
-      url: apiUrl,
-      fetchOptions: { method: 'GET' },
-    })) as unknown as MempoolBalanceResponse
-    const balance =
-      response.chain_stats.funded_txo_sum - response.chain_stats.spent_txo_sum
-    return {
-      result: BigInt(balance),
-    }
-  },
-}

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

@@ -1,71 +0,0 @@
-import type { BlockStats, BlockStatsKeys } from '../../types/blockStats.js'
-import type { UTXOTransaction } from '../../types/transaction.js'
-import type { HttpRpcClient } from './getHttpRpcClient.js'
-export type UTXOSchema = [
-  {
-    Method: 'getblockcount'
-    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?]
-    ReturnType: string
-  },
-  {
-    Method: 'getrawtransaction'
-    Parameters: [string, boolean, string?]
-    ReturnType: UTXOTransaction
-  },
-]
-export type UTXOAPISchema = [
-  {
-    Method: 'getBalance'
-    Parameters: { address: string }
-    ReturnType: bigint
-  },
-]
-export type UTXOAPIMethod = UTXOAPISchema[number]['Method']
-export type SuccessResult<result> = {
-  method?: undefined
-  result: result
-  error?: undefined
-}
-export type ErrorResult<error> = {
-  method?: undefined
-  result?: undefined
-  error: error
-}
-export type RpcResponse<result = any, error = any> =
-  | SuccessResult<result>
-  | ErrorResult<error>
-export type RpcMethodHandler = (
-  client: HttpRpcClient,
-  baseUrl: string,
-  params: any
-) => Promise<RpcResponse>
-export type RpcMethods = {
-  [key in UTXOAPIMethod]: RpcMethodHandler
-}

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

@@ -1,84 +0,0 @@
-import {
-  type HttpTransport,
-  type HttpTransportConfig,
-  RpcRequestError,
-  UrlRequiredError,
-  createTransport,
-} from 'viem'
-import { getHttpRpcClient } from './getHttpRpcClient.js'
-import { getRpcProviderMethods } from './getRpcProviderMethods.js'
-import type { UTXOAPIMethod } from './types.js'
-type UTXOHttpTransportConfig = HttpTransportConfig & {
-  includeChainToURL?: boolean
-}
-export function utxo(
-  url?: string,
-  config: UTXOHttpTransportConfig = {}
-): HttpTransport {
-  const {
-    fetchOptions,
-    key = 'utxo',
-    name = 'UTXO HTTP API',
-    onFetchRequest,
-    onFetchResponse,
-    retryDelay,
-  } = config
-  return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
-    const retryCount = config.retryCount ?? retryCount_
-    const timeout = timeout_ ?? config.timeout ?? 10_000
-    let url_ = url
-    if (config.includeChainToURL) {
-      const chainName = chain?.name.replace(' ', '-').toLowerCase()
-      url_ = `${url}${chainName ? `/${chainName}` : ''}`
-    }
-    if (!url_) {
-      throw new UrlRequiredError()
-    }
-    const client = getHttpRpcClient(url_, {
-      fetchOptions,
-      onRequest: onFetchRequest,
-      onResponse: onFetchResponse,
-      timeout,
-    })
-    const rpcMethods = getRpcProviderMethods(key)
-    return createTransport(
-      {
-        key,
-        name,
-        async request({ method, params }) {
-          const body = { method, params }
-          const methodHandler = rpcMethods?.[method as UTXOAPIMethod]
-          const { error, result } = await (methodHandler?.(
-            client,
-            url_,
-            params
-          ) ??
-            client.request({
-              body,
-            }))
-          if (error) {
-            throw new RpcRequestError({
-              body,
-              error,
-              url: url_,
-            })
-          }
-          return result
-        },
-        retryCount,
-        retryDelay,
-        timeout,
-        type: 'http',
-      },
-      {
-        fetchOptions,
-        url: url_,
-      }
-    )
-  }
-}

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

@@ -1,35 +0,0 @@
-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/types/transaction.ts DELETED Viewed

@@ -1,43 +0,0 @@
-export type UTXOTransaction = {
-  blockhash?: string
-  blocktime?: number
-  confirmations?: number
-  hash: string
-  hex: string
-  in_active_chain?: boolean
-  locktime: number
-  size: number
-  time?: number
-  txid: string
-  version: number
-  vsize: number
-  weight: number
-  vin: {
-    scriptSig: {
-      asm: string
-      hex: string
-    }
-    sequence: number
-    txid: string
-    txinwitness: string[]
-    vout: number
-  }[]
-  vout: {
-    n: 0
-    scriptPubKey:
-      | {
-          address: string
-          asm: string
-          desc: string
-          hex: string
-          type: string
-        }
-      | {
-          asm: string
-          desc: string
-          hex: string
-          type: string
-        }
-    value: number
-  }[]
-}

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

@@ -1,75 +0,0 @@
-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 DELETED Viewed

@@ -1,78 +0,0 @@
-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 DELETED Viewed

@@ -1,81 +0,0 @@
-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 DELETED Viewed

@@ -1,48 +0,0 @@
-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
-}