@bopen-io/wallet-toolbox 1.7.18

package/src/services/chaintracker/chaintracks/util/ChaintracksFetch.ts

@@ -0,0 +1,69 @@
+import { defaultHttpClient, HttpClient } from '@bsv/sdk'
+import { ChaintracksFetchApi } from '../Api/ChaintracksFetchApi'
+import { wait } from '../../../../utility/utilityHelpers'
+
+/**
+ * This class implements the ChaintracksFetchApi
+ * using the @bsv/sdk `defaultHttpClient`.
+ */
+export class ChaintracksFetch implements ChaintracksFetchApi {
+  httpClient: HttpClient = defaultHttpClient()
+
+  constructor() {}
+
+  async download(url: string): Promise<Uint8Array> {
+    for (let retry = 0; ; retry++) {
+      const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/octet-stream'
+        }
+      })
+
+      if (!response.ok) {
+        if (response.statusText === 'Too Many Requests' && retry < 3) {
+          // WhatsOnChain rate limits requests, so backoff and retry
+          await wait(1000 * (retry + 1))
+          continue
+        }
+        throw new Error(`Failed to download from ${url}: ${response.statusText}`)
+      }
+
+      const data = await response.arrayBuffer()
+
+      return new Uint8Array(data)
+    }
+  }
+
+  async fetchJson<R>(url: string): Promise<R> {
+    const requestJsonOptions = {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json'
+      }
+    }
+    let json: R
+    for (let retry = 0; ; retry++) {
+      const response = await fetch(url, requestJsonOptions)
+      if (!response.ok) {
+        if (response.statusText === 'Too Many Requests' && retry < 3) {
+          await wait(1000 * (retry + 1))
+          continue
+        }
+        throw new Error(`Failed to fetch JSON from ${url}: ${response.statusText}`)
+      }
+      json = (await response.json()) as R
+      break
+    }
+    return json
+  }
+
+  pathJoin(baseUrl: string, subpath: string): string {
+    // Ensure the subpath doesn't start with a slash to avoid issues
+    const cleanSubpath = subpath.replace(/^\/+/, '')
+    if (!baseUrl.endsWith('/')) baseUrl += '/'
+    // Create a new URL object and append the subpath
+    const url = new URL(cleanSubpath, baseUrl)
+    return url.toString()
+  }
+}

package/src/services/chaintracker/chaintracks/util/ChaintracksFs.ts

@@ -0,0 +1,141 @@
+import {
+  ChaintracksAppendableFileApi,
+  ChaintracksFsApi,
+  ChaintracksReadableFileApi,
+  ChaintracksWritableFileApi
+} from '../Api/ChaintracksFsApi'
+import { promises as fs } from 'fs'
+import Path from 'path'
+
+export abstract class ChaintracksFsStatics {
+  static async delete(path: string): Promise<void> {
+    await fs.unlink(path)
+  }
+  static async writeFile(path: string, data: Uint8Array): Promise<void> {
+    await this.ensureFoldersExist(path)
+    await fs.writeFile(path, Buffer.from(data))
+  }
+  static async readFile(path: string): Promise<Uint8Array> {
+    const buffer = await fs.readFile(path)
+    return Uint8Array.from(buffer)
+  }
+  static async openReadableFile(path: string): Promise<ChaintracksReadableFileApi> {
+    return await ChaintracksReadableFile.openAsReadable(path)
+  }
+  static async openWritableFile(path: string): Promise<ChaintracksWritableFileApi> {
+    return await ChaintracksWritableFile.openAsWritable(path)
+  }
+
+  static async openAppendableFile(path: string): Promise<ChaintracksAppendableFileApi> {
+    return await ChaintracksAppendableFile.openAsAppendable(path)
+  }
+  static async ensureFoldersExist(path: string): Promise<void> {
+    const parsedPath = Path.parse(path)
+    await fs.mkdir(parsedPath.dir, { recursive: true })
+  }
+  static pathJoin(...parts: string[]): string {
+    return Path.join(...parts)
+  }
+}
+
+/**
+ * This object is an implementation of the `ChaintracksFsApi` interface
+ * using the `fs` package which may not be available in all environments.
+ */
+export const ChaintracksFs: ChaintracksFsApi = ChaintracksFsStatics
+
+export class ChaintracksReadableFile implements ChaintracksReadableFileApi {
+  path: string
+  parsedPath: Path.ParsedPath
+  f: fs.FileHandle
+
+  protected constructor(path: string, f: fs.FileHandle) {
+    this.path = path
+    this.f = f
+    this.parsedPath = Path.parse(path)
+  }
+
+  async close(): Promise<void> {
+    await this.f.close()
+  }
+
+  async getLength(): Promise<number> {
+    const stats = await this.f.stat()
+    return stats.size
+  }
+
+  async read(length?: number, offset?: number): Promise<Uint8Array> {
+    length ||= 80 * 1024 // Default to 80KB if no length is specified
+    const buffer = Buffer.alloc(length)
+    const rr = await this.f.read(buffer, 0, length, offset || 0)
+    const rb = rr.bytesRead < length ? buffer.subarray(0, rr.bytesRead) : buffer
+    return Uint8Array.from(rb)
+  }
+
+  static async openAsReadable(path: string): Promise<ChaintracksReadableFile> {
+    const f = await fs.open(path, 'r')
+    const file = new ChaintracksReadableFile(path, f)
+    return file
+  }
+}
+
+export class ChaintracksWritableFile implements ChaintracksWritableFileApi {
+  path: string
+  parsedPath: Path.ParsedPath
+  f: fs.FileHandle
+  foldersEnsured: boolean = false
+
+  private constructor(path: string, f: fs.FileHandle) {
+    this.path = path
+    this.f = f
+    this.parsedPath = Path.parse(path)
+  }
+
+  static async openAsWritable(path: string): Promise<ChaintracksWritableFile> {
+    const f = await fs.open(path, 'w')
+    const file = new ChaintracksWritableFile(path, f)
+    return file
+  }
+
+  async close(): Promise<void> {
+    await this.f.close()
+  }
+
+  async ensureFoldersExist(): Promise<void> {
+    if (!this.foldersEnsured) {
+      await ChaintracksFsStatics.ensureFoldersExist(this.path)
+      this.foldersEnsured = true
+    }
+  }
+
+  async append(data: Uint8Array): Promise<void> {
+    await this.ensureFoldersExist()
+    throw new Error('Method not implemented.')
+  }
+}
+
+export class ChaintracksAppendableFile extends ChaintracksReadableFile implements ChaintracksAppendableFileApi {
+  foldersEnsured: boolean = false
+
+  private constructor(path: string, f: fs.FileHandle) {
+    super(path, f)
+  }
+
+  static async openAsAppendable(path: string): Promise<ChaintracksAppendableFile> {
+    const f = await fs.open(path, 'a+')
+    const file = new ChaintracksAppendableFile(path, f)
+    return file
+  }
+
+  async ensureFoldersExist(): Promise<void> {
+    if (!this.foldersEnsured) {
+      await ChaintracksFsStatics.ensureFoldersExist(this.path)
+      this.foldersEnsured = true
+    }
+  }
+
+  async append(data: Uint8Array): Promise<void> {
+    await this.ensureFoldersExist()
+    await this.f.write(Buffer.from(data))
+  }
+}

