@bsv/wallet-toolbox 1.5.21 → 1.6.1

package/src/services/chaintracker/chaintracks/Storage/ChaintracksStorageNoDb.ts

@@ -0,0 +1,372 @@
+import { ChaintracksStorageBaseOptions, InsertHeaderResult } from '../Api/ChaintracksStorageApi'
+import { ChaintracksStorageBase } from '../Storage/ChaintracksStorageBase'
+import { LiveBlockHeader } from '../Api/BlockHeaderApi'
+import { addWork, convertBitsToWork, isMoreWork, serializeBaseBlockHeader } from '../util/blockHeaderUtilities'
+import { HeightRange } from '../util/HeightRange'
+import { BulkFilesReaderStorage } from '../util/BulkFilesReader'
+import { ChaintracksFetch } from '../util/ChaintracksFetch'
+import { Chain } from '../../../../sdk/types'
+import { WERR_INVALID_PARAMETER } from '../../../../sdk/WERR_errors'
+import { BlockHeader } from '../../../../sdk/WalletServices.interfaces'
+
+interface ChaintracksNoDbData {
+  chain: Chain
+  liveHeaders: Map<number, LiveBlockHeader>
+  maxHeaderId: number
+  tipHeaderId: number
+  hashToHeaderId: Map<string, number>
+}
+
+export interface ChaintracksStorageNoDbOptions extends ChaintracksStorageBaseOptions {}
+
+export class ChaintracksStorageNoDb extends ChaintracksStorageBase {
+  static mainData: ChaintracksNoDbData = {
+    chain: 'main',
+    liveHeaders: new Map<number, LiveBlockHeader>(),
+    maxHeaderId: 0,
+    tipHeaderId: 0,
+    hashToHeaderId: new Map<string, number>()
+  }
+  static testData: ChaintracksNoDbData = {
+    chain: 'test',
+    liveHeaders: new Map<number, LiveBlockHeader>(),
+    maxHeaderId: 0,
+    tipHeaderId: 0,
+    hashToHeaderId: new Map<string, number>()
+  }
+
+  constructor(options: ChaintracksStorageNoDbOptions) {
+    super(options)
+  }
+
+  override async destroy(): Promise<void> {}
+
+  async getData(): Promise<ChaintracksNoDbData> {
+    if (this.chain === 'main') {
+      return ChaintracksStorageNoDb.mainData
+    } else if (this.chain === 'test') {
+      return ChaintracksStorageNoDb.testData
+    } else {
+      throw new WERR_INVALID_PARAMETER('chain', `either 'main' or 'test. '${this.chain}' is unsupported.`)
+    }
+  }
+
+  override async deleteLiveBlockHeaders(): Promise<void> {
+    const data = await this.getData()
+    data.liveHeaders.clear()
+    data.maxHeaderId = 0
+    data.tipHeaderId = 0
+    data.hashToHeaderId.clear()
+  }
+
+  override async deleteOlderLiveBlockHeaders(maxHeight: number): Promise<number> {
+    const data = await this.getData()
+    let deletedCount = 0
+
+    // Clear previousHeaderId references
+    for (const [headerId, header] of data.liveHeaders) {
+      if (header.previousHeaderId) {
+        const prevHeader = data.liveHeaders.get(header.previousHeaderId)
+        if (prevHeader && prevHeader.height <= maxHeight) {
+          data.liveHeaders.set(headerId, { ...header, previousHeaderId: null })
+        }
+      }
+    }
+
+    // Delete headers up to maxHeight
+    const headersToDelete = new Set<number>()
+    for (const [headerId, header] of data.liveHeaders) {
+      if (header.height <= maxHeight) {
+        headersToDelete.add(headerId)
+        data.hashToHeaderId.delete(header.hash)
+      }
+    }
+    deletedCount = headersToDelete.size
+    for (const headerId of headersToDelete) {
+      data.liveHeaders.delete(headerId)
+    }
+
+    // Update tipHeaderId if necessary
+    if (data.liveHeaders.size > 0) {
+      const tip = Array.from(data.liveHeaders.values()).find(h => h.isActive && h.isChainTip)
+      data.tipHeaderId = tip ? tip.headerId : 0
+    } else {
+      data.tipHeaderId = 0
+    }
+
+    return deletedCount
+  }
+
+  override async findChainTipHeader(): Promise<LiveBlockHeader> {
+    const data = await this.getData()
+    const tip = Array.from(data.liveHeaders.values()).find(h => h.isActive && h.isChainTip)
+    if (!tip) throw new Error('Database contains no active chain tip header.')
+    return tip
+  }
+
+  override async findChainTipHeaderOrUndefined(): Promise<LiveBlockHeader | undefined> {
+    const data = await this.getData()
+    return Array.from(data.liveHeaders.values()).find(h => h.isActive && h.isChainTip)
+  }
+
+  override async findLiveHeaderForBlockHash(hash: string): Promise<LiveBlockHeader | null> {
+    const data = await this.getData()
+    const headerId = data.hashToHeaderId.get(hash)
+    return headerId ? data.liveHeaders.get(headerId) || null : null
+  }
+
+  override async findLiveHeaderForHeaderId(headerId: number): Promise<LiveBlockHeader> {
+    const data = await this.getData()
+    const header = data.liveHeaders.get(headerId)
+    if (!header) throw new Error(`HeaderId ${headerId} not found in live header database.`)
+    return header
+  }
+
+  override async findLiveHeaderForHeight(height: number): Promise<LiveBlockHeader | null> {
+    const data = await this.getData()
+    return Array.from(data.liveHeaders.values()).find(h => h.height === height && h.isActive) || null
+  }
+
+  override async findLiveHeaderForMerkleRoot(merkleRoot: string): Promise<LiveBlockHeader | null> {
+    const data = await this.getData()
+    return Array.from(data.liveHeaders.values()).find(h => h.merkleRoot === merkleRoot) || null
+  }
+
+  override async findLiveHeightRange(): Promise<{ minHeight: number; maxHeight: number }> {
+    const data = await this.getData()
+    const activeHeaders = Array.from(data.liveHeaders.values()).filter(h => h.isActive)
+    if (activeHeaders.length === 0) {
+      return { minHeight: 0, maxHeight: -1 }
+    }
+    const minHeight = Math.min(...activeHeaders.map(h => h.height))
+    const maxHeight = Math.max(...activeHeaders.map(h => h.height))
+    return { minHeight, maxHeight }
+  }
+
+  override async findMaxHeaderId(): Promise<number> {
+    const data = await this.getData()
+    return data.maxHeaderId
+  }
+
+  override async getLiveHeightRange(): Promise<HeightRange> {
+    const data = await this.getData()
+    const activeHeaders = Array.from(data.liveHeaders.values()).filter(h => h.isActive)
+    if (activeHeaders.length === 0) {
+      return new HeightRange(0, -1)
+    }
+    const minHeight = Math.min(...activeHeaders.map(h => h.height))
+    const maxHeight = Math.max(...activeHeaders.map(h => h.height))
+    return new HeightRange(minHeight, maxHeight)
+  }
+
+  override async liveHeadersForBulk(count: number): Promise<LiveBlockHeader[]> {
+    const data = await this.getData()
+    return Array.from(data.liveHeaders.values())
+      .filter(h => h.isActive)
+      .sort((a, b) => a.height - b.height)
+      .slice(0, count)
+  }
+
+  override async getHeaders(height: number, count: number): Promise<number[]> {
+    if (count <= 0) return []
+
+    const data = await this.getData()
+    const headers = Array.from(data.liveHeaders.values())
+      .filter(h => h.isActive && h.height >= height && h.height < height + count)
+      .sort((a, b) => a.height - b.height)
+      .slice(0, count)
+
+    const bufs: Uint8Array[] = []
+
+    if (headers.length === 0 || headers[0].height > height) {
+      const bulkCount = headers.length === 0 ? count : headers[0].height - height
+      const range = new HeightRange(height, height + bulkCount - 1)
+      const reader = await BulkFilesReaderStorage.fromStorage(this, new ChaintracksFetch(), range, bulkCount * 80)
+      const bulkData = await reader.read()
+      if (bulkData) {
+        bufs.push(bulkData)
+      }
+    }
+
+    if (headers.length > 0) {
+      let buf = new Uint8Array(headers.length * 80)
+      for (let i = 0; i < headers.length; i++) {
+        const h = headers[i]
+        const ha = serializeBaseBlockHeader(h)
+        buf.set(ha, i * 80)
+      }
+      bufs.push(buf)
+    }
+
+    const r: number[] = []
+    for (const bh of bufs) {
+      for (const b of bh) {
+        r.push(b)
+      }
+    }
+    return r
+  }
+
+  override async insertHeader(header: BlockHeader, prev?: LiveBlockHeader): Promise<InsertHeaderResult> {
+    const data = await this.getData()
+
+    let ok = true
+    let dupe = false
+    let noPrev = false
+    let badPrev = false
+    let noActiveAncestor = false
+    let noTip = false
+    let setActiveChainTip = false
+    let reorgDepth = 0
+    let priorTip: LiveBlockHeader | undefined
+
+    // Check for duplicate
+    if (data.hashToHeaderId.has(header.hash)) {
+      dupe = true
+      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+    }
+
+    // Find previous header
+    let oneBack = Array.from(data.liveHeaders.values()).find(h => h.hash === header.previousHash)
+    if (!oneBack && prev && prev.hash === header.previousHash && prev.height + 1 === header.height) {
+      oneBack = prev
+    }
+
+    if (!oneBack) {
+      // Check if this is first live header
+      if (data.liveHeaders.size === 0) {
+        const lbf = await this.bulkManager.getLastFile()
+        if (lbf && header.previousHash === lbf.lastHash && header.height === lbf.firstHeight + lbf.count) {
+          const chainWork = addWork(lbf.lastChainWork, convertBitsToWork(header.bits))
+          const newHeader = {
+            ...header,
+            headerId: ++data.maxHeaderId,
+            previousHeaderId: null,
+            chainWork,
+            isChainTip: true,
+            isActive: true
+          }
+          data.liveHeaders.set(newHeader.headerId, newHeader)
+          data.hashToHeaderId.set(header.hash, newHeader.headerId)
+          data.tipHeaderId = newHeader.headerId
+          return {
+            added: true,
+            dupe,
+            isActiveTip: true,
+            reorgDepth,
+            priorTip,
+            noPrev,
+            badPrev,
+            noActiveAncestor,
+            noTip
+          }
+        }
+        noPrev = true
+        return {
+          added: false,
+          dupe,
+          isActiveTip: false,
+          reorgDepth,
+          priorTip,
+          noPrev,
+          badPrev,
+          noActiveAncestor,
+          noTip
+        }
+      }
+      noPrev = true
+      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+    }
+
+    if (oneBack.height + 1 !== header.height) {
+      badPrev = true
+      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+    }
+
+    const chainWork = addWork(oneBack.chainWork, convertBitsToWork(header.bits))
+    let tip =
+      oneBack.isActive && oneBack.isChainTip
+        ? oneBack
+        : Array.from(data.liveHeaders.values()).find(h => h.isActive && h.isChainTip)
+
+    if (!tip) {
+      noTip = true
+      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+    }
+
+    priorTip = tip
+    setActiveChainTip = isMoreWork(chainWork, tip.chainWork)
+
+    const newHeader = {
+      ...header,
+      headerId: ++data.maxHeaderId,
+      previousHeaderId: oneBack === prev ? null : oneBack.headerId,
+      chainWork,
+      isChainTip: setActiveChainTip,
+      isActive: setActiveChainTip
+    }
+
+    if (setActiveChainTip) {
+      let activeAncestor = oneBack
+      while (!activeAncestor.isActive) {
+        const previousHeader = data.liveHeaders.get(activeAncestor.previousHeaderId!)
+        if (!previousHeader) {
+          noActiveAncestor = true
+          return {
+            added: false,
+            dupe,
+            isActiveTip: false,
+            reorgDepth,
+            priorTip,
+            noPrev,
+            badPrev,
+            noActiveAncestor,
+            noTip
+          }
+        }
+        activeAncestor = previousHeader
+      }
+
+      if (!(oneBack.isActive && oneBack.isChainTip)) {
+        reorgDepth = Math.min(priorTip.height, header.height) - activeAncestor.height
+      }
+
+      if (activeAncestor.headerId !== oneBack.headerId) {
+        let headerToDeactivate = Array.from(data.liveHeaders.values()).find(h => h.isChainTip && h.isActive)
+        while (headerToDeactivate && headerToDeactivate.headerId !== activeAncestor.headerId) {
+          data.liveHeaders.set(headerToDeactivate.headerId, { ...headerToDeactivate, isActive: false })
+          headerToDeactivate = data.liveHeaders.get(headerToDeactivate.previousHeaderId!)
+        }
+
+        let headerToActivate = oneBack
+        while (headerToActivate.headerId !== activeAncestor.headerId) {
+          data.liveHeaders.set(headerToActivate.headerId, { ...headerToActivate, isActive: true })
+          headerToActivate = data.liveHeaders.get(headerToActivate.previousHeaderId!)!
+        }
+      }
+    }
+
+    if (oneBack.isChainTip && oneBack !== prev) {
+      data.liveHeaders.set(oneBack.headerId, { ...oneBack, isChainTip: false })
+    }
+
+    data.liveHeaders.set(newHeader.headerId, newHeader)
+    data.hashToHeaderId.set(newHeader.hash, newHeader.headerId)
+    if (setActiveChainTip) {
+      data.tipHeaderId = newHeader.headerId
+      this.pruneLiveBlockHeaders(newHeader.height)
+    }
+
+    return {
+      added: ok,
+      dupe,
+      isActiveTip: setActiveChainTip,
+      reorgDepth,
+      priorTip,
+      noPrev,
+      badPrev,
+      noActiveAncestor,
+      noTip
+    }
+  }
+}

