@bsv/wallet-toolbox 1.1.0

package/src/services/__tests/postTxs.test.ts

@@ -0,0 +1,20 @@
+import { Beef, Utils } from '@bsv/sdk'
+import { Services } from '../../index.client'
+
+describe('postTxs service tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const options = Services.createDefaultOptions('main')
+    const services = new Services(options)
+
+    const txid =
+      '1e3a4e2a952414081ec8576480b00dc2c1eeb04655480a09f167f7d82ac6e74a'
+    const rawTx = await services.getRawTx(txid)
+    const rawTxHex = Utils.toHex(rawTx.rawTx!)
+    const beef = new Beef()
+    beef.mergeRawTx(rawTx.rawTx!)
+    const r = await services.postTxs(beef, [txid])
+    expect(r[0].status).toBe('success')
+  })
+})

package/src/services/chaintracker/ChaintracksChainTracker.ts

@@ -0,0 +1,78 @@
+import { sdk, wait } from '../../index.client'
+import { ChainTracker } from '@bsv/sdk'
+import { BlockHeader } from './chaintracks'
+import { ChaintracksServiceClient } from './chaintracks/ChaintracksServiceClient'
+
+export interface ChaintracksChainTrackerOptions {
+  maxRetries?: number
+}
+
+export class ChaintracksChainTracker implements ChainTracker {
+  chaintracks: ChaintracksServiceClient
+  cache: Record<number, string>
+  options: ChaintracksChainTrackerOptions
+
+  constructor(
+    chain?: sdk.Chain,
+    chaintracks?: ChaintracksServiceClient,
+    options?: ChaintracksChainTrackerOptions
+  ) {
+    chain ||= 'main'
+    this.chaintracks =
+      chaintracks ??
+      new ChaintracksServiceClient(
+        chain,
+        `https://npm-registry.babbage.systems:808${chain === 'main' ? '4' : '3'}`
+      )
+    this.cache = {}
+    this.options = options || {}
+  }
+
+  async currentHeight(): Promise<number> {
+    return await this.chaintracks.getPresentHeight()
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const cachedRoot = this.cache[height]
+    if (cachedRoot) {
+      return cachedRoot === root
+    }
+
+    let header: BlockHeader | undefined
+
+    const retries = this.options.maxRetries || 3
+
+    let error: sdk.WalletError | undefined = undefined
+
+    for (let tryCount = 1; tryCount <= retries; tryCount++) {
+      try {
+        header = await this.chaintracks.findHeaderForHeight(height)
+
+        if (!header) {
+          return false
+        }
+
+        break
+      } catch (eu: unknown) {
+        error = sdk.WalletError.fromUnknown(eu)
+        if (tryCount > retries) {
+          throw error
+        }
+        await wait(1000)
+      }
+    }
+
+    if (!header)
+      throw new sdk.WERR_INTERNAL(
+        'no header should have returned false or thrown an error.'
+      )
+
+    this.cache[height] = header.merkleRoot
+
+    if (header.merkleRoot !== root) {
+      return false
+    }
+
+    return true
+  }
+}

package/src/services/chaintracker/__tests/ChaintracksChainTracker.test.ts

@@ -0,0 +1,25 @@
+import { ChaintracksChainTracker } from '..'
+import { sdk } from '../../../index.client'
+
+describe('ChaintracksChaintracker tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const chains: sdk.Chain[] = ['main', 'test']
+    for (const chain of chains) {
+      const tracker = new ChaintracksChainTracker(chain)
+      const height = await tracker.currentHeight()
+      expect(height).toBeGreaterThan(877598)
+      const okMain = await tracker.isValidRootForHeight(
+        '2bf2edb5fa42aa773c6c13bc90e097b4e7de7ca1df2227f433be75ceace339e9',
+        877599
+      )
+      expect(okMain).toBe(chain === 'main')
+      const okTest = await tracker.isValidRootForHeight(
+        '5513f13554442588dd9acf395072bf1d2e7d5d360fbc42d3ab1fa2026b17c200',
+        1654265
+      )
+      expect(okTest).toBe(chain === 'test')
+    }
+  })
+})

