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

package/src/services/chaintracker/chaintracks/Ingest/BulkIngestorCDNBabbage.ts

@@ -1,18 +0,0 @@
-import { Chain } from '../../../../sdk/types'
-import { ChaintracksFetchApi } from '../Api/ChaintracksFetchApi'
-import { BulkIngestorCDN, BulkIngestorCDNOptions } from './BulkIngestorCDN'
-
-export class BulkIngestorCDNBabbage extends BulkIngestorCDN {
-  /**
-   *
-   * @param chain
-   * @param rootFolder defaults to './data/bulk_cdn_babbage_headers/'
-   * @returns
-   */
-  static createBulkIngestorCDNBabbageOptions(chain: Chain, fetch: ChaintracksFetchApi): BulkIngestorCDNOptions {
-    const options: BulkIngestorCDNOptions = {
-      ...BulkIngestorCDN.createBulkIngestorCDNOptions(chain, 'https://cdn.projectbabbage.com/blockheaders/', fetch)
-    }
-    return options
-  }
-}

package/src/services/chaintracker/chaintracks/Ingest/BulkIngestorWhatsOnChainCdn.ts

@@ -1,113 +0,0 @@
-import { Chain } from '../../../../sdk'
-import { BlockHeader } from '../Api/BlockHeaderApi'
-import { BulkIngestorBaseOptions } from '../Api/BulkIngestorApi'
-import { ChaintracksFetchApi } from '../Api/ChaintracksFetchApi'
-import { BulkIngestorBase } from './BulkIngestorBase'
-import { deserializeBlockHeader } from '../util/blockHeaderUtilities'
-import { ChaintracksFetch } from '../util/ChaintracksFetch'
-import { HeightRange, HeightRanges } from '../util/HeightRange'
-import { StopListenerToken } from './WhatsOnChainIngestorWs'
-import { WhatsOnChainServices, WhatsOnChainServicesOptions } from './WhatsOnChainServices'
-
-export interface BulkIngestorWhatsOnChainOptions extends BulkIngestorBaseOptions, WhatsOnChainServicesOptions {
-  /**
-   * Maximum msces of "normal" pause with no new data arriving.
-   */
-  idleWait: number | undefined
-  /**
-   * Which chain is being tracked: main, test, or stn.
-   */
-  chain: Chain
-  /**
-   * WhatsOnChain.com API Key
-   * https://docs.taal.com/introduction/get-an-api-key
-   * If unknown or empty, maximum request rate is limited.
-   * https://developers.whatsonchain.com/#rate-limits
-   */
-  apiKey?: string
-  /**
-   * Request timeout for GETs to https://api.whatsonchain.com/v1/bsv
-   */
-  timeout: number
-  /**
-   * User-Agent header value for requests to https://api.whatsonchain.com/v1/bsv
-   */
-  userAgent: string
-  /**
-   * Enable WhatsOnChain client cache option.
-   */
-  enableCache: boolean
-  /**
-   * How long chainInfo is considered still valid before updating (msecs).
-   */
-  chainInfoMsecs: number
-  /**
-   *
-   */
-  fetch?: ChaintracksFetchApi
-}
-
-export class BulkIngestorWhatsOnChainCdn extends BulkIngestorBase {
-  /**
-   *
-   * @param chain
-   * @param localCachePath defaults to './data/ingest_whatsonchain_headers'
-   * @returns
-   */
-  static createBulkIngestorWhatsOnChainOptions(chain: Chain): BulkIngestorWhatsOnChainOptions {
-    const options: BulkIngestorWhatsOnChainOptions = {
-      ...WhatsOnChainServices.createWhatsOnChainServicesOptions(chain),
-      ...BulkIngestorBase.createBulkIngestorBaseOptions(chain),
-      idleWait: 5000
-    }
-    return options
-  }
-
-  fetch: ChaintracksFetchApi
-  idleWait: number
-  woc: WhatsOnChainServices
-  stopOldListenersToken: StopListenerToken = { stop: undefined }
-
-  constructor(options: BulkIngestorWhatsOnChainOptions) {
-    super(options)
-    this.idleWait = options.idleWait || 5000
-    this.woc = new WhatsOnChainServices(options)
-    this.fetch = options.fetch || new ChaintracksFetch()
-  }
-
-  override async getPresentHeight(): Promise<number | undefined> {
-    const presentHeight = await this.woc.getChainTipHeight()
-    this.log(`presentHeight=${presentHeight}`)
-    return presentHeight
-  }
-
-  async fetchHeaders(
-    before: HeightRanges,
-    fetchRange: HeightRange,
-    bulkRange: HeightRange,
-    priorLiveHeaders: BlockHeader[]
-  ): Promise<BlockHeader[]> {
-    const oldHeaders: BlockHeader[] = []
-
-    try {
-      const ranges = await this.woc.getHeaderByteFileLinks(fetchRange, this.fetch)
-      const headers: BlockHeader[] = []
-      for (const range of ranges) {
-        for (let height = range.range.minHeight; height <= range.range.maxHeight; height++) {
-          if (fetchRange.contains(height)) {
-            if (!range.data)
-              range.data = await this.fetch.download(this.fetch.pathJoin(range.sourceUrl, range.fileName))
-            const h = deserializeBlockHeader(range.data, (height - range.range.minHeight) * 80, height)
-            oldHeaders.push(h)
-          }
-        }
-      }
-    } catch (e) {
-      this.log(`Errors during WhatsOnChain ingestion:\n${e}`)
-    }
-
-    const liveHeaders = await this.storage().addBulkHeaders(oldHeaders, bulkRange, priorLiveHeaders)
-
-    return liveHeaders
-  }
-}

