@fireproof/core 0.0.1

package/src/fireproof.js

@@ -0,0 +1,209 @@
+// import { vis } from './clock.js'
+import { put, get, getAll, eventsSince } from './prolly.js'
+import Blockstore, { doTransaction } from './blockstore.js'
+
+// const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+
+/**
+ * Represents a Fireproof instance that wraps a ProllyDB instance and Merkle clock head.
+ *
+ * @class
+ * @classdesc A Fireproof instance can be used to store and retrieve values from a ProllyDB instance.
+ *
+ * @param {Blockstore} blocks - The block storage instance to use for the underlying ProllyDB instance.
+ * @param {import('../clock').EventLink<import('../crdt').EventData>[]} 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 {
+  /**
+   * @param {Blockstore} blocks
+   * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock
+   */
+  #listeners = new Set()
+
+  constructor (blocks, clock, config = {}, authCtx = {}) {
+    this.blocks = blocks
+    this.clock = clock
+    this.config = config
+    this.authCtx = authCtx
+    this.instanceId = 'db.' + Math.random().toString(36).substring(2, 7)
+  }
+
+  /**
+   * Returns a snapshot of the current Fireproof instance.
+   *
+   * @param {import('../clock').EventLink<import('../crdt').EventData>[]} clock
+   *    Clock to use for the snapshot.
+   * @returns {Fireproof}
+   *    A new Fireproof instance representing the snapshot.
+   */
+  snapshot (clock) {
+    // how to handle listeners, views, and config?
+    // todo needs a test for that
+    return new Fireproof(this.blocks, clock || this.clock)
+  }
+
+  /**
+   * This triggers a notification to all listeners of the Fireproof instance.
+   */
+  async setClock (clock) {
+    // console.log('setClock', this.instanceId, clock)
+    this.clock = clock.map((item) => item['/'] ? item['/'] : item)
+    await this.#notifyListeners({ reset: true, clock })
+  }
+
+  toJSON () {
+    // todo this also needs to return the index roots...
+    return { clock: this.clock }
+  }
+
+  /**
+   * Returns the changes made to the Fireproof instance since the specified event.
+   *
+   * @param {import('../clock').EventLink<import('../crdt').EventData>?} event -
+   * The event to retrieve changes since. If null or undefined, retrieves all changes.
+   * @returns {Promise<{
+   *   rows: { key: string, value?: any, del?: boolean }[],
+   *   head: import('../clock').EventLink<import('../crdt').EventData>[]
+   * }>} - An object `{rows : [...{key, value, del}], head}` containing the rows and the head of the instance's clock.
+   */
+  async changesSince (event) {
+    // console.log('changesSince', this.instanceId, event, this.clock)
+    let rows
+    if (event) {
+      const resp = await eventsSince(this.blocks, this.clock, event)
+      const docsMap = new Map()
+      for (const { key, type, value } of resp) {
+        if (type === 'del') {
+          docsMap.set(key, { key, del: true })
+        } else {
+          docsMap.set(key, { key, value })
+        }
+      }
+      rows = Array.from(docsMap.values())
+      // console.log('change rows', this.instanceId, rows)
+    } else {
+      rows = (await getAll(this.blocks, this.clock)).map(({ key, value }) => ({ key, value }))
+      // console.log('dbdoc rows', this.instanceId, rows)
+    }
+    return { rows, clock: this.clock }
+  }
+
+  /**
+   * Registers a Listener to be called when the Fireproof instance's clock is updated.
+   * Recieves live changes from the database after they are committed.
+   * @param {Function} listener - The listener to be called when the clock is updated.
+   * @returns {Function} - A function that can be called to unregister the listener.
+   */
+  registerListener (listener) {
+    this.#listeners.add(listener)
+    return () => {
+      this.#listeners.delete(listener)
+    }
+  }
+
+  async #notifyListeners (changes) {
+    // await sleep(0)
+    this.#listeners.forEach((listener) => listener(changes))
+  }
+
+  /**
+   * Runs validation on the specified document using the Fireproof instance's configuration.
+   *
+   * @param {Object} doc - The document to validate.
+   */
+  async runValidation (doc) {
+    if (this.config && this.config.validateChange) {
+      const oldDoc = await this.get(doc._id)
+        .then((doc) => doc)
+        .catch(() => ({}))
+      this.config.validateChange(doc, oldDoc, this.authCtx)
+    }
+  }
+
+  /**
+   * Adds a new document to the database, or updates an existing document.
+   *
+   * @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 {Promise<import('./prolly').PutResult>} - the result of adding the document
+   */
+  async put ({ _id, ...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 })
+  }
+
+  /**
+   * Deletes a document from the database
+   * @param {string} id - the document ID
+   * @returns {Promise<import('./prolly').PutResult>} - the result of deleting the document
+   */
+  async del (id) {
+    await this.runValidation({ _id: id, _deleted: true })
+    // return await this.putToProllyTree({ key: id, del: true }) // 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 })
+  }
+
+  async putToProllyTree (event) {
+    const result = await doTransaction('putToProllyTree', this.blocks, async (blocks) => await put(blocks, this.clock, event))
+    if (!result) {
+      console.log('failed', event)
+    }
+    this.clock = result.head // do we want to do this as a finally block
+    result.id = event.key
+    await this.#notifyListeners([event])
+    return { id: result.id, clock: this.clock }
+  }
+
+  //   /**
+  //    * Advances the clock to the specified event and updates the root CID
+  //    *   Will be used by replication
+  //    * @param {import('../clock').EventLink<import('../crdt').EventData>} event - the event to advance to
+  //    * @returns {import('../clock').EventLink<import('../crdt').EventData>[]} - the new clock after advancing
+  //    */
+  //     async advance (event) {
+  //       this.clock = await advance(this.blocks, this.clock, event)
+  //       this.rootCid = await root(this.blocks, this.clock)
+  //       return this.clock
+  //     }
+
+  /**
+   * Displays a visualization of the current clock in the console
+   */
+  //   async visClock () {
+  //     const shortLink = (l) => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`
+  //     const renderNodeLabel = (event) => {
+  //       return event.value.data.type === 'put'
+  //         ? `${shortLink(event.cid)}\\nput(${shortLink(event.value.data.key)},
+  //         {${Object.values(event.value.data.value)}})`
+  //         : `${shortLink(event.cid)}\\ndel(${event.value.data.key})`
+  //     }
+  //     for await (const line of vis(this.blocks, this.clock, { renderNodeLabel })) console.log(line)
+  //   }
+
+  /**
+   * Retrieves the document with the specified ID from the database
+   *
+   * @param {string} key - the ID of the document to retrieve
+   * @returns {Promise<import('./prolly').GetResult>} - the document with the specified ID
+   */
+  async get (key) {
+    const got = await get(this.blocks, this.clock, key)
+    // this tombstone is temporary until we can get the prolly tree to delete
+    if (got === null) {
+      throw new Error('Not found')
+    }
+    got._id = key
+    return got
+  }
+}
+
+Fireproof.storage = (_email) => {
+  return new Fireproof(new Blockstore(), [])
+}