package/src/services/chaintracker/chaintracks/Storage/__tests/ChaintracksStorageKnex.test.ts

@@ -0,0 +1,45 @@
+import { Knex, knex as makeKnex } from 'knex'
+import { ChaintracksFs } from '../../util/ChaintracksFs'
+import { Chain } from '../../../../../sdk'
+import { ChaintracksStorageKnex } from '../ChaintracksStorageKnex'
+import { deserializeBaseBlockHeader, genesisHeader } from '../../util/blockHeaderUtilities'
+
+describe('ChaintracksStorageKnex tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const chain: Chain = 'main'
+    const fs = ChaintracksFs
+    const rootFolder = './src/services/chaintracker/chaintracks/__tests/data'
+    const localSqlite: Knex.Config = {
+      client: 'sqlite3',
+      connection: { filename: fs.pathJoin(rootFolder, `${chain}Net_chaintracks.sqlite`) },
+      useNullAsDefault: true
+    }
+
+    const knexInstance = makeKnex(localSqlite)
+
+    const knexOptions = ChaintracksStorageKnex.createStorageKnexOptions(chain)
+    knexOptions.knex = knexInstance
+    const storage = new ChaintracksStorageKnex(knexOptions)
+    await storage.makeAvailable()
+
+    const bfs = await storage.bulkManager.getBulkFiles()
+    // Test assumes synchronization has occurred and bulk files are available.
+    if (bfs?.length === 0) return
+
+    expect(bfs.length).toBeGreaterThan(7)
+
+    const gh = await storage.getBulkFileData(bfs[0].fileId!, 0, 80)
+    const dgh = deserializeBaseBlockHeader(gh!)
+    const rgh = genesisHeader(chain)
+    expect(dgh.merkleRoot).toEqual(rgh.merkleRoot)
+    expect(dgh.bits).toEqual(rgh.bits)
+    expect(dgh.nonce).toEqual(rgh.nonce)
+
+    const header = await storage.findHeaderForHeight(101010)
+    expect(header.hash).toEqual('000000000001af33247fff33aae7c31baee4148d5a189e7353bf13bcee618202')
+
+    await storage.shutdown()
+  })
+})