package/src/services/chaintracker/chaintracks/util/HeightRange.ts

@@ -0,0 +1,153 @@
+import { BlockHeader } from '../../../../sdk/WalletServices.interfaces'
+
+export interface HeightRangeApi {
+  minHeight: number
+  maxHeight: number
+}
+
+export interface HeightRanges {
+  bulk: HeightRange
+  live: HeightRange
+}
+
+/**
+ * Represents a range of block heights.
+ *
+ * Operations support integrating contiguous batches of headers,
+ */
+export class HeightRange implements HeightRangeApi {
+  constructor(
+    public minHeight: number,
+    public maxHeight: number
+  ) {}
+
+  /**
+   * All ranges where maxHeight is less than minHeight are considered empty.
+   * The canonical empty range is (0, -1).
+   */
+  static readonly empty = new HeightRange(0, -1)
+
+  /**
+   * @returns true iff minHeight is greater than maxHeight.
+   */
+  get isEmpty() {
+    return this.minHeight > this.maxHeight
+  }
+
+  /**
+   * @param headers an array of objects with a non-negative integer `height` property.
+   * @returns range of height values from the given headers, or the empty range if there are no headers.
+   */
+  static from(headers: BlockHeader[]): HeightRange {
+    if (headers.length === 0) return HeightRange.empty
+    const minHeight = headers.reduce((min, h) => Math.min(min, h.height), headers[0].height)
+    const maxHeight = headers.reduce((max, h) => Math.max(max, h.height), headers[0].height)
+    return new HeightRange(minHeight, maxHeight)
+  }
+
+  /**
+   * @returns the number of heights in the range, or 0 if the range is empty.
+   */
+  get length() {
+    return Math.max(0, this.maxHeight - this.minHeight + 1)
+  }
+
+  /**
+   * @returns an easy to read string representation of the height range.
+   */
+  toString(): string {
+    return this.isEmpty ? '<empty>' : `${this.minHeight}-${this.maxHeight}`
+  }
+
+  /**
+   * @param range HeightRange or single height value.
+   * @returns true if `range` is entirely within this range.
+   */
+  contains(range: HeightRange | number) {
+    if (typeof range === 'number') {
+      return this.minHeight <= range && this.maxHeight >= range
+    }
+    return this.minHeight <= range.minHeight && this.maxHeight >= range.maxHeight
+  }
+
+  /**
+   * Return the intersection with another height range.
+   *
+   * Intersection with an empty range is always empty.
+   *
+   * The result is always a single, possibly empty, range.
+   * @param range
+   * @returns
+   */
+  intersect(range: HeightRange) {
+    //if (this.isEmpty || range.isEmpty) return HeightRange.empty
+    //if (this.maxHeight < range.minHeight || this.minHeight > range.maxHeight) return HeightRange.empty
+    const r = new HeightRange(Math.max(this.minHeight, range.minHeight), Math.min(this.maxHeight, range.maxHeight))
+    return r
+  }
+
+  /**
+   * Return the union with another height range.
+   *
+   * Only valid if the two ranges overlap or touch, or one is empty.
+   *
+   * Throws an error if the union would create two disjoint ranges.
+   *
+   * @param range
+   * @returns
+   */
+  union(range: HeightRange) {
+    if (this.isEmpty) return range.copy()
+    if (range.isEmpty) return this.copy()
+    if (this.maxHeight + 1 < range.minHeight || range.maxHeight + 1 < this.minHeight)
+      throw new Error('Union of ranges with a gap between them is not supported.')
+    return new HeightRange(Math.min(this.minHeight, range.minHeight), Math.max(this.maxHeight, range.maxHeight))
+  }
+
+  /**
+   * Returns `range` subtracted from this range.
+   *
+   * Throws an error if the subtraction would create two disjoint ranges.
+   *
+   * @param range
+   * @returns
+   */
+  subtract(range: HeightRange) {
+    if (this.isEmpty || range.isEmpty) return this.copy()
+    if (this.minHeight < range.minHeight && this.maxHeight > range.maxHeight)
+      throw new Error('Subtraction of range that creates two disjoint ranges is not supported.')
+    if (range.maxHeight < this.minHeight || range.minHeight > this.maxHeight)
+      // Leave untouched. Subtracted is either all lower or all higher.
+      return this.copy()
+    if (range.minHeight <= this.minHeight && range.maxHeight < this.maxHeight)
+      // Remove a chunk on the low side.
+      return new HeightRange(range.maxHeight + 1, this.maxHeight)
+    if (range.minHeight <= this.minHeight && range.maxHeight >= this.maxHeight)
+      // Remove the whole thing
+      return new HeightRange(this.minHeight, this.minHeight - 1) // empty
+    if (range.minHeight <= this.maxHeight && range.maxHeight >= this.maxHeight)
+      // Remove a chunk on the high side.
+      return new HeightRange(this.minHeight, range.minHeight - 1)
+    throw new Error('All cases should have been handled :-) .')
+  }
+
+  /**
+   * If `range` is not empty and this is not empty, returns a new range minHeight
+   * replaced by to range.maxHeight + 1.
+   *
+   * Otherwise returns a copy of this range.
+   *
+   * This returns the portion of this range that is strictly above `range`.
+   */
+  above(range: HeightRange) {
+    if (range.isEmpty || this.isEmpty) return this.copy()
+    return new HeightRange(range.maxHeight + 1, this.maxHeight)
+  }
+
+  /**
+   * Return a copy of this range.
+   */
+  copy(): HeightRange {
+    return new HeightRange(this.minHeight, this.maxHeight)
+  }
+}

