@bsv/wallet-toolbox 1.6.4 → 1.6.6

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

@@ -6,7 +6,7 @@ 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 { WERR_INVALID_OPERATION, WERR_INVALID_PARAMETER } from '../../../../sdk/WERR_errors'
 import { BlockHeader } from '../../../../sdk/WalletServices.interfaces'
 
 interface ChaintracksNoDbData {
@@ -132,15 +132,15 @@ export class ChaintracksStorageNoDb extends ChaintracksStorageBase {
     return Array.from(data.liveHeaders.values()).find(h => h.merkleRoot === merkleRoot) || null
   }
 
-  override async findLiveHeightRange(): Promise<{ minHeight: number; maxHeight: number }> {
+  override async findLiveHeightRange(): Promise<HeightRange> {
     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 }
+      return HeightRange.empty
     }
     const minHeight = Math.min(...activeHeaders.map(h => h.height))
     const maxHeight = Math.max(...activeHeaders.map(h => h.height))
-    return { minHeight, maxHeight }
+    return new HeightRange(minHeight, maxHeight)
   }
 
   override async findMaxHeaderId(): Promise<number> {
@@ -148,17 +148,6 @@ export class ChaintracksStorageNoDb extends ChaintracksStorageBase {
     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())
@@ -167,168 +156,117 @@ export class ChaintracksStorageNoDb extends ChaintracksStorageBase {
       .slice(0, count)
   }
 
-  override async getHeaders(height: number, count: number): Promise<number[]> {
-    if (count <= 0) return []
-
+  override async getLiveHeaders(range: HeightRange): Promise<LiveBlockHeader[]> {
+    if (range.isEmpty) return []
     const data = await this.getData()
     const headers = Array.from(data.liveHeaders.values())
-      .filter(h => h.isActive && h.height >= height && h.height < height + count)
+      .filter(h => h.isActive && h.height >= range.minHeight && h.height <= range.maxHeight)
       .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
+    return headers
   }
 
-  override async insertHeader(header: BlockHeader, prev?: LiveBlockHeader): Promise<InsertHeaderResult> {
+  override async insertHeader(header: BlockHeader): 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
+    const r: InsertHeaderResult = {
+      added: false,
+      dupe: false,
+      noPrev: false,
+      badPrev: false,
+      noActiveAncestor: false,
+      isActiveTip: false,
+      reorgDepth: 0,
+      priorTip: undefined,
+      noTip: false
+    }
 
     // Check for duplicate
     if (data.hashToHeaderId.has(header.hash)) {
-      dupe = true
-      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+      r.dupe = true
+      return r
     }
 
     // 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 count = data.liveHeaders.size
+      if (count === 0) {
+        // If this is the first live header, the last bulk header (if there is one) is the previous header.
         const lbf = await this.bulkManager.getLastFile()
-        if (lbf && header.previousHash === lbf.lastHash && header.height === lbf.firstHeight + lbf.count) {
+        if (!lbf) throw new WERR_INVALID_OPERATION('bulk headers must exist before first live header can be added')
+        if (header.previousHash === lbf.lastHash && header.height === lbf.firstHeight + lbf.count) {
+          // Valid first live header. Add it.
           const chainWork = addWork(lbf.lastChainWork, convertBitsToWork(header.bits))
+          r.isActiveTip = true
           const newHeader = {
             ...header,
             headerId: ++data.maxHeaderId,
             previousHeaderId: null,
             chainWork,
-            isChainTip: true,
-            isActive: true
+            isChainTip: r.isActiveTip,
+            isActive: r.isActiveTip
           }
           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
+          r.added = true
+          return r
         }
       }
-      noPrev = true
-      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+      // Failure without a oneBack
+      // First live header that does not follow last bulk header or
+      // Not the first live header and live headers doesn't include a previousHash header.
+      r.noPrev = true
+      return r
     }
 
+    // This header's previousHash matches an existing live header's hash, if height isn't +1, reject it.
     if (oneBack.height + 1 !== header.height) {
-      badPrev = true
-      return { added: false, dupe, isActiveTip: false, reorgDepth, priorTip, noPrev, badPrev, noActiveAncestor, noTip }
+      r.badPrev = true
+      return r
     }
 
-    const chainWork = addWork(oneBack.chainWork, convertBitsToWork(header.bits))
-    let tip =
+    r.priorTip =
       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 }
+    if (!r.priorTip) {
+      // No active chain tip found. This is a logic error in state of live headers.
+      r.noTip = true
+      return r
     }
 
-    priorTip = tip
-    setActiveChainTip = isMoreWork(chainWork, tip.chainWork)
+    // We have an acceptable new live header...and live headers has an active chain tip.
+
+    const chainWork = addWork(oneBack.chainWork, convertBitsToWork(header.bits))
+
+    r.isActiveTip = isMoreWork(chainWork, r.priorTip.chainWork)
 
     const newHeader = {
       ...header,
       headerId: ++data.maxHeaderId,
-      previousHeaderId: oneBack === prev ? null : oneBack.headerId,
+      previousHeaderId: oneBack.headerId,
       chainWork,
-      isChainTip: setActiveChainTip,
-      isActive: setActiveChainTip
+      isChainTip: r.isActiveTip,
+      isActive: r.isActiveTip
     }
 
-    if (setActiveChainTip) {
+    if (r.isActiveTip) {
       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
-          }
+          r.noActiveAncestor = true
+          return r
         }
         activeAncestor = previousHeader
       }
 
       if (!(oneBack.isActive && oneBack.isChainTip)) {
-        reorgDepth = Math.min(priorTip.height, header.height) - activeAncestor.height
+        r.reorgDepth = Math.min(r.priorTip.height, header.height) - activeAncestor.height
       }
 
       if (activeAncestor.headerId !== oneBack.headerId) {
@@ -346,27 +284,19 @@ export class ChaintracksStorageNoDb extends ChaintracksStorageBase {
       }
     }
 
-    if (oneBack.isChainTip && oneBack !== prev) {
+    if (oneBack.isChainTip) {
       data.liveHeaders.set(oneBack.headerId, { ...oneBack, isChainTip: false })
     }
 
     data.liveHeaders.set(newHeader.headerId, newHeader)
     data.hashToHeaderId.set(newHeader.hash, newHeader.headerId)
-    if (setActiveChainTip) {
+    r.added = true
+
+    if (r.added && r.isActiveTip) {
       data.tipHeaderId = newHeader.headerId
       this.pruneLiveBlockHeaders(newHeader.height)
     }
 
-    return {
-      added: ok,
-      dupe,
-      isActiveTip: setActiveChainTip,
-      reorgDepth,
-      priorTip,
-      noPrev,
-      badPrev,
-      noActiveAncestor,
-      noTip
-    }
+    return r
   }
 }

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

@@ -0,0 +1,102 @@
+import 'fake-indexeddb/auto'
+import { ChaintracksFs } from '../../util/ChaintracksFs'
+import { Chain } from '../../../../../sdk'
+import { ChaintracksStorageKnex } from '../ChaintracksStorageKnex'
+import { deserializeBaseBlockHeader, genesisHeader } from '../../util/blockHeaderUtilities'
+import { ChaintracksStorageIdb, ChaintracksStorageIdbOptions } from '../ChaintracksStorageIdb'
+import { ChaintracksStorageBase } from '../ChaintracksStorageBase'
+import { LiveBlockHeader } from '../../Api/BlockHeaderApi'
+
+describe('ChaintracksStorageIdb tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const options: ChaintracksStorageIdbOptions = ChaintracksStorageBase.createStorageBaseOptions('main')
+    const storage = new ChaintracksStorageIdb(options)
+    const r = await storage.migrateLatest()
+    const db = storage.db!
+    expect(db).toBeTruthy()
+
+    const tip = await storage.findChainTipHeaderOrUndefined()
+    expect(tip).toBeUndefined()
+
+    const ranges = await storage.getAvailableHeightRanges()
+
+    const lh: LiveBlockHeader = {
+      headerId: 0,
+      chainWork: '00'.repeat(32),
+      isChainTip: false,
+      isActive: true,
+      previousHeaderId: null,
+      height: ranges.bulk.maxHeight + 1,
+      hash: '1111',
+      version: 0,
+      previousHash: '01'.repeat(32),
+      merkleRoot: '11'.repeat(32),
+      time: 0,
+      bits: 0,
+      nonce: 0
+    }
+    await storage.insertLiveHeader(lh)
+    lh.previousHeaderId = lh.headerId
+    lh.hash = '2222'
+    lh.merkleRoot = '22'.repeat(32)
+    lh.height++
+    await storage.insertLiveHeader(lh)
+    lh.previousHeaderId = lh.headerId
+    lh.hash = '3333'
+    lh.merkleRoot = '33'.repeat(32)
+    lh.height++
+    await storage.insertLiveHeader(lh)
+    lh.previousHeaderId = lh.headerId
+    lh.hash = '4444'
+    lh.height++
+    await storage.insertLiveHeader(lh)
+    lh.previousHeaderId = lh.headerId
+    lh.hash = '5555'
+    lh.height++
+    lh.isChainTip = true
+    await storage.insertLiveHeader(lh)
+
+    const h1 = await storage.findLiveHeaderForBlockHash('1111')
+    expect(h1!.headerId).toBe(1)
+
+    const h2 = await storage.findLiveHeaderForMerkleRoot('22'.repeat(32))
+    expect(h2!.headerId).toBe(2)
+
+    const h3 = await storage.findLiveHeaderForHeaderId(3)
+    expect(h3!.headerId).toBe(3)
+
+    const h4 = await storage.findLiveHeaderForHeight(4 + ranges.bulk.maxHeight)
+    expect(h4!.headerId).toBe(4)
+
+    const h5 = await storage.findChainTipHeader()
+    expect(h5.headerId).toBe(5)
+
+    const range = await storage.findLiveHeightRange()
+    expect(range).toEqual({ minHeight: 1 + ranges.bulk.maxHeight, maxHeight: 5 + ranges.bulk.maxHeight })
+
+    const maxId = await storage.findMaxHeaderId()
+    expect(maxId).toBe(5)
+
+    const hfbs = await storage.liveHeadersForBulk(3)
+    expect(hfbs.length).toBe(3)
+
+    const lhs = await storage.getHeaders(0, 10)
+    expect(lhs.length).toBe(10)
+
+    const lhs2 = await storage.getHeaders(0 + ranges.bulk.maxHeight + 1, 10)
+    expect(lhs2.length).toBe(5)
+
+    const lhs3 = await storage.getHeaders(0 + ranges.bulk.maxHeight - 2, 10)
+    expect(lhs3.length).toBe(8)
+
+    const data = await storage.getHeadersUint8Array(0, 10)
+    expect(data.length).toBe(10 * 80)
+
+    const deleteCount = await storage.deleteOlderLiveBlockHeaders(3 + ranges.bulk.maxHeight)
+    expect(deleteCount).toBe(3)
+
+    await storage.deleteLiveBlockHeaders()
+  })
+})

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