package/src/services/chaintracker/chaintracks/__tests/Chaintracks.test.ts

@@ -0,0 +1,49 @@
+import { createDefaultKnexChaintracksOptions } from '../createDefaultKnexChaintracksOptions'
+import { Chaintracks } from '../Chaintracks'
+import { wait } from '../../../../utility/utilityHelpers'
+import { Chain } from '../../../../sdk'
+import { createNoDbChaintracksOptions } from '../createDefaultNoDbChaintracksOptions'
+
+const rootFolder = './src/services/chaintracker/chaintracks/__tests/data'
+
+describe('Chaintracks tests', () => {
+  jest.setTimeout(99999999)
+
+  test.skip('0 basic operation mainnet', async () => {
+    const o = createDefaultKnexChaintracksOptions('main', rootFolder)
+    const c = new Chaintracks(o)
+    await c.makeAvailable()
+
+    let done = false
+    for (; !done; ) {
+      await wait(10000)
+    }
+
+    await c.destroy()
+  })
+
+  test('1 NoDb mainnet', async () => {
+    await NoDbBody('main')
+  })
+
+  test('2 NoDb testnet', async () => {
+    await NoDbBody('test')
+  })
+
+  async function NoDbBody(chain: Chain) {
+    const o = createNoDbChaintracksOptions(chain)
+    const c = new Chaintracks(o)
+    await c.makeAvailable()
+
+    c.subscribeHeaders(header => {
+      console.log(`Header received: ${header.height} ${header.hash}`)
+    })
+
+    //let done = false
+    //for (; !done; ) {
+    await wait(1000)
+    //}
+
+    await c.destroy()
+  }
+})