package/src/services/chaintracker/chaintracks/Ingest/BulkIngestorWhatsOnChainWs.ts

@@ -1,81 +0,0 @@
-import { Chain } from '../../../../sdk'
-import { logger } from '../../../../utility/utilityHelpers'
-import { BlockHeader } from '../Api/BlockHeaderApi'
-import { BulkIngestorBase } from './BulkIngestorBase'
-import { HeightRange, HeightRanges } from '../util/HeightRange'
-import { BulkIngestorWhatsOnChainOptions } from './BulkIngestorWhatsOnChainCdn'
-import { StopListenerToken, WocHeadersBulkListener } from './WhatsOnChainIngestorWs'
-import { EnqueueHandler, ErrorHandler, WhatsOnChainServices } from './WhatsOnChainServices'
-
-export class BulkIngestorWhatsOnChainWs extends BulkIngestorBase {
-  /**
-   *
-   * @param chain
-   * @param localCachePath defaults to './data/ingest_whatsonchain_headers'
-   * @returns
-   */
-  static createBulkIngestorWhatsOnChainOptions(chain: Chain): BulkIngestorWhatsOnChainOptions {
-    const options: BulkIngestorWhatsOnChainOptions = {
-      ...WhatsOnChainServices.createWhatsOnChainServicesOptions(chain),
-      ...BulkIngestorBase.createBulkIngestorBaseOptions(chain),
-      idleWait: 5000
-    }
-    return options
-  }
-
-  idleWait: number
-  woc: WhatsOnChainServices
-  stopOldListenersToken: StopListenerToken = { stop: undefined }
-
-  constructor(options: BulkIngestorWhatsOnChainOptions) {
-    super(options)
-    this.idleWait = options.idleWait || 5000
-    this.woc = new WhatsOnChainServices(options)
-  }
-
-  override async getPresentHeight(): Promise<number | undefined> {
-    const presentHeight = await this.woc.getChainTipHeight()
-    logger(`presentHeight=${presentHeight}`)
-    return presentHeight
-  }
-
-  async fetchHeaders(
-    before: HeightRanges,
-    fetchRange: HeightRange,
-    bulkRange: HeightRange,
-    priorLiveHeaders: BlockHeader[]
-  ): Promise<BlockHeader[]> {
-    const oldHeaders: BlockHeader[] = []
-    const errors: { code: number; message: string; count: number }[] = []
-    const enqueue: EnqueueHandler = header => {
-      oldHeaders.push(header)
-    }
-    const error: ErrorHandler = (code, message) => {
-      errors.push({ code, message, count: errors.length })
-      return false
-    }
-
-    const ok = await WocHeadersBulkListener(
-      fetchRange.minHeight,
-      fetchRange.maxHeight,
-      enqueue,
-      error,
-      this.stopOldListenersToken,
-      this.chain,
-      this.log,
-      this.idleWait
-    )
-
-    let liveHeaders: BlockHeader[] = []
-    if (ok) {
-      liveHeaders = await this.storage().addBulkHeaders(oldHeaders, bulkRange, priorLiveHeaders)
-    }
-
-    if (errors.length > 0) {
-      const errorMessages = errors.map(e => `(${e.code}) ${e.message} (${e.count})`).join('\n')
-      logger(`Errors during WhatsOnChain ingestion:\n${errorMessages}`)
-    }
-
-    return liveHeaders
-  }
-}