@@ -3,6 +3,7 @@ import { Chaintracks } from '../Chaintracks'
 import { wait } from '../../../../utility/utilityHelpers'
 import { Chain } from '../../../../sdk'
 import { createNoDbChaintracksOptions } from '../createDefaultNoDbChaintracksOptions'
+import { ChaintracksFs } from '../util/ChaintracksFs'
 
 const rootFolder = './src/services/chaintracker/chaintracks/__tests/data'
 
@@ -30,7 +31,15 @@ describe('Chaintracks tests', () => {
     await NoDbBody('test')
   })
 
-  async function NoDbBody(chain: Chain) {
+  test.skip('3 NoDb export mainnet', async () => {
+    await NoDbBody('main', true)
+  })
+
+  test.skip('4 NoDb export testnet', async () => {
+    await NoDbBody('test', true)
+  })
+
+  async function NoDbBody(chain: Chain, exportHeaders?: boolean) {
     const o = createNoDbChaintracksOptions(chain)
     const c = new Chaintracks(o)
     await c.makeAvailable()
@@ -39,6 +48,10 @@ describe('Chaintracks tests', () => {
       console.log(`Header received: ${header.height} ${header.hash}`)
     })
 
+    if (exportHeaders) {
+      const rootFolder = './src/services/chaintracker/chaintracks/__tests/data/export'
+      await c.exportBulkHeaders(rootFolder, ChaintracksFs, `https://cdn.projectbabbage.com/blockheaders`, 100000)
+    }
     //let done = false
     //for (; !done; ) {
     await wait(1000)

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

@@ -21,7 +21,7 @@ clientClass = 'Chaintracks'
 //clientClass = "ChaintracksServiceClient"
 const includeLocalServiceClient = true
 const includeLocalServiceChaintracks = true
-const includeNpmRegistryClient = true
+const includeNpmRegistryClient = false
 const includeGcrTestClient = true
 
 describe(`ChaintracksClientApi tests`, () => {

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

@@ -0,0 +1,61 @@
+import { _tu } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { wait } from '../../../../utility/utilityHelpers'
+import { createdIdbChaintracks } from '../createIdbChaintracks'
+import { BulkFileDataManager } from '../util/BulkFileDataManager'
+import { BulkHeaderFileInfo } from '../util/BulkHeaderFile'
+import { HeaderListener } from '../Api/ChaintracksClientApi'
+import { Chain } from '../../../../sdk/types'
+import { BlockHeader } from '../Api/BlockHeaderApi'
+
+import 'fake-indexeddb/auto'
+
+describe('createIdbChaintracks tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0', async () => {
+    const target: Chain = 'main'
+    if (_tu.noEnv(target)) return
+    const env = _tu.getEnv(target)
+    const { chain, chaintracks, storage } = await createdIdbChaintracks(env.chain, env.whatsonchainApiKey)
+    const headerListener: HeaderListener = (header: BlockHeader) => {
+      console.log(`headerListener: height: ${header.height} hash: ${header.hash} ${new Date().toISOString()}`)
+    }
+    chaintracks.subscribeHeaders(headerListener)
+    expect(countDatas(storage.bulkManager)).toBeLessThanOrEqual(3)
+
+    const tipHash = await chaintracks.findChainTipHash()
+    const tip = await chaintracks.findChainTipHeader()
+    chaintracks.log(`tip: height: ${tip.height} hash: ${tip.hash}`)
+    expect(tip.hash).toBe(tipHash)
+
+    const forHash = await chaintracks.findHeaderForBlockHash(tip.hash)
+    expect(forHash?.hash).toBe(tip.hash)
+
+    const forHashLive = await chaintracks.findLiveHeaderForBlockHash(tip.hash)
+    expect(forHashLive?.hash).toBe(tip.hash)
+
+    const chainwork = await chaintracks.findChainWorkForBlockHash(tip.hash)
+    expect(forHashLive?.chainWork).toBe(chainwork)
+
+    const forHeight = await chaintracks.findHeaderForHeight(tip.height)
+    expect(forHeight?.hash).toBe(tip.hash)
+
+    const listening = await chaintracks.isListening()
+    expect(listening).toBe(true)
+
+    //    console.log('validating...')
+    //    const validated = await chaintracks.validate()
+    //    expect(validated).toBe(true)
+    //    console.log('validated')
+
+    for (;;) await wait(120000)
+  })
+})
+
+function countDatas(manager: BulkFileDataManager): number {
+  let count = 0
+  for (const file of manager['bfds'] as BulkHeaderFileInfo[]) {
+    if (file.data) count += 1
+  }
+  return count
+}

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

@@ -0,0 +1,111 @@
+import { Chain } from '../../../sdk'
+import { ChaintracksOptions } from './Api/ChaintracksApi'
+import { Chaintracks } from './Chaintracks'
+import { BulkIngestorCDNBabbage } from './Ingest/BulkIngestorCDNBabbage'
+import { ChaintracksFetch } from './util/ChaintracksFetch'
+import { LiveIngestorWhatsOnChainOptions, LiveIngestorWhatsOnChainPoll } from './Ingest/LiveIngestorWhatsOnChainPoll'
+import { BulkIngestorWhatsOnChainCdn, BulkIngestorWhatsOnChainOptions } from './Ingest/BulkIngestorWhatsOnChainCdn'
+import { ChaintracksFetchApi } from './Api/ChaintracksFetchApi'
+import { ChaintracksStorageIdb, ChaintracksStorageIdbOptions } from './Storage/ChaintracksStorageIdb'
+import { BulkFileDataManager, BulkFileDataManagerOptions } from './util/BulkFileDataManager'
+import { BulkIngestorCDNOptions, WhatsOnChainServicesOptions } from './index.client'
+
+export async function createdIdbChaintracks(
+  chain: Chain,
+  whatsonchainApiKey: string,
+  maxPerFile: number = 100000,
+  maxRetained: number = 2,
+  fetch?: ChaintracksFetchApi,
+  cdnUrl: string = 'https://cdn.projectbabbage.com/blockheaders/',
+  liveHeightThreshold: number = 2000,
+  reorgHeightThreshold: number = 400,
+  bulkMigrationChunkSize: number = 500,
+  batchInsertLimit: number = 400,
+  addLiveRecursionLimit: number = 36
+): Promise<{
+  chain: Chain
+  maxPerFile: number
+  fetch: ChaintracksFetchApi
+  storage: ChaintracksStorageIdb
+  chaintracks: Chaintracks
+}> {
+  try {
+    fetch ||= new ChaintracksFetch()
+
+    const bfo: BulkFileDataManagerOptions = {
+      chain,
+      fetch,
+      maxPerFile,
+      maxRetained,
+      fromKnownSourceUrl: cdnUrl
+    }
+    const bulkFileDataManager = new BulkFileDataManager(bfo)
+
+    const so: ChaintracksStorageIdbOptions = {
+      chain,
+      bulkFileDataManager,
+      liveHeightThreshold,
+      reorgHeightThreshold,
+      bulkMigrationChunkSize,
+      batchInsertLimit
+    }
+    const storage = new ChaintracksStorageIdb(so)
+
+    const co: ChaintracksOptions = {
+      chain,
+      storage,
+      bulkIngestors: [],
+      liveIngestors: [],
+      addLiveRecursionLimit,
+      logging: (...args) => console.log(new Date().toISOString(), ...args),
+      readonly: false
+    }
+
+    const jsonResource = `${chain}NetBlockHeaders.json`
+
+    const bulkCdnOptions: BulkIngestorCDNOptions = {
+      chain,
+      jsonResource,
+      fetch,
+      cdnUrl,
+      maxPerFile
+    }
+    co.bulkIngestors.push(new BulkIngestorCDNBabbage(bulkCdnOptions))
+
+    const wocOptions: WhatsOnChainServicesOptions = {
+      chain,
+      apiKey: whatsonchainApiKey,
+      timeout: 30000,
+      userAgent: 'BabbageWhatsOnChainServices',
+      enableCache: true,
+      chainInfoMsecs: 5000
+    }
+
+    const bulkOptions: BulkIngestorWhatsOnChainOptions = {
+      ...wocOptions,
+      jsonResource,
+      idleWait: 5000
+    }
+    co.bulkIngestors.push(new BulkIngestorWhatsOnChainCdn(bulkOptions))
+
+    const liveOptions: LiveIngestorWhatsOnChainOptions = {
+      ...wocOptions,
+      idleWait: 100000
+    }
+    co.liveIngestors.push(new LiveIngestorWhatsOnChainPoll(liveOptions))
+
+    const chaintracks = new Chaintracks(co)
+    await chaintracks.makeAvailable()
+
+    return {
+      chain,
+      fetch,
+      maxPerFile,
+      storage,
+      chaintracks
+    }
+  } catch (error) {
+    console.error('Error setting up Chaintracks with Idb Storage:', error)
+    throw error
+  }
+}

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

@@ -24,8 +24,10 @@ export * from './Ingest/WhatsOnChainServices'
 export * from './Storage/BulkStorageBase'
 export * from './Storage/ChaintracksStorageBase'
 export * from './Storage/ChaintracksStorageNoDb'
+export * from './Storage/ChaintracksStorageIdb'
 
 export * from './createDefaultNoDbChaintracksOptions'
+export * from './createIdbChaintracks'
 
 export * from './util/BulkFilesReader'
 export * from './util/HeightRange'