@fireproof/core 0.3.1 → 0.3.3

package/src/fireproof.js

@@ -1,24 +1,28 @@
+// @ts-nocheck
 import { randomBytes } from 'crypto'
 import { visMerkleClock, visMerkleTree, vis, put, get, getAll, eventsSince } from './prolly.js'
-import TransactionBlockstore, { doTransaction } from './blockstore.js'
+import { TransactionBlockstore, doTransaction } from './blockstore.js'
 import charwise from 'charwise'
+// import { CID } from 'multiformats/dist/types/src/cid.js'
 
 // const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
 
+// class Proof {}
+
 /**
  * @class Fireproof
  * @classdesc Fireproof stores data in IndexedDB and provides a Merkle clock.
  *  This is the main class for saving and loading JSON and other documents with the database. You can find additional examples and
  *  usage guides in the repository README.
  *
- * @param {Blockstore} blocks - The block storage instance to use documents and indexes
+ * @param {import('./blockstore.js').TransactionBlockstore} blocks - The block storage instance to use documents and indexes
  * @param {CID[]} clock - The Merkle clock head to use for the Fireproof instance.
  * @param {object} [config] - Optional configuration options for the Fireproof instance.
  * @param {object} [authCtx] - Optional authorization context object to use for any authentication checks.
  *
  */