package/src/services/chaintracker/chaintracks/__tests/ChaintracksClientApi.test.ts

@@ -0,0 +1,183 @@
+import { Chain } from '../../../../sdk/types'
+import { BaseBlockHeader, BlockHeader } from '../../../../sdk/WalletServices.interfaces'
+import { asUint8Array } from '../../../../utility/utilityHelpers.noBuffer'
+import { ChaintracksClientApi } from '../Api/ChaintracksClientApi'
+import { ChaintracksStorageApi } from '../Api/ChaintracksStorageApi'
+import { Chaintracks } from '../Chaintracks'
+import { ChaintracksService } from '../ChaintracksService'
+import { ChaintracksServiceClient } from '../ChaintracksServiceClient'
+import {
+  blockHash,
+  deserializeBaseBlockHeaders,
+  genesisBuffer,
+  serializeBaseBlockHeader
+} from '../util/blockHeaderUtilities'
+
+type ClientClass = 'ChaintracksSingletonClient' | 'Chaintracks' | 'ChaintracksServiceClient' | undefined
+let clientClass: ClientClass = undefined
+
+clientClass = 'Chaintracks'
+//clientClass = "ChaintracksSingletonClient"
+//clientClass = "ChaintracksServiceClient"
+const includeLocalServiceClient = true
+const includeLocalServiceChaintracks = true
+const includeNpmRegistryClient = true
+
+describe(`ChaintracksClientApi tests`, () => {
+  jest.setTimeout(999999999)
+
+  const chain: Chain = 'main'
+
+  const clients: ChaintracksClientApi[] = []
+
+  let localService: ChaintracksService
+  let localServiceStorage: ChaintracksStorageApi
+  let localServiceClient: ChaintracksClientApi
+  let firstTip: BlockHeader
+
+  beforeAll(async () => {
+    if (includeLocalServiceChaintracks || includeLocalServiceClient) {
+      localService = new ChaintracksService(ChaintracksService.createChaintracksServiceOptions(chain))
+      localServiceStorage = localService.chaintracks['storageEngine'] as ChaintracksStorageApi
+      await localService.startJsonRpcServer()
+
+      if (includeLocalServiceClient) {
+        localServiceClient = new ChaintracksServiceClient(chain, `http://localhost:${localService.port}`, {})
+        clients.push(localServiceClient)
+      }
+
+      if (includeLocalServiceChaintracks) {
+        clients.push(localService.chaintracks)
+      }
+    }
+
+    if (includeNpmRegistryClient) {
+      clients.push(makeNpmRegistryClient(chain))
+    }
+
+    const ft = await clients[0].findChainTipHeader()
+    if (!ft) throw new Error('No chain tip found')
+    firstTip = ft
+  })
+
+  afterAll(async () => {
+    await localService?.stopJsonRpcServer()
+  })
+
+  test('0 getChain', async () => {
+    for (const client of clients) {
+      const gotChain = await client.getChain()
+      expect(gotChain).toBe(chain)
+    }
+  })
+
+  test('1 getInfo', async () => {
+    for (const client of clients) {
+      const gotInfo = await client.getInfo()
+      expect(gotInfo.chain).toBe(chain)
+      expect(gotInfo.heightBulk).toBeGreaterThan(700000)
+      expect(gotInfo.heightLive).toBeGreaterThanOrEqual(firstTip.height)
+    }
+  })
+
+  test('2 getPresentHeight', async () => {
+    for (const client of clients) {
+      const presentHeight = await client.getPresentHeight()
+      expect(presentHeight).toBeGreaterThanOrEqual(firstTip.height)
+    }
+  })
+
+  test('3 getHeaders', async () => {
+    for (const client of clients) {
+      const info = await client.getInfo()
+      const h0 = info.heightBulk + 1
+      const h1 = info.heightLive || 10
+      const bulkHeaders = await getHeaders(h0 - 2, 2)
+      expect(bulkHeaders.length).toBe(2)
+      expect(bulkHeaders[1].previousHash === blockHash(bulkHeaders[0])).toBe(true)
+      const bothHeaders = await getHeaders(h0 - 1, 2)
+      expect(bothHeaders.length).toBe(2)
+      expect(bothHeaders[1].previousHash === blockHash(bothHeaders[0])).toBe(true)
+      const liveHeaders = await getHeaders(h0 - 0, 2)
+      expect(liveHeaders.length).toBe(2)
+      expect(liveHeaders[1].previousHash === blockHash(liveHeaders[0])).toBe(true)
+      const partHeaders = await getHeaders(h1, 2)
+      expect(partHeaders.length).toBe(1)
+
+      async function getHeaders(h: number, c: number): Promise<BaseBlockHeader[]> {
+        const data = asUint8Array(await client.getHeaders(h, c))
+        const headers = deserializeBaseBlockHeaders(data)
+        return headers
+      }
+    }
+  })
+
+  test('4 findChainTipHeader', async () => {
+    for (const client of clients) {
+      const tipHeader = await client.findChainTipHeader()
+      expect(tipHeader.height >= firstTip.height).toBe(true)
+    }
+  })
+
+  test('5 findChainTipHash', async () => {
+    for (const client of clients) {
+      const hash = await client.findChainTipHash()
+      expect(hash.length === 64).toBe(true)
+    }
+  })
+
+  test('6 findHeaderForHeight', async () => {
+    for (const client of clients) {
+      const header0 = await client.findHeaderForHeight(0)
+      expect(header0 !== undefined).toBe(true)
+      if (header0) {
+        expect(genesisBuffer(chain)).toEqual(serializeBaseBlockHeader(header0))
+      }
+
+      const header = await client.findHeaderForHeight(firstTip.height)
+      expect(header && header.height === firstTip.height).toBe(true)
+
+      const missing = await client.findHeaderForHeight(1000 + firstTip.height)
+      expect(missing === undefined).toBe(true)
+    }
+  })
+
+  test('7 addHeader', async () => {
+    for (const client of clients) {
+      const t = await client.findChainTipHeader()
+      const h: BaseBlockHeader = {
+        version: t.version,
+        previousHash: t.previousHash,
+        merkleRoot: t.merkleRoot,
+        time: t.time,
+        bits: t.bits,
+        nonce: t.nonce
+      }
+      await client.addHeader(h)
+    }
+  })
+
+  /*
+  const headers: BlockHeader[] = []
+  const headerListener: HeaderListener = (header) => { headers.push(header) }
+
+  test("subscribeHeaders", async () => {
+      const id = await client.subscribeHeaders(headerListener)
+      expect(typeof id === 'string').toBe(true)
+      expect(await client.unsubscribe(id)).toBe(true)
+  })
+
+  const reorgs: ({ depth: number, oldTip: BlockHeader, newTip: BlockHeader })[] = []
+  const reorgListener: ReorgListener = (depth, oldTip, newTip) => { reorgs.push({ depth, oldTip, newTip }) }
+
+  test("subscribeReorgs", async () => {
+      const id = await client.subscribeReorgs(reorgListener)
+      expect(typeof id === 'string').toBe(true)
+      expect(await client.unsubscribe(id)).toBe(true)
+  })
+  */
+})
+
+function makeNpmRegistryClient(chain: Chain) {
+  return new ChaintracksServiceClient(chain, `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`)
+}