package/src/link.d.ts

@@ -0,0 +1,3 @@
+import type { Link } from 'multiformats'
+
+export type AnyLink = Link<unknown, number, number, 1|0>

package/src/listener.js

@@ -0,0 +1,111 @@
+/**
+ * A Fireproof database Listener allows you to react to events in the database.
+ *
+ * @class
+ * @classdesc An listener can be notified of events as they happen or on reconection
+ *
+ * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to index.
+ * @param {Function} eventFun - The map function to apply to each entry in the database.
+ *
+ */
+export default class Listener {
+  #subcribers = new Map()
+
+  // todo code review if there is a better way that doesn't create a circular reference
+  // because otherwise we need to document that the user must call stopListening
+  // or else the listener will never be garbage collected
+  // maybe we can use WeakRef on the db side
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef
+  #doStopListening = null
+
+  /**
+   * Creates a new index with the given map function and database.
+   * @param {import('./fireproof').Fireproof} database - The Fireproof database instance to index.
+   * @param {Function} eventFun - The event function to apply to each current change to the database.
+   */
+  constructor (database, eventFun) {
+    /** eventFun
+     * The database instance to index.
+     * @type {import('./fireproof').Fireproof}
+     */
+    this.database = database
+    this.#doStopListening = database.registerListener((changes) => this.#onChanges(changes))
+    /**
+     * The map function to apply to each entry in the database.
+     * @type {Function}
+     */
+    this.eventFun = eventFun || function (_, emit) { emit('*') }
+    this.dbHead = null
+  }
+
+  /**
+   * Subscribe to a topic emitted by the event function.
+   * @param {string} topic - The topic to subscribe to.
+   * @param {Function} subscriber - The function to call when the topic is emitted.
+   * @returns {Function} A function to unsubscribe from the topic.
+   */
+  on (topic, subscriber, since) {
+    const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
+    listOfTopicSubscribers.push(subscriber)
+    if (typeof since !== 'undefined') {
+      this.database.changesSince(since).then(({ rows: changes }) => {
+        const keys = topicsForChanges(changes, this.eventFun).get(topic)
+        if (keys) keys.forEach((key) => subscriber(key))
+      })
+    }
+    return () => {
+      const index = listOfTopicSubscribers.indexOf(subscriber)
+      if (index > -1) listOfTopicSubscribers.splice(index, 1)
+    }
+  }
+
+  #onChanges (changes) {
+    if (Array.isArray(changes)) {
+      const seenTopics = topicsForChanges(changes, this.eventFun)
+      for (const [topic, keys] of seenTopics) {
+        const listOfTopicSubscribers = getTopicList(this.#subcribers, topic)
+        listOfTopicSubscribers.forEach((subscriber) => keys.forEach((key) => subscriber(key)))
+      }
+    } else {
+      // reset event
+      if (changes.reset) {
+        for (const [, listOfTopicSubscribers] of this.#subcribers) {
+          listOfTopicSubscribers.forEach((subscriber) => subscriber(changes))
+        }
+      }
+    }
+    // if changes is special, notify all listeners?
+    // first make the example app use listeners
+  }
+}
+
+function getTopicList (subscribersMap, name) {
+  let topicList = subscribersMap.get(name)
+  if (!topicList) {
+    topicList = []
+    subscribersMap.set(name, topicList)
+  }
+  return topicList
+}
+
+// copied from src/db-index.js
+const makeDoc = ({ key, value }) => ({ _id: key, ...value })
+
+/**
+ * Transforms a set of changes to events using an emitter function.
+ *
+ * @param {Array<{ key: string, value: import('./link').AnyLink, del?: boolean }>} changes
+ * @param {Function} eventFun
+ * @returns {Array<string>} The topics emmitted by the event function.
+ */
+const topicsForChanges = (changes, eventFun) => {
+  const seenTopics = new Map()
+  changes.forEach(({ key, value, del }) => {
+    if (del || !value) value = { _deleted: true }
+    eventFun(makeDoc({ key, value }), (t) => {
+      const topicList = getTopicList(seenTopics, t)
+      topicList.push(key)
+    })
+  })
+  return seenTopics
+}