package/src/services/chaintracker/chaintracks/util/SingleWriterMultiReaderLock.ts

@@ -0,0 +1,76 @@
+/**
+ * A reader-writer lock to manage concurrent access.
+ * Allows multiple readers or one writer at a time.
+ */
+export class SingleWriterMultiReaderLock {
+  private readers: number = 0
+  private writerActive: boolean = false
+  private readerQueue: Array<() => void> = []
+  private writerQueue: Array<() => void> = []
+
+  private checkQueues(): void {
+    if (this.writerActive || this.readers > 0) return
+    if (this.writerQueue.length > 0) {
+      // If there are waiting writers and no active readers or writers, start the next writer
+      const resolve = this.writerQueue.shift()!
+      resolve()
+    } else if (this.readerQueue.length > 0) {
+      // If there are waiting readers and no waiting writers, start all readers
+      const readers = this.readerQueue.splice(0)
+      for (const resolve of readers) {
+        resolve()
+      }
+    }
+  }
+
+  async withReadLock<T>(fn: () => Promise<T>): Promise<T> {
+    if (!this.writerActive && this.writerQueue.length === 0) {
+      // Fast path: no active writer or waiting writers, proceed immediately
+      this.readers++
+      try {
+        return await fn()
+      } finally {
+        this.readers--
+        this.checkQueues()
+      }
+    } else {
+      // Queue the reader until writers are done
+      const promise = new Promise<void>(resolve => {
+        this.readerQueue.push(resolve)
+      })
+      await promise
+      this.readers++
+      try {
+        return await fn()
+      } finally {
+        this.readers--
+        this.checkQueues()
+      }
+    }
+  }
+
+  async withWriteLock<T>(fn: () => Promise<T>): Promise<T> {
+    if (!this.writerActive && this.readers === 0) {
+      // Fast path: no active writer or readers, proceed immediately
+      this.writerActive = true
+      try {
+        return await fn()
+      } finally {
+        this.writerActive = false
+        this.checkQueues()
+      }
+    } else {
+      const promise = new Promise<void>(resolve => {
+        this.writerQueue.push(resolve)
+      })
+      await promise
+      this.writerActive = true
+      try {
+        return await fn()
+      } finally {
+        this.writerActive = false
+        this.checkQueues()
+      }
+    }
+  }
+}