package/src/services/chaintracker/__tests/ChaintracksServiceClient.test.ts

@@ -0,0 +1,32 @@
+import { sdk } from '../../../index.client'
+import { ChaintracksServiceClient } from '../chaintracks'
+
+describe('ChaintracksServiceClient tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const chains: sdk.Chain[] = ['test', 'main']
+    for (const chain of chains) {
+      const client = new ChaintracksServiceClient(
+        chain,
+        `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`
+      )
+      {
+        // testnet block
+        const r = await client.findHeaderForBlockHash(
+          '0000000049686fe721f70614c89df146e410240f838b8f3ef8e6471c6dfdd153'
+        )
+        if (chain === 'main') expect(r).toBe(undefined)
+        else expect(r?.height).toBe(1651723)
+      }
+      {
+        // mainnet block
+        const r = await client.findHeaderForBlockHash(
+          '00000000000000000b010edee7422c59ec9131742e35f3e0d5837d710b961406'
+        )
+        if (chain === 'main') expect(r?.height).toBe(877595)
+        else expect(r).toBe(undefined)
+      }
+    }
+  })
+})

package/src/services/chaintracker/chaintracks/BlockHeaderApi.ts

@@ -0,0 +1,123 @@
+/**
+ * These are fields of 80 byte serialized header in order whose double sha256 hash is a block's hash value
+ * and the next block's previousHash value.
+ *
+ * All block hash values and merkleRoot values are 32 byte hex string values with the byte order reversed from the serialized byte order.
+ */
+export interface BaseBlockHeader {
+  /**
+   * Block header version value. Serialized length is 4 bytes.
+   */
+  version: number
+  /**
+   * Hash of previous block's block header. Serialized length is 32 bytes.
+   */
+  previousHash: string
+  /**
+   * Root hash of the merkle tree of all transactions in this block. Serialized length is 32 bytes.
+   */
+  merkleRoot: string
+  /**
+   * Block header time value. Serialized length is 4 bytes.
+   */
+  time: number
+  /**
+   * Block header bits value. Serialized length is 4 bytes.
+   */
+  bits: number
+  /**
+   * Block header nonce value. Serialized length is 4 bytes.
+   */
+  nonce: number
+}
+
+/**
+ * A `BaseBlockHeader` extended with its computed hash and height in its chain.
+ */
+export interface BlockHeader extends BaseBlockHeader {
+  /**
+   * Height of the header, starting from zero.
+   */
+  height: number
+  /**
+   * The double sha256 hash of the serialized `BaseBlockHeader` fields.
+   */
+  hash: string
+}
+
+/**
+ * The "live" portion of the block chain is recent history that can conceivably be subject to reorganizations.
+ * The additional fields support tracking orphan blocks, chain forks, and chain reorgs.
+ */
+export interface LiveBlockHeader extends BlockHeader {
+  /**
+   * The cummulative chainwork achieved by the addition of this block to the chain.
+   * Chainwork only matters in selecting the active chain.
+   */
+  chainWork: string
+  /**
+   * True only if this header is currently a chain tip. e.g. There is no header that follows it by previousHash or previousHeaderId.
+   */
+  isChainTip: boolean
+  /**
+   * True only if this header is currently on the active chain.
+   */
+  isActive: boolean
+  /**
+   * As there may be more than one header with identical height values due to orphan tracking,
+   * headers are assigned a unique headerId while part of the "live" portion of the block chain.
+   */
+  headerId: number
+  /**
+   * Every header in the "live" portion of the block chain is linked to an ancestor header through
+   * both its previousHash and previousHeaderId properties.
+   *
+   * Due to forks, there may be multiple headers with identical `previousHash` and `previousHeaderId` values.
+   * Of these, only one (the header on the active chain) will have `isActive` === true.
+   */
+  previousHeaderId: number | null
+}
+
+//
+// TYPE GUARDS
+//
+
+/**
+ * Type guard function.
+ * @publicbody
+ */
+export function isLive(
+  header: BlockHeader | LiveBlockHeader
+): header is LiveBlockHeader {
+  return (header as LiveBlockHeader).headerId !== undefined
+}
+
+/**
+ * Type guard function.
+ * @publicbody
+ */
+export function isBaseBlockHeader(
+  header: BaseBlockHeader | BlockHeader | LiveBlockHeader
+): header is BaseBlockHeader {
+  return typeof header.previousHash === 'string'
+}
+
+/**
+ * Type guard function.
+ * @publicbody
+ */
+export function isBlockHeader(
+  header: BaseBlockHeader | BlockHeader | LiveBlockHeader
+): header is LiveBlockHeader {
+  return 'height' in header && typeof header.previousHash === 'string'
+}
+
+/**
+ * Type guard function.
+ * @publicbody
+ */
+export function isLiveBlockHeader(
+  header: BaseBlockHeader | BlockHeader | LiveBlockHeader
+): header is LiveBlockHeader {
+  return 'chainwork' in header && typeof header.previousHash === 'string'
+}