package/src/services/chaintracker/chaintracks/Ingest/LiveIngestorBase.ts

@@ -1,86 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-function */
-import { Chain } from '../../../../sdk/types'
-import { LiveIngestorApi } from '../Api/LiveIngestorApi'
-import { ChaintracksStorageApi } from '../Api/ChaintracksStorageApi'
-import { BlockHeader } from '../Api/BlockHeaderApi'
-
-export interface LiveIngestorBaseOptions {
-  /**
-   * The target chain: "main" or "test"
-   */
-  chain: Chain
-}
-
-/**
- *
- */
-export abstract class LiveIngestorBase implements LiveIngestorApi {
-  static createLiveIngestorBaseOptions(chain: Chain) {
-    const options: LiveIngestorBaseOptions = {
-      chain
-    }
-    return options
-  }
-
-  chain: Chain
-  log: (...args: any[]) => void = () => {}
-
-  constructor(options: LiveIngestorBaseOptions) {
-    this.chain = options.chain
-  }
-
-  /**
-   * Release resources.
-   * Override if required.
-   */
-  async shutdown(): Promise<void> {}
-
-  private storageEngine?: ChaintracksStorageApi
-
-  /**
-   * Allocate resources.
-   * @param storage coordinating storage engine.
-   */
-  async setStorage(storage: ChaintracksStorageApi, log: (...args: any[]) => void): Promise<void> {
-    this.storageEngine = storage
-    this.log = log
-  }
-
-  /**
-   *
-   * @returns coordinating storage engine.
-   */
-  storage(): ChaintracksStorageApi {
-    if (!this.storageEngine) throw new Error('storageEngine must be set.')
-    return this.storageEngine
-  }
-
-  /**
-   * Called to retrieve a missing block header,
-   * when the previousHash of a new header is unknown.
-   *
-   * @param hash block hash of missing header
-   */
-  abstract getHeaderByHash(hash: string): Promise<BlockHeader | undefined>
-
-  /**
-   * Begin retrieving new block headers.
-   *
-   * New headers are pushed onto the liveHeaders array.
-   *
-   * Continue waiting for new headers.
-   *
-   * Return only when either `stopListening` or `shutdown` are called.
-   *
-   * Be prepared to resume listening after `stopListening` but not
-   * after `shutdown`.
-   *
-   * @param liveHeaders
-   */
-  abstract startListening(liveHeaders: BlockHeader[]): Promise<void>
-
-  /**
-   * Causes `startListening` to stop listening for new block headers and return.
-   */
-  abstract stopListening(): void
-}

package/src/services/chaintracker/chaintracks/Ingest/LiveIngestorTeranodeP2P.ts

