@bsv/wallet-toolbox 1.4.6 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -32,7 +32,7 @@
   "dependencies": {
     "@bsv/auth-express-middleware": "^1.1.2",
     "@bsv/payment-express-middleware": "^1.0.6",
-    "@bsv/sdk": "^1.6.0",
+    "@bsv/sdk": "^1.6.5",
     "express": "^4.21.2",
     "idb": "^8.0.2",
     "knex": "^3.1.0",

package/src/Setup.ts

@@ -26,6 +26,8 @@ import {
 import { Knex, knex as makeKnex } from 'knex'
 
 import * as dotenv from 'dotenv'
+// To rely on your own headers service, uncomment the following line:
+// import { BHServiceClient } from './services/chaintracker'
 dotenv.config()
 
 /**
@@ -145,6 +147,10 @@ DEV_KEYS = '{
     if (storage.canMakeAvailable()) await storage.makeAvailable()
     const serviceOptions = Services.createDefaultOptions(chain)
     serviceOptions.taalApiKey = args.env.taalApiKey
+
+    // To rely on your own headers service, uncomment the following line, updating the url and apiKey to your own values.
+    // serviceOptions.chaintracks = new BHServiceClient('main', 'https://headers.spv.money', 'fC42F069YJs30FaWBAgikfDFEfIW1j4q')
+
     const services = new Services(serviceOptions)
     const monopts = Monitor.createDefaultWalletMonitorOptions(chain, storage, services)
     const monitor = new Monitor(monopts)

package/src/services/__tests/ArcGorillaPool.man.test.ts

@@ -2,7 +2,7 @@ import { _tu, logger } from '../../../test/utils/TestUtilsWalletStorage'
 import { sdk, wait } from '../../index.client'
 import { ARC } from '../providers/ARC'
 import { Beef, BeefTx } from '@bsv/sdk'
-import { arcDefaultUrl, arcGorillaPoolUrl } from '../createDefaultWalletServicesOptions'
+import { arcGorillaPoolUrl } from '../createDefaultWalletServicesOptions'
 import { Setup } from '../../index.all'
 
 describe('ArcGorillaPool tests', () => {

package/src/services/chaintracker/BHServiceClient.ts

@@ -0,0 +1,199 @@
+import { BlockHeadersService, Utils } from '@bsv/sdk'
+import { ChaintracksServiceClient, ChaintracksServiceClientOptions } from './chaintracks/ChaintracksServiceClient'
+import { sdk } from '../../index.client'
+import { BaseBlockHeader, BlockHeader } from './chaintracks'
+import { serializeBlockHeader } from './chaintracks/util/blockHeaderUtilities'
+
+interface BHSHeader {
+  hash: string
+  version: number
+  prevBlockHash: string
+  merkleRoot: string
+  creationTimestamp: number
+  difficultyTarget: number
+  nonce: number
+  work: string
+}
+
+interface BHSHeaderState {
+  header: BHSHeader
+  state: string
+  chainWork: string
+  height: number
+}
+
+export class BHServiceClient implements ChaintracksServiceClient {
+  bhs: BlockHeadersService
+  cache: Record<number, string>
+  chain: sdk.Chain
+  serviceUrl: string
+  options: ChaintracksServiceClientOptions
+  apiKey: string
+
+  constructor(chain: sdk.Chain, url: string, apiKey: string) {
+    this.bhs = new BlockHeadersService(url, { apiKey })
+    this.cache = {}
+    this.chain = chain
+    this.serviceUrl = url
+    this.options = ChaintracksServiceClient.createChaintracksServiceClientOptions()
+    this.options.useAuthrite = true
+    this.apiKey = apiKey
+  }
+
+  async currentHeight(): Promise<number> {
+    return await this.bhs.currentHeight()
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const cachedRoot = this.cache[height]
+    if (cachedRoot) {
+      return cachedRoot === root
+    }
+    const isValid = await this.bhs.isValidRootForHeight(root, height)
+    this.cache[height] = root
+    return isValid
+  }
+
+  async getPresentHeight(): Promise<number> {
+    return await this.bhs.currentHeight()
+  }
+
+  async findHeaderForHeight(height: number): Promise<BlockHeader | undefined> {
+    const response = await this.getJsonOrUndefined<BHSHeader[]>(`/api/v1/chain/header/byHeight?height=${height}`)
+    const header = response?.[0]
+    if (!header) return undefined
+    const formatted: BlockHeader = {
+      version: header.version,
+      previousHash: header.prevBlockHash,
+      merkleRoot: header.merkleRoot,
+      time: header.creationTimestamp,
+      bits: header.difficultyTarget,
+      nonce: header.nonce,
+      height,
+      hash: header.hash
+    }
+    return formatted
+  }
+
+  async findHeaderForBlockHash(hash: string): Promise<BlockHeader | undefined> {
+    const response = await this.getJsonOrUndefined<BHSHeaderState>(`/api/v1/chain/header/state/${hash}`)
+    if (!response?.header) return undefined
+    const formatted: BlockHeader = {
+      version: response.header.version,
+      previousHash: response.header.prevBlockHash,
+      merkleRoot: response.header.merkleRoot,
+      time: response.header.creationTimestamp,
+      bits: response.header.difficultyTarget,
+      nonce: response.header.nonce,
+      height: response.height,
+      hash: response.header.hash
+    }
+    return formatted
+  }
+
+  async getHeaders(height: number, count: number): Promise<string> {
+    const response = await this.getJsonOrUndefined<BHSHeader[]>(
+      `/api/v1/chain/header/byHeight?height=${height}&count=${count}`
+    )
+    if (!response) return ''
+    if (response.length < count) throw new Error('Cannot retrieve enough headers')
+    const headers = response.map(response => {
+      const header: BaseBlockHeader = {
+        version: response.version,
+        previousHash: response.prevBlockHash,
+        merkleRoot: response.merkleRoot,
+        time: response.creationTimestamp,
+        bits: response.difficultyTarget,
+        nonce: response.nonce
+      }
+      return serializeBlockHeader(header)
+    })
+    return headers.reduce((str: string, arr: number[]) => str + Utils.toHex(arr), '')
+  }
+
+  async findChainWorkForBlockHash(hash: string): Promise<string | undefined> {
+    throw new Error('Not implemented')
+  }
+
+  async findChainTipHeader(): Promise<BlockHeader> {
+    const response = await this.getJson<BHSHeaderState>('/api/v1/chain/tip/longest')
+    const formatted: BlockHeader = {
+      version: response.header.version,
+      previousHash: response.header.prevBlockHash,
+      merkleRoot: response.header.merkleRoot,
+      time: response.header.creationTimestamp,
+      bits: response.header.difficultyTarget,
+      nonce: response.header.nonce,
+      height: response.height,
+      hash: response.header.hash
+    }
+    return formatted
+  }
+
+  async getJsonOrUndefined<T>(path: string): Promise<T | undefined> {
+    let e: Error | undefined = undefined
+    for (let retry = 0; retry < 3; retry++) {
+      try {
+        const r = await fetch(`${this.serviceUrl}${path}`, { headers: { Authorization: `Bearer ${this.apiKey}` } })
+        if (r.status !== 200) throw new Error(JSON.stringify(r))
+        const v = <T>await r.json()
+        if (!v) return undefined
+        return v
+      } catch (eu: unknown) {
+        e = eu as Error
+      }
+      if (e && e.name !== 'ECONNRESET') break
+    }
+    if (e) throw e
+  }
+
+  async getJson<T>(path: string): Promise<T> {
+    const r = await this.getJsonOrUndefined<T>(path)
+    if (r === undefined) throw new Error('Value was undefined. Requested object may not exist.')
+    return r
+  }
+
+  /*
+    Please note that all methods hereafter are included only to match the interface of ChaintracksServiceClient.
+  */
+
+  async postJsonVoid<T>(path: string, params: T): Promise<void> {
+    throw new Error('Not implemented')
+  }
+
+  async addHeader(header: any): Promise<void> {
+    throw new Error('Not implemented')
+  }
+
+  async findHeaderForMerkleRoot(merkleRoot: string, height?: number): Promise<undefined> {
+    throw new Error('Not implemented')
+  }
+
+  async startListening(): Promise<void> {
+    throw new Error('Not implemented')
+  }
+
+  async listening(): Promise<void> {
+    throw new Error('Not implemented')
+  }
+
+  async isSynchronized(): Promise<boolean> {
+    throw new Error('Not implemented')
+  }
+
+  async getChain(): Promise<sdk.Chain> {
+    return this.chain
+  }
+
+  async isListening(): Promise<boolean> {
+    throw new Error('Not implemented')
+  }
+
+  async getChainTipHeader(): Promise<BlockHeader> {
+    throw new Error('Not implemented')
+  }
+
+  async findChainTipHashHex(): Promise<string> {
+    throw new Error('Not implemented')
+  }
+}

package/src/services/chaintracker/index.ts

@@ -1,2 +1,3 @@
 export * from './chaintracks'
 export * from './ChaintracksChainTracker'
+export * from './BHServiceClient'

package/src/services/createDefaultWalletServicesOptions.ts

@@ -1,13 +1,17 @@
 import { randomBytesHex, sdk } from '../index.client'
 import { ChaintracksServiceClient } from './chaintracker'
 
-export function createDefaultWalletServicesOptions(chain: sdk.Chain): sdk.WalletServicesOptions {
+export function createDefaultWalletServicesOptions(
+  chain: sdk.Chain,
+  arcCallbackUrl?: string,
+  arcCallbackToken?: string,
+  arcApiKey?: string
+): sdk.WalletServicesOptions {
   const deploymentId = `wallet-toolbox-${randomBytesHex(16)}`
   const taalApiKey =
-    chain === 'main'
+    arcApiKey || chain === 'main'
       ? 'mainnet_9596de07e92300c6287e4393594ae39c' // no plan
       : 'testnet_0e6cf72133b43ea2d7861da2a38684e3' // personal "starter" key
-  const gorillaPoolApiKey = chain === 'main' ? '' : ''
 
   const o: sdk.WalletServicesOptions = {
     chain,
@@ -37,13 +41,17 @@ export function createDefaultWalletServicesOptions(chain: sdk.Chain): sdk.Wallet
     ),
     arcUrl: arcDefaultUrl(chain),
     arcConfig: {
-      apiKey: taalApiKey,
-      deploymentId
+      apiKey: arcApiKey ?? undefined,
+      deploymentId,
+      callbackUrl: arcCallbackUrl ?? undefined,
+      callbackToken: arcCallbackToken ?? undefined
     },
     arcGorillaPoolUrl: arcGorillaPoolUrl(chain),
     arcGorillaPoolConfig: {
-      apiKey: gorillaPoolApiKey,
-      deploymentId
+      apiKey: arcApiKey ?? undefined,
+      deploymentId,
+      callbackUrl: arcCallbackUrl ?? undefined,
+      callbackToken: arcCallbackToken ?? undefined
     }
   }
   return o