package/src/prolly.js

@@ -0,0 +1,235 @@
+import { advance, EventFetcher, EventBlock, findCommonAncestorWithSortedEvents, findUnknownSortedEvents } from './clock.js'
+import { create, load } from 'prolly-trees/map'
+import * as codec from '@ipld/dag-cbor'
+import { sha256 as hasher } from 'multiformats/hashes/sha2'
+import { MemoryBlockstore, MultiBlockFetcher } from './block.js'
+import { doTransaction } from './blockstore.js'
+
+import { nocache as cache } from 'prolly-trees/cache'
+import { bf, simpleCompare as compare } from 'prolly-trees/utils'
+import { create as createBlock } from 'multiformats/block'
+const opts = { cache, chunker: bf(3), codec, hasher, compare }
+
+const withLog = async (label, fn) => {
+  const resp = await fn()
+  // console.log('withLog', label, !!resp)
+  return resp
+}
+
+const makeGetBlock = (blocks) => async (address) => {
+  const { cid, bytes } = await withLog(address, () => blocks.get(address))
+  return createBlock({ cid, bytes, hasher, codec })
+}
+
+async function createAndSaveNewEvent (inBlocks, mblocks, getBlock, bigPut, root, { key, value, del }, head, additions, removals = []) {
+  const data = {
+    type: 'put',
+    root: {
+      cid: root.cid,
+      bytes: root.bytes,
+      value: root.value
+    },
+    key
+  }
+
+  if (del) {
+    data.value = null
+    data.type = 'del'
+  } else {
+    data.value = value
+  }
+  /** @type {EventData} */
+
+  const event = await EventBlock.create(data, head)
+  bigPut(event)
+  head = await advance(inBlocks, head, event.cid)
+
+  return {
+    root,
+    additions,
+    removals,
+    head,
+    event
+  }
+}
+
+const makeGetAndPutBlock = (inBlocks) => {
+  const mblocks = new MemoryBlockstore()
+  const blocks = new MultiBlockFetcher(mblocks, inBlocks)
+  const getBlock = makeGetBlock(blocks)
+  const put = inBlocks.put.bind(inBlocks)
+  const bigPut = async (block, additions) => {
+    // console.log('bigPut', block.cid.toString())
+    const { cid, bytes } = block
+    put(cid, bytes)
+    mblocks.putSync(cid, bytes)
+    if (additions) {
+      additions.set(cid.toString(), block)
+    }
+  }
+  return { getBlock, bigPut, mblocks, blocks }
+}
+
+const bulkFromEvents = (sorted) =>
+  sorted.map(({ value: event }) => {
+    const {
+      data: { type, value, key }
+    } = event
+    return type === 'put' ? { key, value } : { key, del: true }
+  })
+
+// Get the value of the root from the ancestor event
+/**
+ *
+ * @param {EventFetcher} events
+ * @param {Link} ancestor
+ * @param {*} getBlock
+ * @returns
+ */
+const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
+  // console.log('prollyRootFromAncestor', ancestor)
+  const event = await events.get(ancestor)
+  const { root } = event.value.data
+  // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
+  return load({ cid: root.cid, get: getBlock, ...opts })
+}
+
+/**
+ * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
+ *
+ * @param {import('./block').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 {import('./link').AnyLink} value The value to put.
+ * @param {object} [options]
+ * @returns {Promise<Result>}
+ */
+export async function put (inBlocks, head, event, options) {
+  const { getBlock, bigPut, mblocks, blocks } = makeGetAndPutBlock(inBlocks)
+
+  // If the head is empty, we create a new event and return the root and addition blocks
+  if (!head.length) {
+    const additions = new Map()
+    let root
+    for await (const node of create({ get: getBlock, list: [event], ...opts })) {
+      root = await node.block
+      bigPut(root, additions)
+    }
+    return createAndSaveNewEvent(inBlocks, mblocks, getBlock, bigPut, root, event, head, Array.from(additions.values()))
+  }
+
+  // Otherwise, we find the common ancestor and update the root and other blocks
+  const events = new EventFetcher(blocks)
+  const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
+  const prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
+
+  const bulkOperations = bulkFromEvents(sorted)
+  const { root: newProllyRootNode, blocks: newBlocks } = await prollyRootNode.bulk([...bulkOperations, event]) // ading delete support here
+  const prollyRootBlock = await newProllyRootNode.block
+  const additions = new Map() // ; const removals = new Map()
+  bigPut(prollyRootBlock, additions)
+  for (const nb of newBlocks) {
+    bigPut(nb, additions)
+  }
+
+  return createAndSaveNewEvent(inBlocks, mblocks, getBlock, bigPut,
+    prollyRootBlock, event, head, Array.from(additions.values()) /*, Array.from(removals.values()) */)
+}
+
+/**
+ * Determine the effective prolly root given the current merkle clock head.
+ *
+ * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
+ */
+export async function root (inBlocks, head) {
+  if (!head.length) {
+    throw new Error('no head')
+  }
+  const { getBlock, blocks } = makeGetAndPutBlock(inBlocks)
+  const events = new EventFetcher(blocks)
+  const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head)
+  const prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock)
+
+  // Perform bulk operations (put or delete) for each event in the sorted array
+  const bulkOperations = bulkFromEvents(sorted)
+  const { root: newProllyRootNode, blocks: newBlocks } = await prollyRootNode.bulk(bulkOperations)
+  const prollyRootBlock = await newProllyRootNode.block
+  // console.log('emphemeral blocks', newBlocks.map((nb) => nb.cid.toString()))
+  // todo maybe these should go to a temp blockstore?
+  await doTransaction('root', inBlocks, async (transactionBlockstore) => {
+    const { bigPut } = makeGetAndPutBlock(transactionBlockstore)
+    for (const nb of newBlocks) {
+      bigPut(nb)
+    }
+    bigPut(prollyRootBlock)
+  })
+
+  return newProllyRootNode // .block).cid // todo return live object not cid
+}
+
+/**
+ * Get the list of events not known by the `since` event
+ * @param {import('./block').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>[]>}
+ */
+export async function eventsSince (blocks, head, since) {
+  if (!head.length) {
+    throw new Error('no head')
+  }
+  const sinceHead = [...since, ...head]
+  const unknownSorted3 = await findUnknownSortedEvents(blocks, sinceHead,
+    await findCommonAncestorWithSortedEvents(blocks, sinceHead))
+  return unknownSorted3.map(({ value: { data } }) => data)
+}
+
+/**
+ *
+ * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
+ *
+ * @returns {Promise<import('./prolly').Entry[]>}
+ *
+ */
+export async function getAll (blocks, head) {
+  // todo use the root node left around from put, etc
+  // move load to a central place
+  if (!head.length) {
+    return []
+  }
+  const prollyRootNode = await root(blocks, head)
+  const { result } = await prollyRootNode.getAllEntries()
+  return result.map(({ key, value }) => ({ key, value }))
+}
+
+/**
+ * @param {import('./block').BlockFetcher} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<EventData>[]} head Merkle clock head.
+ * @param {string} key The key of the value to retrieve.
+ */
+export async function get (blocks, head, key) {
+  // instead pass root from db? and always update on change
+  if (!head.length) {
+    return null
+  }
+  const prollyRootNode = await root(blocks, head)
+  const { result } = await prollyRootNode.get(key)
+  return result
+}
+
+/**
+ * @typedef {{
+ *   type: 'put'|'del'
+ *   key: string
+ *   value: import('./link').AnyLink
+ *   root: import('./shard').ShardLink
+ * }} EventData
+ *
+ * @typedef {{
+ *   root: import('./shard').ShardLink
+ *   head: import('./clock').EventLink<EventData>[]
+ *   event: import('./clock').EventBlockView<EventData>
+ * } & import('./db-index').ShardDiff} Result
+ */