-export default class Fireproof {
-  #listeners = new Set()
+export class Fireproof {
+  listeners = new Set()
 
   /**
    * @function storage
@@ -82,12 +86,12 @@ export default class Fireproof {
    * @instance
    */
   async notifyReset () {
-    await this.#notifyListeners({ _reset: true, _clock: this.clockToJSON() })
+    await this.notifyListeners({ _reset: true, _clock: this.clockToJSON() })
   }
 
   // used be indexes etc to notify database listeners of new availability
   async notifyExternal (source = 'unknown') {
-    await this.#notifyListeners({ _external: source, _clock: this.clockToJSON() })
+    await this.notifyListeners({ _external: source, _clock: this.clockToJSON() })
   }
 
   /**
@@ -147,7 +151,7 @@ export default class Fireproof {
    * @memberof Fireproof
    * @instance
    */
-  async #runValidation (doc) {
+  async runValidation (doc) {
     if (this.config && this.config.validateChange) {
       const oldDoc = await this.get(doc._id)
         .then((doc) => doc)
@@ -161,7 +165,7 @@ export default class Fireproof {
    *
    * @param {string} key - the ID of the document to retrieve
    * @param {Object} [opts] - options
-   * @returns {Object<{_id: string, ...doc: Object}>} - the document with the specified ID
+   * @returns {Promise<{_id: string}>} - the document with the specified ID
    * @memberof Fireproof
    * @instance
    */
@@ -190,21 +194,22 @@ export default class Fireproof {
    *
    * @param {Object} doc - the document to be added
    * @param {string} doc._id - the document ID. If not provided, a random ID will be generated.
-   * @param {Object} doc.* - the document data to be added
-   * @returns {Object<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
+   * @param {CID[]} doc._clock - the document ID. If not provided, a random ID will be generated.
+   * @param {Proof} doc._proof - CIDs referenced by the update
+   * @returns {Promise<{ id: string, clock: CID[]  }>} - The result of adding the document to the database
    * @memberof Fireproof
    * @instance
    */
   async put ({ _id, _proof, ...doc }) {
     const id = _id || 'f' + Math.random().toString(36).slice(2)
-    await this.#runValidation({ _id: id, ...doc })
-    return await this.#putToProllyTree({ key: id, value: doc }, doc._clock)
+    await this.runValidation({ _id: id, ...doc })
+    return await this.putToProllyTree({ key: id, value: doc }, doc._clock)
   }
 
   /**
    * Deletes a document from the database
-   * @param {string} id - the document ID
-   * @returns {Object<{ id: string, clock: CID[] }>} - The result of deleting the document from the database
+   * @param {string | any} docOrId - the document ID
+   * @returns {Promise<{ id: string, clock: CID[] }>} - The result of deleting the document from the database
    * @memberof Fireproof
    * @instance
    */
@@ -217,19 +222,19 @@ export default class Fireproof {
     } else {
       id = docOrId
     }
-    await this.#runValidation({ _id: id, _deleted: true })
-    return await this.#putToProllyTree({ key: id, del: true }, clock) // not working at prolly tree layer?
+    await this.runValidation({ _id: id, _deleted: true })
+    return await this.putToProllyTree({ key: id, del: true }, clock) // not working at prolly tree layer?
     // this tombstone is temporary until we can get the prolly tree to delete
-    // return await this.#putToProllyTree({ key: id, value: null }, clock)
+    // return await this.putToProllyTree({ key: id, value: null }, clock)
   }
 
   /**
    * Updates the underlying storage with the specified event.
    * @private
-   * @param {Object<{key : string, value: any}>} event - the event to add
-   * @returns {Object<{ id: string, clock: CID[] }>} - The result of adding the event to storage
+   * @param {{del?: true, key : string, value?: any}} decodedEvent - the event to add
+   * @returns {Promise<{ proof:{}, id: string, clock: CID[] }>} - The result of adding the event to storage
    */
-  async #putToProllyTree (decodedEvent, clock = null) {
+  async putToProllyTree (decodedEvent, clock = null) {
     const event = encodeEvent(decodedEvent)
     if (clock && JSON.stringify(clock) !== JSON.stringify(this.clockToJSON())) {
       // we need to check and see what version of the document exists at the clock specified
@@ -241,7 +246,7 @@ export default class Fireproof {
       }
     }
     const result = await doTransaction(
-      '#putToProllyTree',
+      'putToProllyTree',
       this.blocks,
       async (blocks) => await put(blocks, this.clock, event)
     )
@@ -251,7 +256,7 @@ export default class Fireproof {
     }
     // console.log('new clock head', this.instanceId, result.head.toString())
     this.clock = result.head // do we want to do this as a finally block
-    await this.#notifyListeners([decodedEvent]) // this type is odd
+    await this.notifyListeners([decodedEvent]) // this type is odd
     return {
       id: decodedEvent.key,
       clock: this.clockToJSON(),
@@ -290,15 +295,15 @@ export default class Fireproof {
    * @memberof Fireproof
    */
   registerListener (listener) {
-    this.#listeners.add(listener)
+    this.listeners.add(listener)
     return () => {
-      this.#listeners.delete(listener)
+      this.listeners.delete(listener)
     }
   }
 
-  async #notifyListeners (changes) {
+  async notifyListeners (changes) {
     // await sleep(10)
-    for (const listener of this.#listeners) {
+    for (const listener of this.listeners) {
       await listener(changes)
     }
   }

package/src/hydrator.js

@@ -1,10 +1,10 @@
-import DbIndex from './db-index.js'
-import Fireproof from './fireproof.js'
+import { DbIndex } from './db-index.js'
+import { Fireproof } from './fireproof.js'
 import { CID } from 'multiformats'
 
 const parseCID = cid => typeof cid === 'string' ? CID.parse(cid) : cid
 
-export default class Hydrator {
+export class Hydrator {
   static fromJSON (json, database) {
     database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key })
     if (json.indexes) {

package/src/index.js

@@ -0,0 +1,6 @@
+import { Fireproof } from './fireproof'
+import { DbIndex as Index } from './db-index'
+import { Listener } from './listener'
+import { Hydrator } from './hydrator'
+
+export { Fireproof, Index, Listener, Hydrator }

package/src/listener.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /**
  * A Fireproof database Listener allows you to react to events in the database.
  *
@@ -9,9 +10,9 @@
  */
 // import { ChangeEvent } from './db-index'
 
-export default class Listener {
-  #subcribers = new Map()
-  #doStopListening = null
+export class Listener {
+  subcribers = new Map()
+  doStopListening = null
 
   constructor (database, routingFn) {
     /** routingFn
@@ -19,7 +20,7 @@ export default class Listener {
      * @type {Fireproof}
      */
     this.database = database
-    this.#doStopListening = database.registerListener(changes => this.#onChanges(changes))
+    this.doStopListening = database.registerListener(changes => this.onChanges(changes))
     /**
      * The map function to apply to each entry in the database.
      * @type {Function}
@@ -41,7 +42,7 @@ export default class Listener {
    * @instance
    */
   on (topic, subscriber, since) {
-    const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
+    const listOfTopicSubscribers = getTopicList(this.subcribers, topic)
     listOfTopicSubscribers.push(subscriber)
     if (typeof since !== 'undefined') {
       this.database.changesSince(since).then(({ rows: changes }) => {
@@ -55,16 +56,16 @@ export default class Listener {
     }
   }
 
-  #onChanges (changes) {
+  onChanges (changes) {
     if (Array.isArray(changes)) {
       const seenTopics = topicsForChanges(changes, this.routingFn)
       for (const [topic, keys] of seenTopics) {
-        const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
+        const listOfTopicSubscribers = getTopicList(this.subcribers, topic)
         listOfTopicSubscribers.forEach(subscriber => keys.forEach(key => subscriber(key)))
       }
     } else {
       // non-arrays go to all subscribers
-      for (const [, listOfTopicSubscribers] of this.#subcribers) {
+      for (const [, listOfTopicSubscribers] of this.subcribers) {
         listOfTopicSubscribers.forEach(subscriber => subscriber(changes))
       }
     }

package/src/prolly.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import {
   advance,
   EventFetcher,
@@ -37,23 +38,9 @@ export const makeGetBlock = (blocks) => {
 }
 
 /**
- * Creates and saves a new event.
- * @param {import('./blockstore.js').Blockstore} inBlocks - A persistent blockstore.
- * @param {MemoryBlockstore} mblocks - A temporary blockstore.
- * @param {Function} getBlock - A function that gets a block.
- * @param {Function} bigPut - A function that puts a block.
- * @param {import('prolly-trees/map').Root} root - The root node.
- * @param {Object<{ key: string, value: any, del: boolean }>} event - The update event.
- * @param {CID[]} head - The head of the event chain.
- * @param {Array<import('multiformats/block').Block>} additions - A array of additions.
- * @param {Array<mport('multiformats/block').Block>>} removals - An array of removals.
- * @returns {Promise<{
- *   root: import('prolly-trees/map').Root,
- *   additions: Map<string, import('multiformats/block').Block>,
- *   removals: Array<string>,
- *   head: CID[],
- *   event: CID[]
- * }>}
+ *
+ * @param {*} param0
+ * @returns
  */
 async function createAndSaveNewEvent ({
   inBlocks,
@@ -198,7 +185,7 @@ const doProllyBulk = async (inBlocks, head, event) => {
 /**
  * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
  *
- * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./blockstore.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  * @param {string} key The key of the value to put.
  * @param {CID} value The value to put.
@@ -250,7 +237,7 @@ export async function put (inBlocks, head, event, options) {
 /**
  * Determine the effective prolly root given the current merkle clock head.
  *
- * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./blockstore.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  */
 export async function root (inBlocks, head) {
@@ -270,10 +257,10 @@ export async function root (inBlocks, head) {
 
 /**
  * Get the list of events not known by the `since` event
- * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./blockstore.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  * @param {import('./clock').EventLink<EventData>} since Event to compare against.
- * @returns {Promise<import('./clock').EventLink<EventData>[]>}
+ * @returns {Promise<{clockCIDs: CIDCounter, result: EventData[]}>}
  */
 export async function eventsSince (blocks, head, since) {
   if (!head.length) {
@@ -286,10 +273,10 @@ export async function eventsSince (blocks, head, since) {
 
 /**
  *
- * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./blockstore.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  *
- * @returns {Promise<import('./prolly').Entry[]>}
+ * @returns {Promise<{clockCIDs: CIDCounter, result: EventData[]}>}
  *
  */
 export async function getAll (blocks, head) {
@@ -307,7 +294,7 @@ export async function getAll (blocks, head) {
 }
 
 /**
- * @param {import('../test/block.js').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./blockstore.js').BlockFetcher} blocks Bucket block storage.
  * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
  * @param {string} key The key of the value to retrieve.
  */

package/src/sha1.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 // from https://github.com/duzun/sync-sha1/blob/master/rawSha1.js
 // MIT License Copyright (c) 2020 Dumitru Uzun
 // Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -29,7 +30,7 @@
 *
 * @return  {Uint8Array}  sha1 hash
 */
-export default function rawSha1 (b) {
+export function rawSha1 (b) {
   let i = b.byteLength
   let bs = 0
   let A; let B; let C; let D; let G

package/src/valet.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import { CarReader } from '@ipld/car'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
@@ -12,18 +13,18 @@ import { nocache as cache } from 'prolly-trees/cache'
 import { encrypt, decrypt } from './crypto.js'
 import { Buffer } from 'buffer'
 import * as codec from 'encrypted-block'
-import sha1sync from './sha1.js'
+import { rawSha1 as sha1sync } from './sha1.js'
 const chunker = bf(3)
 
 const NO_ENCRYPT =
   typeof process !== 'undefined' ? process.env.NO_ENCRYPT : import.meta && import.meta.env.VITE_NO_ENCRYPT
 
-export default class Valet {
+export class Valet {
   idb = null
   name = null
-  #uploadQueue = null
-  #alreadyEnqueued = new Set()
-  #keyMaterial = null
+  uploadQueue = null
+  alreadyEnqueued = new Set()
+  keyMaterial = null
   keyId = 'null'
 
   /**
@@ -35,7 +36,7 @@ export default class Valet {
   constructor (name = 'default', keyMaterial) {
     this.name = name
     this.setKeyMaterial(keyMaterial)
-    this.#uploadQueue = cargoQueue(async (tasks, callback) => {
+    this.uploadQueue = cargoQueue(async (tasks, callback) => {
       console.log(
         'queue worker',
         tasks.length,
@@ -56,7 +57,7 @@ export default class Valet {
       callback()
     })
 
-    this.#uploadQueue.drain(async () => {
+    this.uploadQueue.drain(async () => {
       return await this.withDB(async db => {
         const carKeys = (await db.getAllFromIndex('cidToCar', 'pending')).map(c => c.car)
         for (const carKey of carKeys) {
@@ -70,17 +71,17 @@ export default class Valet {
   }
 
   getKeyMaterial () {
-    return this.#keyMaterial
+    return this.keyMaterial
   }
 
   setKeyMaterial (km) {
     if (km && !NO_ENCRYPT) {
       const hex = Uint8Array.from(Buffer.from(km, 'hex'))
-      this.#keyMaterial = km
+      this.keyMaterial = km
       const hash = sha1sync(hex)
       this.keyId = Buffer.from(hash).toString('hex')
     } else {
-      this.#keyMaterial = null
+      this.keyMaterial = null
       this.keyId = 'null'
     }
     // console.trace('keyId', this.name, this.keyId)
@@ -95,9 +96,9 @@ export default class Valet {
    */
   async writeTransaction (innerBlockstore, cids) {
     if (innerBlockstore.lastCid) {
-      if (this.#keyMaterial) {
+      if (this.keyMaterial) {
         // console.log('encrypting car', innerBlockstore.label)
-        const newCar = await blocksToEncryptedCarBlock(innerBlockstore.lastCid, innerBlockstore, this.#keyMaterial)
+        const newCar = await blocksToEncryptedCarBlock(innerBlockstore.lastCid, innerBlockstore, this.keyMaterial)
         await this.parkCar(newCar.cid.toString(), newCar.bytes, cids)
       } else {
         const newCar = await blocksToCarBlock(innerBlockstore.lastCid, innerBlockstore)
@@ -140,14 +141,14 @@ export default class Valet {
 
     // upload to web3.storage if we have credentials
     if (this.uploadFunction) {
-      if (this.#alreadyEnqueued.has(carCid)) {
+      if (this.alreadyEnqueued.has(carCid)) {
         // console.log('already enqueued', carCid)
         return
       }
       // don't await this, it will be done in the queue
       // console.log('add to queue', carCid, value.length)
-      this.#uploadQueue.push({ carCid, value })
-      this.#alreadyEnqueued.add(carCid)
+      this.uploadQueue.push({ carCid, value })
+      this.alreadyEnqueued.add(carCid)
     } else {
       // console.log('no upload function', carCid, value.length, this.uploadFunction)
     }
@@ -165,7 +166,7 @@ export default class Valet {
       }
       const carBytes = await tx.objectStore('cars').get(carCid)
       const reader = await CarReader.fromBytes(carBytes)
-      if (this.#keyMaterial) {
+      if (this.keyMaterial) {
         const roots = await reader.getRoots()
         const readerGetWithCodec = async cid => {
           const got = await reader.get(cid)
@@ -182,7 +183,7 @@ export default class Valet {
           // console.log('decoded', decoded.value)
           return decoded
         }
-        const { blocks } = await blocksFromEncryptedCarBlock(roots[0], readerGetWithCodec, this.#keyMaterial)
+        const { blocks } = await blocksFromEncryptedCarBlock(roots[0], readerGetWithCodec, this.keyMaterial)
         const block = blocks.find(b => b.cid.toString() === dataCID)
         if (block) {
           return block.bytes
@@ -234,7 +235,8 @@ const blocksToEncryptedCarBlock = async (innerBlockStoreClockRootCid, blocks, ke
     key: encryptionKey,
     hasher: sha256,
     chunker,
-    codec: dagcbor, // should be crypto?
+    cache,
+    // codec: dagcbor, // should be crypto?
     root: innerBlockStoreClockRootCid
   })) {
     encryptedBlocks.push(block)
@@ -262,8 +264,8 @@ const blocksFromEncryptedCarBlock = async (cid, get, keyMaterial) => {
         key: decryptionKey,
         chunker,
         hasher: sha256,
-        cache,
-        codec: dagcbor
+        cache
+        // codec: dagcbor
       })) {
         decryptedBlocks.push(block)
         cids.add(block.cid.toString())

package/hooks/use-fireproof.js

@@ -1,135 +0,0 @@
-/* global localStorage */
-// @ts-ignore
-import { useEffect, useState, createContext } from 'react'
-import { Fireproof, Listener, Hydrator } from '../index'
-
-// export interface FireproofCtxValue {
-//   addSubscriber: (label: String, fn: Function) => void
-//   database: Fireproof
-//   ready: boolean
-//   persist: () => void
-// }
-export const FireproofCtx = createContext({
-  addSubscriber: () => {},
-  database: null,
-  ready: false
-})
-
-const inboundSubscriberQueue = new Map()
-
-let startedSetup = false
-let database
-let listener
-const initializeDatabase = name => {
-  if (database) return
-  database = Fireproof.storage(name)
-  listener = new Listener(database)
-}
-
-/**
- * @function useFireproof
- * React hook to initialize a Fireproof database, automatically saving and loading the clock.
- * You might need to `import { nodePolyfills } from 'vite-plugin-node-polyfills'` in your vite.config.ts
- * @param [defineDatabaseFn] Synchronous function that defines the database, run this before any async calls
- * @param [setupDatabaseFn] Asynchronous function that sets up the database, run this to load fixture data etc
- * @returns {FireproofCtxValue} { addSubscriber, database, ready }
- */
-export function useFireproof (
-  defineDatabaseFn = () => {},
-  setupDatabaseFn = async () => {},
-  name
-) {
-  const [ready, setReady] = useState(false)
-  initializeDatabase(name || 'useFireproof')
-  const localStorageKey = 'fp.' + database.name
-
-  const addSubscriber = (label, fn) => {
-    inboundSubscriberQueue.set(label, fn)
-  }
-
-  const listenerCallback = async event => {
-    localSet(localStorageKey, JSON.stringify(database))
-    if (event._external) return
-    for (const [, fn] of inboundSubscriberQueue) fn()
-  }
-
-  useEffect(() => {
-    const doSetup = async () => {
-      if (ready) return
-      if (startedSetup) return
-      startedSetup = true
-      defineDatabaseFn(database) // define indexes before querying them
-      console.log('Initializing database', database.name)
-      const fp = localGet(localStorageKey) // todo use db.name
-      if (fp) {
-        try {
-          const serialized = JSON.parse(fp)
-          // console.log('serialized', JSON.stringify(serialized.indexes.map(c => c.clock)))
-          console.log(`Loading previous database clock. (localStorage.removeItem('${localStorageKey}') to reset)`)
-          await Hydrator.fromJSON(serialized, database)
-          const changes = await database.changesSince()
-          if (changes.rows.length < 2) {
-            // console.log('Resetting database')
-            throw new Error('Resetting database')
-          }
-        } catch (e) {
-          console.error(`Error loading previous database clock. ${fp} Resetting.`, e)
-          await Hydrator.zoom(database, [])
-          await setupDatabaseFn(database)
-          localSet(localStorageKey, JSON.stringify(database))
-        }
-      } else {
-        await setupDatabaseFn(database)
-        localSet(localStorageKey, JSON.stringify(database))
-      }
-      setReady(true)
-      listener.on('*', listenerCallback)// hushed('*', listenerCallback, 250))
-    }
-    doSetup()
-  }, [ready])
-
-  return {
-    addSubscriber,
-    database,
-    ready,
-    persist: () => {
-      localSet(localStorageKey, JSON.stringify(database))
-    }
-  }
-}
-
-// const husherMap = new Map()
-// const husher = (id, workFn, ms) => {
-//   if (!husherMap.has(id)) {
-//     const start = Date.now()
-//     husherMap.set(
-//       id,
-//       workFn().finally(() => setTimeout(() => husherMap.delete(id), ms - (Date.now() - start)))
-//     )
-//   }
-//   return husherMap.get(id)
-// }
-// const hushed =
-//   (id, workFn, ms) =>
-//     (...args) =>
-//       husher(id, () => workFn(...args), ms)
-
-let storageSupported = false
-try {
-  storageSupported = window.localStorage && true
-} catch (e) {}
-export function localGet (key) {
-  if (storageSupported) {
-    return localStorage && localStorage.getItem(key)
-  }
-}
-function localSet (key, value) {
-  if (storageSupported) {
-    return localStorage && localStorage.setItem(key, value)
-  }
-}
-// function localRemove(key) {
-//   if (storageSupported) {
-//     return localStorage && localStorage.removeItem(key)
-//   }
-// }

package/index.js

@@ -1,6 +0,0 @@
-import Fireproof from './src/fireproof'
-import Index from './src/db-index'
-import Listener from './src/listener'
-import Hydrator from './src/hydrator'
-
-export { Fireproof, Index, Listener, Hydrator }

package/scripts/keygen.js

@@ -1,3 +0,0 @@
-import { randomBytes } from 'crypto'
-
-console.log(randomBytes(32).toString('hex'))

package/test/block.js

@@ -1,65 +0,0 @@
-import { parse } from 'multiformats/link'
-
-/**
- * @typedef {{ cid: import('../src/link').AnyLink, bytes: Uint8Array }} AnyBlock
- * @typedef {{ get: (link: import('../src/link').AnyLink) => Promise<AnyBlock | undefined> }} BlockFetcher
- */
-
-/** @implements {BlockFetcher} */
-export class MemoryBlockstore {
-  /** @type {Map<string, Uint8Array>} */
-  #blocks = new Map()
-
-  /**
-   * @param {import('../src/link').AnyLink} cid
-   * @returns {Promise<AnyBlock | undefined>}
-   */
-  async get (cid) {
-    const bytes = this.#blocks.get(cid.toString())
-    if (!bytes) return
-    return { cid, bytes }
-  }
-
-  /**
-   * @param {import('../src/link').AnyLink} cid
-   * @param {Uint8Array} bytes
-   */
-  async put (cid, bytes) {
-    // console.log('put', cid)
-    this.#blocks.set(cid.toString(), bytes)
-  }
-
-  /**
-   * @param {import('../src/link').AnyLink} cid
-   * @param {Uint8Array} bytes
-   */
-  putSync (cid, bytes) {
-    this.#blocks.set(cid.toString(), bytes)
-  }
-
-  * entries () {
-    for (const [str, bytes] of this.#blocks) {
-      yield { cid: parse(str), bytes }
-    }
-  }
-}
-
-export class MultiBlockFetcher {
-  /** @type {BlockFetcher[]} */
-  #fetchers
-
-  /** @param {BlockFetcher[]} fetchers */
-  constructor (...fetchers) {
-    this.#fetchers = fetchers
-  }
-
-  /** @param {import('../src/link').AnyLink} link */
-  async get (link) {
-    for (const f of this.#fetchers) {
-      const v = await f.get(link)
-      if (v) {
-        return v
-      }
-    }
-  }
-}