@@ -1,59 +0,0 @@
-import { BlockHeader, Chain } from '../../../../sdk'
-import { LiveIngestorBase, LiveIngestorBaseOptions } from './LiveIngestorBase'
-import { EnqueueHandler, ErrorHandler, WhatsOnChainServices, WhatsOnChainServicesOptions } from './WhatsOnChainServices'
-
-export interface LiveIngestorTeranodeP2POptions extends LiveIngestorBaseOptions {
-  /**
-   *
-   */
-  apiKey?: string
-  /**
-   * User-Agent header value for requests
-   */
-  userAgent?: string
-}
-
-export class LiveIngestorTeranodeP2P extends LiveIngestorBase {
-  static createLiveIngestorTeranodeP2POptions(chain: Chain): LiveIngestorTeranodeP2POptions {
-    const options: LiveIngestorTeranodeP2POptions = {
-      ...LiveIngestorBase.createLiveIngestorBaseOptions(chain)
-    }
-    return options
-  }
-
-  constructor(options: LiveIngestorTeranodeP2POptions) {
-    super(options)
-  }
-
-  async getHeaderByHash(hash: string): Promise<BlockHeader | undefined> {
-    return undefined
-  }
-
-  async startListening(liveHeaders: BlockHeader[]): Promise<void> {
-    const errors: { code: number; message: string; count: number }[] = []
-    const enqueue: EnqueueHandler = header => {
-      liveHeaders.push(header)
-    }
-    const error: ErrorHandler = (code, message) => {
-      errors.push({ code, message, count: errors.length })
-      return false
-    }
-
-    for (;;) {
-      const ok = true // await this.woc.listenForNewBlockHeaders(enqueue, error, this.idleWait)
-
-      if (!ok || errors.length > 0) {
-        console.log(`TeranodeP2P live ingestor ok=${ok} error count=${errors.length}`)
-        for (const e of errors) console.log(`TeranodeP2P error code=${e.code} count=${e.count} message=${e.message}`)
-      }
-
-      if (ok) break
-
-      errors.length = 0
-    }
-  }
-
-  stopListening(): void {
-    //this.woc?.stopNewListener()
-  }
-}

package/src/services/chaintracker/chaintracks/Ingest/LiveIngestorWhatsOnChainPoll.ts

@@ -1,104 +0,0 @@
-import { BlockHeader, Chain } from '../../../../sdk'
-import { wait } from '../../../../utility/utilityHelpers'
-import { LiveIngestorBase, LiveIngestorBaseOptions } from './LiveIngestorBase'
-import {
-  WhatsOnChainServices,
-  WhatsOnChainServicesOptions,
-  WocGetHeadersHeader,
-  wocGetHeadersHeaderToBlockHeader
-} from './WhatsOnChainServices'
-
-export interface LiveIngestorWhatsOnChainOptions extends LiveIngestorBaseOptions, WhatsOnChainServicesOptions {
-  /**
-   * Maximum msces of "normal" time with no ping received from connected WoC service.
-   */
-  idleWait: number | undefined
-  /**
-   * Which chain is being tracked: main, test, or stn.
-   */
-  chain: Chain
-  /**
-   * WhatsOnChain.com API Key
-   * https://docs.taal.com/introduction/get-an-api-key
-   * If unknown or empty, maximum request rate is limited.
-   * https://developers.whatsonchain.com/#rate-limits
-   */
-  apiKey?: string
-  /**
-   * Request timeout for GETs to https://api.whatsonchain.com/v1/bsv
-   */
-  timeout: number
-  /**
-   * User-Agent header value for requests to https://api.whatsonchain.com/v1/bsv
-   */
-  userAgent: string
-  /**
-   * Enable WhatsOnChain client cache option.
-   */
-  enableCache: boolean
-  /**
-   * How long chainInfo is considered still valid before updating (msecs).
-   */
-  chainInfoMsecs: number
-}
-
-/**
- * Reports new headers by polling periodically.
- */
-export class LiveIngestorWhatsOnChainPoll extends LiveIngestorBase {
-  static createLiveIngestorWhatsOnChainOptions(chain: Chain): LiveIngestorWhatsOnChainOptions {
-    const options: LiveIngestorWhatsOnChainOptions = {
-      ...WhatsOnChainServices.createWhatsOnChainServicesOptions(chain),
-      ...LiveIngestorBase.createLiveIngestorBaseOptions(chain),
-      idleWait: 100000
-    }
-    return options
-  }
-
-  idleWait: number
-  woc: WhatsOnChainServices
-  done: boolean = false
-
-  constructor(options: LiveIngestorWhatsOnChainOptions) {
-    super(options)
-    this.idleWait = options.idleWait || 100000
-    this.woc = new WhatsOnChainServices(options)
-  }
-
-  async getHeaderByHash(hash: string): Promise<BlockHeader | undefined> {
-    const header = await this.woc.getHeaderByHash(hash)
-    return header
-  }
-
-  async startListening(liveHeaders: BlockHeader[]): Promise<void> {
-    this.done = false
-    let lastHeaders: WocGetHeadersHeader[] = []
-
-    for (; !this.done; ) {
-      const headers = await this.woc.getHeaders()
-
-      const newHeaders = headers.filter(h => !lastHeaders.some(lh => lh.hash === h.hash))
-
-      for (const h of newHeaders) {
-        const bh = wocGetHeadersHeaderToBlockHeader(h)
-        liveHeaders.unshift(bh)
-      }
-
-      lastHeaders = headers
-
-      for (let sec = 0; sec < 60 && !this.done; sec++) {
-        // Only wait a second at a time so we notice `done` sooner...
-        await wait(1000)
-      }
-    }
-    this.log(`LiveIngestorWhatsOnChainPoll stopped`)
-  }
-
-  stopListening(): void {
-    this.done = true
-  }
-
-  override async shutdown(): Promise<void> {
-    this.stopListening()
-  }
-}