package/src/services/chaintracker/chaintracks/ChaintracksServiceClient.ts

@@ -0,0 +1,160 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { asString, sdk } from '../../../index.client'
+
+import {
+  BaseBlockHeader,
+  BlockHeader,
+  isBaseBlockHeader
+} from './BlockHeaderApi'
+
+interface FetchStatus<T> {
+  status: 'success' | 'error'
+  code?: string
+  description?: string
+  value?: T
+}
+
+export interface ChaintracksServiceClientOptions {
+  useAuthrite: boolean
+}
+
+/**
+ * Connects to a ChaintracksService to implement 'ChaintracksClientApi'
+ *
+ */
+export class ChaintracksServiceClient {
+  static createChaintracksServiceClientOptions(): ChaintracksServiceClientOptions {
+    const options: ChaintracksServiceClientOptions = {
+      useAuthrite: false
+    }
+    return options
+  }
+
+  options: ChaintracksServiceClientOptions
+
+  constructor(
+    public chain: sdk.Chain,
+    public serviceUrl: string,
+    options?: ChaintracksServiceClientOptions
+  ) {
+    this.options =
+      options ||
+      ChaintracksServiceClient.createChaintracksServiceClientOptions()
+  }
+
+  async currentHeight(): Promise<number> {
+    return await this.getPresentHeight()
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const r = await this.findHeaderForHeight(height)
+    if (!r) return false
+    const isValid = root === asString(r.merkleRoot)
+    return isValid
+  }
+
+  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}`)
+        const v = <FetchStatus<T>>await r.json()
+        if (v.status === 'success') return v.value
+        else e = new Error(JSON.stringify(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
+  }
+
+  async postJsonVoid<T>(path: string, params: T): Promise<void> {
+    const headers = {}
+    headers['Content-Type'] = 'application/json'
+    const r = await fetch(`${this.serviceUrl}${path}`, {
+      body: JSON.stringify(params),
+      method: 'POST',
+      headers
+      //cache: 'no-cache',
+    })
+    try {
+      const s = <FetchStatus<void>>await r.json()
+      if (s.status === 'success') return
+      throw new Error(JSON.stringify(s))
+    } catch (e) {
+      console.log(`Exception: ${JSON.stringify(e)}`)
+      throw new Error(JSON.stringify(e))
+    }
+  }
+
+  //
+  // HTTP API FUNCTIONS
+  //
+
+  async addHeader(header: BaseBlockHeader): Promise<void> {
+    const r = await this.postJsonVoid('/addHeaderHex', header)
+    if (typeof r === 'string') throw new Error(r)
+  }
+
+  async startListening(): Promise<void> {
+    return await this.getJsonOrUndefined('/startListening')
+  }
+  async listening(): Promise<void> {
+    return await this.getJsonOrUndefined('/listening')
+  }
+  async getChain(): Promise<sdk.Chain> {
+    return this.chain
+    //return await this.getJson('/getChain')
+  }
+
+  async isListening(): Promise<boolean> {
+    return await this.getJson('/isListening')
+  }
+  async isSynchronized(): Promise<boolean> {
+    return await this.getJson('/isSynchronized')
+  }
+  async getPresentHeight(): Promise<number> {
+    return await this.getJson('/getPresentHeight')
+  }
+  async findChainTipHeader(): Promise<BlockHeader> {
+    return await this.getJson('/findChainTipHeaderHex')
+  }
+  async findChainTipHashHex(): Promise<string> {
+    return await this.getJson('/findChainTipHashHex')
+  }
+
+  async getHeaders(height: number, count: number): Promise<string> {
+    return await this.getJson(`/getHeaders?height=${height}&count=${count}`)
+  }
+  async findHeaderForHeight(height: number): Promise<BlockHeader | undefined> {
+    return await this.getJsonOrUndefined(
+      `/findHeaderHexForHeight?height=${height}`
+    )
+  }
+  async findChainWorkForBlockHash(hash: string): Promise<string | undefined> {
+    return await this.getJsonOrUndefined(
+      `/findChainWorkHexForBlockHash?hash=${asString(hash)}`
+    )
+  }
+  async findHeaderForBlockHash(hash: string): Promise<BlockHeader | undefined> {
+    return await this.getJsonOrUndefined(
+      `/findHeaderHexForBlockHash?hash=${asString(hash)}`
+    )
+  }
+  async findHeaderForMerkleRoot(
+    merkleRoot: string,
+    height?: number
+  ): Promise<BlockHeader | undefined> {
+    return await this.getJsonOrUndefined(
+      `/findHeaderHexForMerkleRoot?root=${asString(merkleRoot)}&height=${height}`
+    )
+  }
+}

package/src/services/chaintracker/chaintracks/index.ts

@@ -0,0 +1,2 @@
+export * from './ChaintracksServiceClient'
+export * from './BlockHeaderApi'

package/src/services/chaintracker/index.ts

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

package/src/services/createDefaultWalletServicesOptions.ts

@@ -0,0 +1,38 @@
+import { sdk } from '../index.client'
+import { ChaintracksServiceClient } from './chaintracker'
+
+export function createDefaultWalletServicesOptions(
+  chain: sdk.Chain
+): sdk.WalletServicesOptions {
+  const o: sdk.WalletServicesOptions = {
+    chain,
+    taalApiKey:
+      chain === 'main'
+        ? 'mainnet_9596de07e92300c6287e4393594ae39c' // Tone's key, no plan
+        : 'testnet_0e6cf72133b43ea2d7861da2a38684e3', // Tone's personal "starter" key
+    bsvExchangeRate: {
+      timestamp: new Date('2023-12-13'),
+      base: 'USD',
+      rate: 47.52
+    },
+    bsvUpdateMsecs: 1000 * 60 * 15, // 15 minutes
+    fiatExchangeRates: {
+      timestamp: new Date('2023-12-13'),
+      base: 'USD',
+      rates: {
+        USD: 1,
+        GBP: 0.8,
+        EUR: 0.93
+      }
+    },
+    fiatUpdateMsecs: 1000 * 60 * 60 * 24, // 24 hours
+    disableMapiCallback: true, // Rely on WalletMonitor by default.
+    exchangeratesapiKey: 'bd539d2ff492bcb5619d5f27726a766f',
+    chaintracksFiatExchangeRatesUrl: `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}/getFiatExchangeRates`,
+    chaintracks: new ChaintracksServiceClient(
+      chain,
+      `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`
+    )
+  }
+  return o
+}

package/src/services/index.ts

@@ -0,0 +1 @@
+export * from './Services'