@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/src/services/Services.ts

@@ -1,603 +0,0 @@
-import { Transaction as BsvTransaction, Beef, ChainTracker, Utils, WalletLoggerInterface } from '@bsv/sdk'
-import { ServiceCollection, ServiceToCall } from './ServiceCollection'
-import { createDefaultWalletServicesOptions } from './createDefaultWalletServicesOptions'
-import { WhatsOnChain } from './providers/WhatsOnChain'
-import { updateChaintracksFiatExchangeRates, updateExchangeratesapi } from './providers/exchangeRates'
-import { ARC } from './providers/ARC'
-import { Bitails } from './providers/Bitails'
-import { getBeefForTxid } from './providers/getBeefForTxid'
-import {
-  BaseBlockHeader,
-  BlockHeader,
-  FiatExchangeRates,
-  GetMerklePathResult,
-  GetMerklePathService,
-  GetRawTxResult,
-  GetRawTxService,
-  GetScriptHashHistoryResult,
-  GetScriptHashHistoryService,
-  GetStatusForTxidsResult,
-  GetStatusForTxidsService,
-  GetUtxoStatusOutputFormat,
-  GetUtxoStatusResult,
-  GetUtxoStatusService,
-  PostBeefResult,
-  PostBeefService,
-  ServicesCallHistory,
-  UpdateFiatExchangeRateService,
-  WalletServices,
-  WalletServicesOptions
-} from '../sdk/WalletServices.interfaces'
-import { Chain } from '../sdk/types'
-import { WERR_INTERNAL, WERR_INVALID_OPERATION, WERR_INVALID_PARAMETER } from '../sdk/WERR_errors'
-import { ChaintracksChainTracker } from './chaintracker/ChaintracksChainTracker'
-import { WalletError } from '../sdk/WalletError'
-import { doubleSha256BE, sha256Hash, wait } from '../utility/utilityHelpers'
-import { TableOutput } from '../storage/schema/tables/TableOutput'
-import { asArray, asString } from '../utility/utilityHelpers.noBuffer'
-
-export class Services implements WalletServices {
-  static createDefaultOptions(chain: Chain): WalletServicesOptions {
-    return createDefaultWalletServicesOptions(chain)
-  }
-
-  options: WalletServicesOptions
-  whatsonchain: WhatsOnChain
-  arcTaal: ARC
-  arcGorillaPool?: ARC
-  bitails: Bitails
-
-  getMerklePathServices: ServiceCollection<GetMerklePathService>
-  getRawTxServices: ServiceCollection<GetRawTxService>
-  postBeefServices: ServiceCollection<PostBeefService>
-  getUtxoStatusServices: ServiceCollection<GetUtxoStatusService>
-  getStatusForTxidsServices: ServiceCollection<GetStatusForTxidsService>
-  getScriptHashHistoryServices: ServiceCollection<GetScriptHashHistoryService>
-  updateFiatExchangeRateServices: ServiceCollection<UpdateFiatExchangeRateService>
-
-  chain: Chain
-
-  constructor(optionsOrChain: Chain | WalletServicesOptions) {
-    this.chain = typeof optionsOrChain === 'string' ? optionsOrChain : optionsOrChain.chain
-
-    this.options = typeof optionsOrChain === 'string' ? Services.createDefaultOptions(this.chain) : optionsOrChain
-
-    this.whatsonchain = new WhatsOnChain(this.chain, { apiKey: this.options.whatsOnChainApiKey }, this)
-
-    this.arcTaal = new ARC(this.options.arcUrl, this.options.arcConfig, 'arcTaal')
-    if (this.options.arcGorillaPoolUrl) {
-      this.arcGorillaPool = new ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, 'arcGorillaPool')
-    }
-
-    this.bitails = new Bitails(this.chain, { apiKey: this.options.bitailsApiKey })
-
-    //prettier-ignore
-    this.getMerklePathServices = new ServiceCollection<GetMerklePathService>('getMerklePath')
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.getMerklePath.bind(this.whatsonchain) })
-      .add({ name: 'Bitails', service: this.bitails.getMerklePath.bind(this.bitails) })
-
-    //prettier-ignore
-    this.getRawTxServices = new ServiceCollection<GetRawTxService>('getRawTx')
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain) })
-
-    this.postBeefServices = new ServiceCollection<PostBeefService>('postBeef')
-    if (this.arcGorillaPool) {
-      //prettier-ignore
-      this.postBeefServices.add({ name: 'GorillaPoolArcBeef', service: this.arcGorillaPool.postBeef.bind(this.arcGorillaPool) })
-    }
-    //prettier-ignore
-    this.postBeefServices
-      .add({ name: 'TaalArcBeef', service: this.arcTaal.postBeef.bind(this.arcTaal) })
-      .add({ name: 'Bitails', service: this.bitails.postBeef.bind(this.bitails) })
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.postBeef.bind(this.whatsonchain) })
-      ;
-
-    //prettier-ignore
-    this.getUtxoStatusServices = new ServiceCollection<GetUtxoStatusService>('getUtxoStatus')
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.getUtxoStatus.bind(this.whatsonchain) })
-
-    //prettier-ignore
-    this.getStatusForTxidsServices = new ServiceCollection<GetStatusForTxidsService>('getStatusForTxids')
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.getStatusForTxids.bind(this.whatsonchain) })
-
-    //prettier-ignore
-    this.getScriptHashHistoryServices = new ServiceCollection<GetScriptHashHistoryService>('getScriptHashHistory')
-      .add({ name: 'WhatsOnChain', service: this.whatsonchain.getScriptHashHistory.bind(this.whatsonchain) })
-
-    //prettier-ignore
-    this.updateFiatExchangeRateServices = new ServiceCollection<UpdateFiatExchangeRateService>('updateFiatExchangeRate')
-      .add({ name: 'ChaintracksService', service: updateChaintracksFiatExchangeRates })
-      .add({ name: 'exchangeratesapi', service: updateExchangeratesapi })
-  }
-
-  getServicesCallHistory(reset?: boolean): ServicesCallHistory {
-    return {
-      version: 2,
-      getMerklePath: this.getMerklePathServices.getServiceCallHistory(reset),
-      getRawTx: this.getRawTxServices.getServiceCallHistory(reset),
-      postBeef: this.postBeefServices.getServiceCallHistory(reset),
-      getUtxoStatus: this.getUtxoStatusServices.getServiceCallHistory(reset),
-      getStatusForTxids: this.getStatusForTxidsServices.getServiceCallHistory(reset),
-      getScriptHashHistory: this.getScriptHashHistoryServices.getServiceCallHistory(reset),
-      updateFiatExchangeRates: this.updateFiatExchangeRateServices.getServiceCallHistory(reset)
-    }
-  }
-
-  async getChainTracker(): Promise<ChainTracker> {
-    if (!this.options.chaintracks)
-      throw new WERR_INVALID_PARAMETER('options.chaintracks', `valid to enable 'getChainTracker' service.`)
-    return new ChaintracksChainTracker(this.chain, this.options.chaintracks)
-  }
-
-  async getBsvExchangeRate(): Promise<number> {
-    this.options.bsvExchangeRate = await this.whatsonchain.updateBsvExchangeRate(
-      this.options.bsvExchangeRate,
-      this.options.bsvUpdateMsecs
-    )
-    return this.options.bsvExchangeRate.rate
-  }
-
-  async getFiatExchangeRate(currency: 'USD' | 'GBP' | 'EUR', base?: 'USD' | 'GBP' | 'EUR'): Promise<number> {
-    const rates = await this.updateFiatExchangeRates(this.options.fiatExchangeRates, this.options.fiatUpdateMsecs)
-
-    this.options.fiatExchangeRates = rates
-
-    base ||= 'USD'
-    const rate = rates.rates[currency] / rates.rates[base]
-
-    return rate
-  }
-
-  get getProofsCount() {
-    return this.getMerklePathServices.count
-  }
-  get getRawTxsCount() {
-    return this.getRawTxServices.count
-  }
-  get postBeefServicesCount() {
-    return this.postBeefServices.count
-  }
-  get getUtxoStatsCount() {
-    return this.getUtxoStatusServices.count
-  }
-
-  async getStatusForTxids(txids: string[], useNext?: boolean): Promise<GetStatusForTxidsResult> {
-    const services = this.getStatusForTxidsServices
-    if (useNext) services.next()
-
-    let r0: GetStatusForTxidsResult = {
-      name: '<noservices>',
-      status: 'error',
-      error: new WERR_INTERNAL('No services available.'),
-      results: []
-    }
-
-    for (let tries = 0; tries < services.count; tries++) {
-      const stc = services.serviceToCall
-      try {
-        const r = await stc.service(txids)
-        if (r.status === 'success') {
-          services.addServiceCallSuccess(stc)
-          r0 = r
-          break
-        } else {
-          if (r.error) services.addServiceCallError(stc, r.error)
-          else services.addServiceCallFailure(stc)
-        }
-      } catch (eu: unknown) {
-        const e = WalletError.fromUnknown(eu)
-        services.addServiceCallError(stc, e)
-      }
-      services.next()
-    }
-
-    return r0
-  }
-
-  /**
-   * @param script Output script to be hashed for `getUtxoStatus` default `outputFormat`
-   * @returns script hash in 'hashLE' format, which is the default.
-   */
-  hashOutputScript(script: string): string {
-    const hash = Utils.toHex(sha256Hash(Utils.toArray(script, 'hex')))
-    return hash
-  }
-
-  async isUtxo(output: TableOutput): Promise<boolean> {
-    if (!output.lockingScript) {
-      throw new WERR_INVALID_PARAMETER('output.lockingScript', 'validated by storage provider validateOutputScript.')
-    }
-    const hash = this.hashOutputScript(Utils.toHex(output.lockingScript))
-    const or = await this.getUtxoStatus(hash, undefined, `${output.txid}.${output.vout}`)
-    return or.isUtxo === true
-  }
-
-  async getUtxoStatus(
-    output: string,
-    outputFormat?: GetUtxoStatusOutputFormat,
-    outpoint?: string,
-    useNext?: boolean,
-    logger?: WalletLoggerInterface
-  ): Promise<GetUtxoStatusResult> {
-    const services = this.getUtxoStatusServices
-    if (useNext) services.next()
-
-    let r0: GetUtxoStatusResult = {
-      name: '<noservices>',
-      status: 'error',
-      error: new WERR_INTERNAL('No services available.'),
-      details: []
-    }
-
-    logger?.group(`services getUtxoStatus`)
-    for (let retry = 0; retry < 2; retry++) {
-      for (let tries = 0; tries < services.count; tries++) {
-        const stc = services.serviceToCall
-        try {
-          const r = await stc.service(output, outputFormat, outpoint)
-          logger?.log(`${stc.providerName} status ${r.status}`)
-          if (r.status === 'success') {
-            services.addServiceCallSuccess(stc)
-            r0 = r
-            break
-          } else {
-            if (r.error) services.addServiceCallError(stc, r.error)
-            else services.addServiceCallFailure(stc)
-          }
-        } catch (eu: unknown) {
-          const e = WalletError.fromUnknown(eu)
-          services.addServiceCallError(stc, e)
-        }
-        services.next()
-      }
-      if (r0.status === 'success') break
-      await wait(2000)
-    }
-    logger?.groupEnd()
-    return r0
-  }
-
-  async getScriptHashHistory(
-    hash: string,
-    useNext?: boolean,
-    logger?: WalletLoggerInterface
-  ): Promise<GetScriptHashHistoryResult> {
-    const services = this.getScriptHashHistoryServices
-    if (useNext) services.next()
-
-    let r0: GetScriptHashHistoryResult = {
-      name: '<noservices>',
-      status: 'error',
-      error: new WERR_INTERNAL('No services available.'),
-      history: []
-    }
-
-    logger?.group(`services getScriptHashHistory`)
-    for (let tries = 0; tries < services.count; tries++) {
-      const stc = services.serviceToCall
-      try {
-        const r = await stc.service(hash)
-        logger?.log(`${stc.providerName} status ${r.status}`)
-        if (r.status === 'success') {
-          r0 = r
-          break
-        } else {
-          if (r.error) services.addServiceCallError(stc, r.error)
-          else services.addServiceCallFailure(stc)
-        }
-      } catch (eu: unknown) {
-        const e = WalletError.fromUnknown(eu)
-        services.addServiceCallError(stc, e)
-      }
-      services.next()
-    }
-    logger?.groupEnd()
-    return r0
-  }
-
-  postBeefMode: 'PromiseAll' | 'UntilSuccess' = 'UntilSuccess'
-
-  /**
-   *
-   * @param beef
-   * @param chain
-   * @returns
-   */
-  async postBeef(beef: Beef, txids: string[], logger?: WalletLoggerInterface): Promise<PostBeefResult[]> {
-    let rs: PostBeefResult[] = []
-    const services = this.postBeefServices
-    const stcs = services.allServicesToCall
-    logger?.group(`services postBeef`)
-    switch (this.postBeefMode) {
-      case 'UntilSuccess':
-        {
-          for (const stc of stcs) {
-            const r = await callService(stc)
-            logger?.log(`${stc.providerName} status ${r.status}`)
-            rs.push(r)
-            if (r.status === 'success') break
-            if (r.txidResults && r.txidResults.every(txr => txr.serviceError)) {
-              // move this service to the end of the list
-              this.postBeefServices.moveServiceToLast(stc)
-            }
-          }
-        }
-        break
-      case 'PromiseAll':
-        {
-          rs = await Promise.all(
-            stcs.map(async stc => {
-              const r = await callService(stc)
-              return r
-            })
-          )
-        }
-        break
-    }
-    logger?.groupEnd()
-    return rs
-
-    async function callService(stc: ServiceToCall<PostBeefService>) {
-      const r = await stc.service(beef, txids)
-      if (r.status === 'success') {
-        services.addServiceCallSuccess(stc)
-      } else {
-        if (r.error) {
-          services.addServiceCallError(stc, r.error)
-        } else {
-          services.addServiceCallFailure(stc)
-        }
-      }
-      return r
-    }
-  }
-
-  async getRawTx(txid: string, useNext?: boolean): Promise<GetRawTxResult> {
-    const services = this.getRawTxServices
-    if (useNext) services.next()
-
-    const r0: GetRawTxResult = { txid }
-
-    for (let tries = 0; tries < services.count; tries++) {
-      const stc = services.serviceToCall
-      try {
-        const r = await stc.service(txid, this.chain)
-        if (r.rawTx) {
-          const hash = asString(doubleSha256BE(r.rawTx!))
-          // Confirm transaction hash matches txid
-          if (hash === asString(txid)) {
-            // If we have a match, call it done.
-            r0.rawTx = r.rawTx
-            r0.name = r.name
-            r0.error = undefined
-            services.addServiceCallSuccess(stc)
-            break
-          }
-          r.error = new WERR_INTERNAL(`computed txid ${hash} doesn't match requested value ${txid}`)
-          r.rawTx = undefined
-        }
-
-        if (r.error) services.addServiceCallError(stc, r.error)
-        else if (!r.rawTx) services.addServiceCallSuccess(stc, `not found`)
-        else services.addServiceCallFailure(stc)
-
-        if (r.error && !r0.error && !r0.rawTx)
-          // If we have an error and didn't before...
-          r0.error = r.error
-      } catch (eu: unknown) {
-        const e = WalletError.fromUnknown(eu)
-        services.addServiceCallError(stc, e)
-      }
-      services.next()
-    }
-    return r0
-  }
-
-  async invokeChaintracksWithRetry<R>(method: () => Promise<R>): Promise<R> {
-    if (!this.options.chaintracks)
-      throw new WERR_INVALID_PARAMETER('options.chaintracks', 'valid for this service operation.')
-    for (let retry = 0; retry < 3; retry++) {
-      try {
-        const r: R = await method()
-        return r
-      } catch (eu: unknown) {
-        const e = WalletError.fromUnknown(eu)
-        if (e.code != 'ECONNRESET') throw eu
-      }
-    }
-    throw new WERR_INVALID_OPERATION('hashToHeader service unavailable')
-  }
-
-  async getHeaderForHeight(height: number): Promise<number[]> {
-    const method = async () => {
-      const header = await this.options.chaintracks!.findHeaderForHeight(height)
-      if (!header) throw new WERR_INVALID_PARAMETER('hash', `valid height '${height}' on mined chain ${this.chain}`)
-      return toBinaryBaseBlockHeader(header)
-    }
-    return this.invokeChaintracksWithRetry(method)
-  }
-
-  async getHeight(): Promise<number> {
-    const method = async () => {
-      return await this.options.chaintracks!.currentHeight()
-    }
-    return this.invokeChaintracksWithRetry(method)
-  }
-
-  async hashToHeader(hash: string): Promise<BlockHeader> {
-    const method = async () => {
-      const header = await this.options.chaintracks!.findHeaderForBlockHash(hash)
-      return header
-    }
-    let header = await this.invokeChaintracksWithRetry(method)
-    if (!header) {
-      header = await this.whatsonchain.getBlockHeaderByHash(hash)
-    }
-    if (!header) throw new WERR_INVALID_PARAMETER('hash', `valid blockhash '${hash}' on mined chain ${this.chain}`)
-    return header
-  }
-
-  async getMerklePath(txid: string, useNext?: boolean, logger?: WalletLoggerInterface): Promise<GetMerklePathResult> {
-    const services = this.getMerklePathServices
-    if (useNext) services.next()
-
-    const r0: GetMerklePathResult = { notes: [] }
-
-    logger?.group(`services getMerklePath`)
-    for (let tries = 0; tries < services.count; tries++) {
-      const stc = services.serviceToCall
-      try {
-        const r = await stc.service(txid, this)
-        if (r.notes) r0.notes!.push(...r.notes)
-        if (!r0.name) r0.name = r.name
-        if (r.merklePath) {
-          logger?.log(`${stc.providerName} has merklePath`)
-          // If we have a proof, call it done.
-          r0.merklePath = r.merklePath
-          r0.header = r.header
-          r0.name = r.name
-          r0.error = undefined
-          services.addServiceCallSuccess(stc)
-          break
-        } else {
-          logger?.log(`${stc.providerName} no merklePath`)
-        }
-
-        if (r.error) services.addServiceCallError(stc, r.error)
-        else services.addServiceCallFailure(stc)
-
-        if (r.error && !r0.error) {
-          // If we have an error and didn't before...
-          r0.error = r.error
-        }
-      } catch (eu: unknown) {
-        const e = WalletError.fromUnknown(eu)
-        services.addServiceCallError(stc, e)
-      }
-      services.next()
-    }
-    return r0
-  }
-
-  targetCurrencies = ['USD', 'GBP', 'EUR']
-
-  async updateFiatExchangeRates(rates?: FiatExchangeRates, updateMsecs?: number): Promise<FiatExchangeRates> {
-    updateMsecs ||= 1000 * 60 * 15
-    const freshnessDate = new Date(Date.now() - updateMsecs)
-    if (rates) {
-      // Check if the rate we know is stale enough to update.
-      updateMsecs ||= 1000 * 60 * 15
-      if (rates.timestamp > freshnessDate) return rates
-    }
-
-    // Make sure we always start with the first service listed (chaintracks aggregator)
-    const services = this.updateFiatExchangeRateServices.clone()
-
-    let r0: FiatExchangeRates | undefined
-
-    for (let tries = 0; tries < services.count; tries++) {
-      const stc = services.serviceToCall
-      try {
-        const r = await stc.service(this.targetCurrencies, this.options)
-        if (this.targetCurrencies.every(c => typeof r.rates[c] === 'number')) {
-          services.addServiceCallSuccess(stc)
-          r0 = r
-          break
-        } else {
-          services.addServiceCallFailure(stc)
-        }
-      } catch (eu: unknown) {
-        const e = WalletError.fromUnknown(eu)
-        services.addServiceCallError(stc, e)
-      }
-      services.next()
-    }
-
-    if (!r0) {
-      console.error('Failed to update fiat exchange rates.')
-      if (!rates) throw new WERR_INTERNAL()
-      return rates
-    }
-
-    return r0
-  }
-
-  async nLockTimeIsFinal(tx: string | number[] | BsvTransaction | number): Promise<boolean> {
-    const MAXINT = 0xffffffff
-    const BLOCK_LIMIT = 500000000
-
-    let nLockTime: number
-
-    if (typeof tx === 'number') nLockTime = tx
-    else {
-      if (typeof tx === 'string') {
-        tx = BsvTransaction.fromHex(tx)
-      } else if (Array.isArray(tx)) {
-        tx = BsvTransaction.fromBinary(tx)
-      }
-
-      if (tx instanceof BsvTransaction) {
-        if (tx.inputs.every(i => i.sequence === MAXINT)) {
-          return true
-        }
-        nLockTime = tx.lockTime
-      } else {
-        throw new WERR_INTERNAL('Should be either @bsv/sdk Transaction or babbage-bsv Transaction')
-      }
-    }
-
-    if (nLockTime >= BLOCK_LIMIT) {
-      const limit = Math.floor(Date.now() / 1000)
-      return nLockTime < limit
-    }
-
-    const height = await this.getHeight()
-    return nLockTime < height
-  }
-
-  async getBeefForTxid(txid: string): Promise<Beef> {
-    const beef = await getBeefForTxid(this, txid)
-    return beef
-  }
-}
-
-export function validateScriptHash(output: string, outputFormat?: GetUtxoStatusOutputFormat): string {
-  let b = asArray(output)
-  if (!outputFormat) {
-    if (b.length === 32) outputFormat = 'hashLE'
-    else outputFormat = 'script'
-  }
-  switch (outputFormat) {
-    case 'hashBE':
-      break
-    case 'hashLE':
-      b = b.reverse()
-      break
-    case 'script':
-      b = sha256Hash(b).reverse()
-      break
-    default:
-      throw new WERR_INVALID_PARAMETER('outputFormat', `not be ${outputFormat}`)
-  }
-  return asString(b)
-}
-
-/**
- * Serializes a block header as an 80 byte array.
- * The exact serialized format is defined in the Bitcoin White Paper
- * such that computing a double sha256 hash of the array computes
- * the block hash for the header.
- * @returns 80 byte array
- * @publicbody
- */
-export function toBinaryBaseBlockHeader(header: BaseBlockHeader): number[] {
-  const writer = new Utils.Writer()
-  writer.writeUInt32LE(header.version)
-  writer.writeReverse(asArray(header.previousHash))
-  writer.writeReverse(asArray(header.merkleRoot))
-  writer.writeUInt32LE(header.time)
-  writer.writeUInt32LE(header.bits)
-  writer.writeUInt32LE(header.nonce)
-  const r = writer.toArray()
-  return r
-}