package/src/services/chaintracker/chaintracks/Ingest/LiveIngestorWhatsOnChainWs.ts

@@ -1,66 +0,0 @@
-import { BlockHeader, Chain } from '../../../../sdk'
-import { LiveIngestorBase } from './LiveIngestorBase'
-import { LiveIngestorWhatsOnChainOptions } from './LiveIngestorWhatsOnChainPoll'
-import { StopListenerToken, WocHeadersLiveListener } from './WhatsOnChainIngestorWs'
-import { EnqueueHandler, ErrorHandler, WhatsOnChainServices } from './WhatsOnChainServices'
-
-export class LiveIngestorWhatsOnChainWs extends LiveIngestorBase {
-  static createLiveIngestorWhatsOnChainOptions(chain: Chain): LiveIngestorWhatsOnChainOptions {
-    const options: LiveIngestorWhatsOnChainOptions = {
-      ...WhatsOnChainServices.createWhatsOnChainServicesOptions(chain),
-      ...LiveIngestorBase.createLiveIngestorBaseOptions(chain),
-      idleWait: 100000
-    }
-    return options
-  }
-
-  idleWait: number
-  woc: WhatsOnChainServices
-  stopNewListenersToken: StopListenerToken = { stop: undefined }
-
-  constructor(options: LiveIngestorWhatsOnChainOptions) {
-    super(options)
-    this.idleWait = options.idleWait || 100000
-    this.woc = new WhatsOnChainServices(options)
-  }
-
-  async getHeaderByHash(hash: string): Promise<BlockHeader | undefined> {
-    const header = await this.woc.getHeaderByHash(hash)
-    return header
-  }
-
-  async startListening(liveHeaders: BlockHeader[]): Promise<void> {
-    const errors: { code: number; message: string; count: number }[] = []
-    const enqueue: EnqueueHandler = header => {
-      liveHeaders.push(header)
-    }
-    const error: ErrorHandler = (code, message) => {
-      errors.push({ code, message, count: errors.length })
-      return false
-    }
-
-    for (;;) {
-      const ok = await WocHeadersLiveListener(
-        enqueue,
-        error,
-        this.stopNewListenersToken,
-        this.chain,
-        this.log,
-        this.idleWait
-      )
-
-      if (!ok || errors.length > 0) {
-        this.log(`WhatsOnChain live ingestor ok=${ok} error count=${errors.length}`)
-        for (const e of errors) this.log(`WhatsOnChain error code=${e.code} count=${e.count} message=${e.message}`)
-      }
-
-      if (ok) break
-
-      errors.length = 0
-    }
-  }
-
-  stopListening(): void {
-    this.stopNewListenersToken.stop?.()
-  }
-}