package/src/valet.js

@@ -0,0 +1,142 @@
+import { CarReader } from '@ipld/car'
+import { CID } from 'multiformats/cid'
+import { openDB } from 'idb'
+
+// const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+let storageSupported = false
+try {
+  storageSupported = (window.localStorage && true)
+} catch (e) { }
+
+export default class Valet {
+  #cars = new Map() // cars by cid
+  #cidToCar = new Map() // cid to car
+
+  #db = null
+
+  withDB = async (dbWorkFun) => {
+    if (!storageSupported) return
+    if (!this.#db) {
+      this.#db = await openDB('valet', 1, {
+        upgrade (db) {
+          db.createObjectStore('cars') // todo use database name
+          const cidToCar = db.createObjectStore('cidToCar', { keyPath: 'car' })
+          cidToCar.createIndex('cids', 'cids', { multiEntry: true })
+        }
+      })
+    }
+    return await dbWorkFun(this.#db)
+  }
+
+  /**
+     *
+     * @param {string} carCid
+     * @param {*} value
+     */
+  async parkCar (carCid, value, cids) {
+    this.#cars.set(carCid, value)
+    for (const cid of cids) {
+      this.#cidToCar.set(cid, carCid)
+    }
+
+    await this.withDB(async (db) => {
+      const tx = db.transaction(['cars', 'cidToCar'], 'readwrite')
+      await tx.objectStore('cars').put(value, carCid)
+      await tx.objectStore('cidToCar').put({ car: carCid, cids: Array.from(cids) })
+      return await tx.done
+    })
+  }
+
+  async getBlock (dataCID) {
+    // return await this.#valetGet(dataCID)
+    // const MEMcarCid = this.#cidToCar.get(dataCID)
+
+    // return await this.withDB(async (db) => {
+    //   const tx = db.transaction(['cars', 'cidToCar'], 'readonly')
+    //   const carBytes = await tx.objectStore('cars').get(MEMcarCid)
+    //   const reader = await CarReader.fromBytes(carBytes)
+    //   const gotBlock = await reader.get(CID.parse(dataCID))
+    //   if (gotBlock) {
+    //     return gotBlock.bytes
+    //   }
+    // })
+
+    return await this.withDB(async (db) => {
+      const tx = db.transaction(['cars', 'cidToCar'], 'readonly')
+      const indexResp = await tx.objectStore('cidToCar').index('cids').get(dataCID)
+      const carCid = indexResp?.car
+      if (!carCid) {
+        return
+      }
+      const carBytes = await tx.objectStore('cars').get(carCid)
+      const reader = await CarReader.fromBytes(carBytes)
+      const gotBlock = await reader.get(CID.parse(dataCID))
+      if (gotBlock) {
+        return gotBlock.bytes
+      }
+    })
+  }
+
+  /**
+   * Internal function to load blocks from persistent storage.
+   * Currently it just searches all the cars for the block, but in the future
+   * we need to index the block CIDs to the cars, and reference that to find the block.
+   * This index will also allow us to use accelerator links for the gateway when needed.
+   * It can itself be a prolly tree...
+   * @param {string} cid
+   * @returns {Promise<Uint8Array|undefined>}
+   */
+  #valetGet = async (cid) => {
+    const carCid = this.#cidToCar.get(cid)
+    if (carCid) {
+      const carBytes = this.#cars.get(carCid)
+      const reader = await CarReader.fromBytes(carBytes)
+      const gotBlock = await reader.get(CID.parse(cid))
+      if (gotBlock) {
+        return gotBlock.bytes
+      }
+    }
+  }
+}
+
+export class MemoryValet {
+  #cars = new Map() // cars by cid
+  #cidToCar = new Map() // cid to car
+
+  /**
+       *
+       * @param {string} carCid
+       * @param {*} value
+       */
+  async parkCar (carCid, value, cids) {
+    this.#cars.set(carCid, value)
+    for (const cid of cids) {
+      this.#cidToCar.set(cid, carCid)
+    }
+  }
+
+  async getBlock (dataCID) {
+    return await this.#valetGet(dataCID)
+  }
+
+  /**
+     * Internal function to load blocks from persistent storage.
+     * Currently it just searches all the cars for the block, but in the future
+     * we need to index the block CIDs to the cars, and reference that to find the block.
+     * This index will also allow us to use accelerator links for the gateway when needed.
+     * It can itself be a prolly tree...
+     * @param {string} cid
+     * @returns {Promise<Uint8Array|undefined>}
+     */
+  #valetGet = async (cid) => {
+    const carCid = this.#cidToCar.get(cid)
+    if (carCid) {
+      const carBytes = this.#cars.get(carCid)
+      const reader = await CarReader.fromBytes(carBytes)
+      const gotBlock = await reader.get(CID.parse(cid))
+      if (gotBlock) {
+        return gotBlock.bytes
+      }
+    }
+  }
+}