@atproto/repo 0.10.2 → 0.10.3

package/tests/_util.ts

@@ -1,265 +0,0 @@
-import fs from 'node:fs'
-import { TID } from '@atproto/common-web'
-import * as crypto from '@atproto/crypto'
-import { Keypair, randomBytes } from '@atproto/crypto'
-import * as cbor from '@atproto/lex-cbor'
-import { Cid, cidForCbor, parseCid } from '@atproto/lex-data'
-import { NsidString } from '@atproto/syntax'
-import {
-  BlockMap,
-  CollectionContents,
-  Commit,
-  CommitData,
-  DataDiff,
-  RecordPath,
-  RecordWriteOp,
-  RepoContents,
-  WriteOpAction,
-} from '../src/index.js'
-import { MST } from '../src/mst/index.js'
-import { Repo } from '../src/repo.js'
-import { RepoStorage } from '../src/storage/index.js'
-
-type IdMapping = Record<string, Cid>
-
-export const randomCid = async (storage?: RepoStorage): Promise<Cid> => {
-  const bytes = cbor.encode({ test: randomStr(50) })
-  const cid = await cidForCbor(bytes)
-  if (storage) {
-    // @ts-expect-error FIXME remove this comment (and fix the TS error)
-    await storage.putBlock(cid, bytes)
-  }
-  return cid
-}
-
-export const generateBulkDataKeys = async (
-  count: number,
-  blockstore?: RepoStorage,
-): Promise<IdMapping> => {
-  const obj: IdMapping = {}
-  for (let i = 0; i < count; i++) {
-    const key = `com.example.record/${TID.nextStr()}`
-    obj[key] = await randomCid(blockstore)
-  }
-  return obj
-}
-
-export const keysFromMapping = (mapping: IdMapping): TID[] => {
-  return Object.keys(mapping).map((id) => TID.fromStr(id))
-}
-
-export const keysFromMappings = (mappings: IdMapping[]): TID[] => {
-  return mappings.map(keysFromMapping).flat()
-}
-
-export const randomStr = (len: number): string => {
-  let result = ''
-  const CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-  for (let i = 0; i < len; i++) {
-    result += CHARS.charAt(Math.floor(Math.random() * CHARS.length))
-  }
-  return result
-}
-
-export const shuffle = <T>(arr: T[]): T[] => {
-  const toShuffle = [...arr]
-  const shuffled: T[] = []
-  while (toShuffle.length > 0) {
-    const index = Math.floor(Math.random() * toShuffle.length)
-    shuffled.push(toShuffle[index])
-    toShuffle.splice(index, 1)
-  }
-  return shuffled
-}
-
-export const generateObject = (): Record<string, string> => {
-  return {
-    name: randomStr(100),
-  }
-}
-
-// Mass repo mutations & checking
-// -------------------------------
-
-export const testCollections: NsidString[] = [
-  'com.example.posts',
-  'com.example.likes',
-]
-
-export const fillRepo = async (
-  repo: Repo,
-  keypair: crypto.Keypair,
-  itemsPerCollection: number,
-): Promise<{ repo: Repo; data: RepoContents }> => {
-  const repoData: RepoContents = {}
-  const writes: RecordWriteOp[] = []
-  for (const collName of testCollections) {
-    const collData: CollectionContents = {}
-    for (let i = 0; i < itemsPerCollection; i++) {
-      const object = generateObject()
-      const rkey = TID.nextStr()
-      collData[rkey] = object
-      writes.push({
-        action: WriteOpAction.Create,
-        collection: collName,
-        rkey,
-        record: object,
-      })
-    }
-    repoData[collName] = collData
-  }
-  const updated = await repo.applyWrites(writes, keypair)
-  return {
-    repo: updated,
-    data: repoData,
-  }
-}
-
-export const formatEdit = async (
-  repo: Repo,
-  prevData: RepoContents,
-  keypair: crypto.Keypair,
-  params: {
-    adds?: number
-    updates?: number
-    deletes?: number
-  },
-): Promise<{ commit: CommitData; data: RepoContents }> => {
-  const { adds = 0, updates = 0, deletes = 0 } = params
-  const repoData: RepoContents = {}
-  const writes: RecordWriteOp[] = []
-  for (const collName of testCollections) {
-    const collData = { ...(prevData[collName] ?? {}) }
-    const shuffled = shuffle(Object.entries(collData))
-
-    for (let i = 0; i < adds; i++) {
-      const object = generateObject()
-      const rkey = TID.nextStr()
-      collData[rkey] = object
-      writes.push({
-        action: WriteOpAction.Create,
-        collection: collName,
-        rkey,
-        record: object,
-      })
-    }
-
-    const toUpdate = shuffled.slice(0, updates)
-    for (let i = 0; i < toUpdate.length; i++) {
-      const object = generateObject()
-      const rkey = toUpdate[i][0]
-      collData[rkey] = object
-      writes.push({
-        action: WriteOpAction.Update,
-        collection: collName,
-        rkey,
-        record: object,
-      })
-    }
-
-    const toDelete = shuffled.slice(updates, deletes)
-    for (let i = 0; i < toDelete.length; i++) {
-      const rkey = toDelete[i][0]
-      delete collData[rkey]
-      writes.push({
-        action: WriteOpAction.Delete,
-        collection: collName,
-        rkey,
-      })
-    }
-    repoData[collName] = collData
-  }
-  const commit = await repo.formatCommit(writes, keypair)
-  return {
-    commit,
-    data: repoData,
-  }
-}
-
-export const pathsForOps = (ops: RecordWriteOp[]): RecordPath[] =>
-  ops.map((op) => ({ collection: op.collection, rkey: op.rkey }))
-
-export const saveMst = async (storage: RepoStorage, mst: MST): Promise<Cid> => {
-  const diff = await mst.getUnstoredBlocks()
-  // @ts-expect-error FIXME remove this comment (and fix the TS error)
-  await storage.putMany(diff.blocks)
-  return diff.root
-}
-
-// Creating repo
-// -------------------
-export const addBadCommit = async (
-  repo: Repo,
-  keypair: Keypair,
-): Promise<Repo> => {
-  const obj = generateObject()
-  const newBlocks = new BlockMap()
-  const cid = await newBlocks.add(obj)
-  const updatedData = await repo.data.add(`com.example.test/${TID.next()}`, cid)
-  const dataCid = await updatedData.getPointer()
-  const diff = await DataDiff.of(updatedData, repo.data)
-  newBlocks.addMap(diff.newMstBlocks)
-  // we generate a bad sig by signing some other data
-  const rev = TID.nextStr(repo.commit.rev)
-  const commit: Commit = {
-    ...repo.commit,
-    rev,
-    data: dataCid,
-    sig: await keypair.sign(randomBytes(256)),
-  }
-  const commitCid = await newBlocks.add(commit)
-
-  // @ts-expect-error FIXME remove this comment (and fix the TS error)
-  await repo.storage.applyCommit({
-    cid: commitCid,
-    rev,
-    prev: repo.cid,
-    newBlocks,
-    removedCids: diff.removedCids,
-  })
-  return await Repo.load(repo.storage, commitCid)
-}
-
-// Logging
-// ----------------
-
-export const writeMstLog = async (filename: string, tree: MST) => {
-  let log = ''
-  for await (const entry of tree.walk()) {
-    if (entry.isLeaf()) continue
-    const layer = await entry.getLayer()
-    log += `Layer ${layer}: ${entry.pointer}\n`
-    log += '--------------\n'
-    const entries = await entry.getEntries()
-    for (const e of entries) {
-      if (e.isLeaf()) {
-        log += `Key: ${e.key} (${e.value})\n`
-      } else {
-        log += `Subtree: ${e.pointer}\n`
-      }
-    }
-    log += '\n\n'
-  }
-  fs.writeFileSync(filename, log)
-}
-
-export const saveMstEntries = (filename: string, entries: [string, Cid][]) => {
-  const writable = entries.map(([key, val]) => [key, val.toString()])
-  fs.writeFileSync(filename, JSON.stringify(writable))
-}
-
-export const loadMstEntries = (filename: string): [string, Cid][] => {
-  const contents = fs.readFileSync(filename)
-  const parsed = JSON.parse(contents.toString())
-  return parsed.map(([key, value]) => [key, parseCid(value)])
-}
-
-export async function toBuffer(
-  stream: AsyncIterable<Uint8Array> | Iterable<Uint8Array>,
-): Promise<Buffer> {
-  const chunks: Uint8Array[] = []
-  for await (const chunk of stream) {
-    chunks.push(chunk)
-  }
-  return Buffer.concat(chunks)
-}

package/tests/car-file-fixtures.json

@@ -1,28 +0,0 @@
-[
-  {
-    "root": "bafyreiapldaco7m23c7qzc4w42r7kxmcswm64nkindtuh4vwztrpoe7m5m",
-    "blocks": [
-      {
-        "cid": "bafyreiapldaco7m23c7qzc4w42r7kxmcswm64nkindtuh4vwztrpoe7m5m",
-        "bytes": "oWR0ZXN0ZHJvb3Q"
-      },
-      {
-        "cid": "bafyreieteuyxvbvjbvuhsuo54qx6r3tnjxtp3ub6kb66rdjml3murxjcsy",
-        "bytes": "oWR0ZXN0WQEAM32TVA//xgHS9Gtukp0vw6whQ+TnlwF9czt5A7Dxz/URSbryc9Pdw7HESX+jC2oPI/6rwKbhSml2kxJo4MaUeIg/HWI9ixxALw5gIF/I0JC3ejXVAu1Pw6bI9RWa5TgIvAnSow0pJ6jbaaWHlxCpqqHCNHUYbIC14D9k+RK3yS0h2g+O+gRUETQt8t4jOKxEhD037cYEuJCD+fWzFoLkEkrPdUWeqlFQxGt6bflCYjZFgiZKFUo72afR3XM16+jOlhOl+EtuqFcijYJ6MIB53qI8P8HMC2RVH0Mv8UYWLcWatl+CNLykEjesnMar5CvZT8j4w5EyEiS09iD4r6bljg"
-      },
-      {
-        "cid": "bafyreiahvdwcywzm35id7hajal5l73p4bnoyaowgckeatd6sbxsacoo5jq",
-        "bytes": "oWR0ZXN0WID81CSnkdKi0OBexCStL5gex6Fkehtg7R9Jaww7LFuJC/6Or9Cdb58I+6T9Kjqhf1bf5t5WLbTGt8HOlf1Ysl3wqfdxdxnRZYjyng8YjEmH2Twkc//moluskzywxfOwhRXsXI7SYt36OUkS8AKDzmhTijOG2XWSa2QvU3iSSjP8zw"
-      },
-      {
-        "cid": "bafyreictawwxwjuto6csptbtktbbgwkrryqoakgyb3qovakgiqjzmvzi6a",
-        "bytes": "oWR0ZXN0RBnEJSE"
-      },
-      {
-        "cid": "bafyreierfkr6cwv2ux5hk6hp5qh5fhgzyr4yicad5m3pyu3ndaatyqucxu",
-        "bytes": "oWR0ZXN0WQH09xLXHen1UTIPEap18egWK6OiRVQ4oLBqjfBVQGdiSsmsIn8uXDM6wp63kCrYWLvXoI0dREVW6+RUjoQIbmDhiKbEUTuLbcFiJnwD5gSlkXdUEwO4UeLfvcAsDJXel5lLaOlOeRTfA3Wf+rEEpr/ccCuwOATBPZBjPrneFVQu8UdsvTu5W144tGxp/ptBsMBqM3yLYkYYHNRrjcAI7iFiszsfKzo28GyM199Jko11mcVhNQ8KHZS72jbsWW/HyfJsL1M/dn6sDCfIaro66mTLRddSQaheQL4NBW5FEgLUBO2VDuBT9fVIl2IwQcijZAOakjLkS1sY2SyUmdsicqGRalnOrVlC5iWQcwHDXLzm9GWz/vfuoF+jzWsdpo6cjT5MIN8uXpzoZRSjH1+UXFxCzFhXkDwL/xJUq8u/0OFGp0mzDc7RLO3gC7X/ENaVPtz/wQaZ3q00EeHvDuiaxHdKIesf/+IkbqS1XjKtaHemB511MFiVf7l2OcqsUU12A5VMreqWPwbAHLgFRDPWiLS0D7yEF3KJX1IupxBmidQMT+SlmCp7FZMdJeHJ3pzpbQv+EoKSXja7it2D2uYsMcTn2DGhlVYsCcQd8PVNKZmPXuC7D82N4sh8p2XVW4LbsDfNTOrgHLX7zRX31VNa47w5Uc03Wuk"
-      }
-    ],
-    "car": "OqJlcm9vdHOB2CpYJQABcRIgD1jAJ32a2L8Mi5bmo/VdgpWZ7jVIaOdD8rbM4vcT7OtndmVyc2lvbgEvAXESIA9YwCd9mti/DIuW5qP1XYKVme41SGjnQ/K2zOL3E+zroWR0ZXN0ZHJvb3StAgFxEiCTJTF6hqkNaHlR3eQv6O5tTeb90D5QfeiNLF7ZSN0ilqFkdGVzdFkBADN9k1QP/8YB0vRrbpKdL8OsIUPk55cBfXM7eQOw8c/1EUm68nPT3cOxxEl/owtqDyP+q8Cm4UppdpMSaODGlHiIPx1iPYscQC8OYCBfyNCQt3o11QLtT8OmyPUVmuU4CLwJ0qMNKSeo22mlh5cQqaqhwjR1GGyAteA/ZPkSt8ktIdoPjvoEVBE0LfLeIzisRIQ9N+3GBLiQg/n1sxaC5BJKz3VFnqpRUMRrem35QmI2RYImShVKO9mn0d1zNevozpYTpfhLbqhXIo2CejCAed6iPD/BzAtkVR9DL/FGFi3FmrZfgjS8pBI3rJzGq+Qr2U/I+MORMhIktPYg+K+m5Y6sAQFxEiAHqOwsWyzfUD+cCQL6v+38C12AOsYSiAmP0g3kATndTKFkdGVzdFiA/NQkp5HSotDgXsQkrS+YHsehZHobYO0fSWsMOyxbiQv+jq/QnW+fCPuk/So6oX9W3+beVi20xrfBzpX9WLJd8Kn3cXcZ0WWI8p4PGIxJh9k8JHP/5qJbrJM8sMXzsIUV7FyO0mLd+jlJEvACg85oU4ozhtl1kmtkL1N4kkoz/M8vAXESIFMFrXsmk3eFJ8wzVMITWVGOIOAo2A7g6oFGRBOWVyjwoWR0ZXN0RBnEJSGhBAFxEiCRKqPhWrql+nV47+wP0pzZxHmECAPrNvxTbRgBPEKCvaFkdGVzdFkB9PcS1x3p9VEyDxGqdfHoFiujokVUOKCwao3wVUBnYkrJrCJ/LlwzOsKet5Aq2Fi716CNHURFVuvkVI6ECG5g4YimxFE7i23BYiZ8A+YEpZF3VBMDuFHi373ALAyV3peZS2jpTnkU3wN1n/qxBKa/3HArsDgEwT2QYz653hVULvFHbL07uVteOLRsaf6bQbDAajN8i2JGGBzUa43ACO4hYrM7Hys6NvBsjNffSZKNdZnFYTUPCh2Uu9o27Flvx8nybC9TP3Z+rAwnyGq6Oupky0XXUkGoXkC+DQVuRRIC1ATtlQ7gU/X1SJdiMEHIo2QDmpIy5EtbGNkslJnbInKhkWpZzq1ZQuYlkHMBw1y85vRls/737qBfo81rHaaOnI0+TCDfLl6c6GUUox9flFxcQsxYV5A8C/8SVKvLv9DhRqdJsw3O0Szt4Au1/xDWlT7c/8EGmd6tNBHh7w7omsR3SiHrH//iJG6ktV4yrWh3pgeddTBYlX+5djnKrFFNdgOVTK3qlj8GwBy4BUQz1oi0tA+8hBdyiV9SLqcQZonUDE/kpZgqexWTHSXhyd6c6W0L/hKCkl42u4rdg9rmLDHE59gxoZVWLAnEHfD1TSmZj17guw/NjeLIfKdl1VuC27A3zUzq4By1+80V99VTWuO8OVHNN1rp"
-  }
-]

package/tests/car.test.ts

@@ -1,125 +0,0 @@
-import { wait } from '@atproto/common-web'
-import { encode } from '@atproto/lex-cbor'
-import {
-  Cid,
-  LexValue,
-  cidForCbor,
-  fromBase64,
-  parseCid,
-  toBase64,
-} from '@atproto/lex-data'
-import { CarBlock, readCarStream, writeCarStream } from '../src/index.js'
-import fixtures from './car-file-fixtures.json' with { type: 'json' }
-
-async function dataToCborBlock(data: LexValue): Promise<{
-  cid: Cid
-  bytes: Uint8Array
-}> {
-  const bytes = encode(data)
-  const cid = await cidForCbor(bytes)
-  return { cid, bytes }
-}
-
-describe('car', () => {
-  for (const fixture of fixtures) {
-    it('correctly writes car files', async () => {
-      const root = parseCid(fixture.root)
-      async function* blockIter() {
-        for (const block of fixture.blocks) {
-          const cid = parseCid(block.cid)
-          const bytes = fromBase64(block.bytes, 'base64')
-          yield { cid, bytes }
-        }
-      }
-      const carStream = writeCarStream(root, blockIter())
-      const chunks: Uint8Array[] = []
-      for await (const chunk of carStream) {
-        chunks.push(chunk)
-      }
-      const car = Buffer.concat(chunks)
-      // @NOTE Not using car.toString('base64') because of padding differences
-      expect(toBase64(car)).toEqual(fixture.car)
-    })
-
-    it('correctly reads carfiles', async () => {
-      const carStream = [fromBase64(fixture.car, 'base64')]
-      const { roots, blocks } = await readCarStream(carStream)
-      expect(roots.length).toBe(1)
-      expect(roots[0].toString()).toEqual(fixture.root)
-      const carBlocks: CarBlock[] = []
-      for await (const block of blocks) {
-        carBlocks.push(block)
-      }
-      expect(carBlocks.length).toEqual(fixture.blocks.length)
-      for (let i = 0; i < carBlocks.length; i++) {
-        expect(carBlocks[i].cid.toString()).toEqual(fixture.blocks[i].cid)
-        expect(toBase64(carBlocks[i].bytes, 'base64')).toEqual(
-          fixture.blocks[i].bytes,
-        )
-      }
-    })
-  }
-
-  it('writeCar propagates errors', async () => {
-    const iterate = async () => {
-      async function* blockIterator() {
-        await wait(1)
-        const block = await dataToCborBlock({ test: 1 })
-        yield block
-        throw new Error('Oops!')
-      }
-      const iter = writeCarStream(null, blockIterator())
-      for await (const _bytes of iter) {
-        // no-op
-      }
-    }
-    await expect(iterate).rejects.toThrow('Oops!')
-  })
-
-  it('verifies CIDs', async () => {
-    const block0 = await dataToCborBlock({ block: 0 })
-    const block1 = await dataToCborBlock({ block: 1 })
-    const block2 = await dataToCborBlock({ block: 2 })
-    const block3 = await dataToCborBlock({ block: 3 })
-    const badBlock = await dataToCborBlock({ block: 'bad' })
-    const blockIter = async function* () {
-      yield block0
-      yield block1
-      yield block2
-      yield { cid: block3.cid, bytes: badBlock.bytes }
-    }
-    const flush = async function (iter: AsyncIterable<unknown>) {
-      for await (const _ of iter) {
-        // no-op
-      }
-    }
-    const badCar = await readCarStream(writeCarStream(block0.cid, blockIter()))
-    await expect(flush(badCar.blocks)).rejects.toThrow(
-      'Not a valid CID for bytes',
-    )
-  })
-
-  it('skips CID verification', async () => {
-    const block0 = await dataToCborBlock({ block: 0 })
-    const block1 = await dataToCborBlock({ block: 1 })
-    const block2 = await dataToCborBlock({ block: 2 })
-    const block3 = await dataToCborBlock({ block: 3 })
-    const badBlock = await dataToCborBlock({ block: 'bad' })
-    const blockIter = async function* () {
-      yield block0
-      yield block1
-      yield block2
-      yield { cid: block3.cid, bytes: badBlock.bytes }
-    }
-    const flush = async function (iter: AsyncIterable<unknown>) {
-      for await (const _ of iter) {
-        // no-op
-      }
-    }
-    const badCar = await readCarStream(
-      writeCarStream(block0.cid, blockIter()),
-      { skipCidVerification: true },
-    )
-    await expect(flush(badCar.blocks)).resolves.toBeUndefined()
-  })
-})

package/tests/commit-data.test.ts

@@ -1,94 +0,0 @@
-import { Secp256k1Keypair } from '@atproto/crypto'
-import {
-  Repo,
-  WriteOpAction,
-  blocksToCarFile,
-  verifyProofs,
-} from '../src/index.js'
-import { MemoryBlockstore } from '../src/storage/index.js'
-
-describe('Commit data', () => {
-  // @NOTE this test uses a fully deterministic tree structure
-  it('includes all relevant blocks for proof in commit data', async () => {
-    const did = 'did:example:alice'
-    const collection = 'com.atproto.test'
-    const record = {
-      test: 123,
-    }
-
-    const blockstore = new MemoryBlockstore()
-    const keypair = await Secp256k1Keypair.create()
-    let repo = await Repo.create(blockstore, did, keypair)
-
-    const keys: string[] = []
-    for (let i = 0; i < 50; i++) {
-      const rkey = `key-${i}`
-      keys.push(rkey)
-      repo = await repo.applyWrites(
-        [
-          {
-            action: WriteOpAction.Create,
-            collection,
-            rkey,
-            record,
-          },
-        ],
-        keypair,
-      )
-    }
-
-    // this test demonstrates the test case:
-    // specifically in the case of deleting the first key, there is a "rearranged block" that is necessary
-    // in the proof path but _is not_ in newBlocks (as it already existed in the repository)
-    {
-      const commit = await repo.formatCommit(
-        {
-          action: WriteOpAction.Delete,
-          collection,
-          rkey: keys[0],
-        },
-        keypair,
-      )
-      const car = await blocksToCarFile(commit.cid, commit.newBlocks)
-      const proofAttempt = verifyProofs(
-        car,
-        [
-          {
-            collection,
-            rkey: keys[0],
-            cid: null,
-          },
-        ],
-        did,
-        keypair.did(),
-      )
-      await expect(proofAttempt).rejects.toThrow(/block not found/)
-    }
-
-    for (const rkey of keys) {
-      const commit = await repo.formatCommit(
-        {
-          action: WriteOpAction.Delete,
-          collection,
-          rkey,
-        },
-        keypair,
-      )
-      const car = await blocksToCarFile(commit.cid, commit.relevantBlocks)
-      const proofRes = await verifyProofs(
-        car,
-        [
-          {
-            collection,
-            rkey: rkey,
-            cid: null,
-          },
-        ],
-        did,
-        keypair.did(),
-      )
-      expect(proofRes.unverified.length).toBe(0)
-      repo = await repo.applyCommit(commit)
-    }
-  })
-})

package/tests/commit-proof-fixtures.json

@@ -1,118 +0,0 @@
-[
-  {
-    "comment": "two deep split",
-    "leafValue": "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454",
-    "keys": [
-      "A0/374913",
-      "B1/986427",
-      "C0/451630",
-      "E0/670489",
-      "F1/085263",
-      "G0/765327"
-    ],
-    "adds": ["D2/269196"],
-    "dels": [],
-    "rootBeforeCommit": "bafyreicraprx2xwnico4tuqir3ozsxpz46qkcpox3obf5bagicqwurghpy",
-    "rootAfterCommit": "bafyreihvay6pazw3dfa47u5d2tn3rd6pa57sr37bo5bqyvjuqc73ib65my",
-    "blocksInProof": [
-      "bafyreieazvzmba35p4phksumwfoklwe5o4ncmo7otud74idcyv4orrbzxi",
-      "bafyreie4227qpa4vbtbpnsvuhp322b776vjuhxsidi5hxp2gawumr4m3de",
-      "bafyreid44jgimksqqdratyste2moqu6zo4h6co2pknjppfoiplsqxtuxae",
-      "bafyreiaerlvitye7fjjwodkshtbqqdsmfsdjtnlz4vs6y4trnddshsmd5a",
-      "bafyreihvay6pazw3dfa47u5d2tn3rd6pa57sr37bo5bqyvjuqc73ib65my"
-    ]
-  },
-  {
-    "comment": "two deep leafless split",
-    "leafValue": "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454",
-    "keys": ["A0/374913", "B0/601692", "D0/952776", "E0/670489"],
-    "adds": ["C2/014073"],
-    "dels": [],
-    "rootBeforeCommit": "bafyreialm5sgf7pijawbschsjpdevid5rss5ip3d4n4w6cc4mhu53sfl4i",
-    "rootAfterCommit": "bafyreibxh4iztp5l2yshz3ectg2qjpeyprpw2gogao3pvceowpq3k3thya",
-    "blocksInProof": [
-      "bafyreih7dxytqtcjv3cfia3fi3wxofeip62teqkpynnkxisxqwfchfb4bu",
-      "bafyreiaqbymlnvpklmogx75gozjl3y73gva43jbgwcrqu2pp5g5ejou5vm",
-      "bafyreicfh3st5ghtnoqyyvznjv4lhfnvl7qsndempx35i4tcmoxakqbgrm",
-      "bafyreieyjrrai6igjceyxzkajrxgxz37da2eufb33anvesb4ev6yzztauu",
-      "bafyreibxh4iztp5l2yshz3ectg2qjpeyprpw2gogao3pvceowpq3k3thya"
-    ]
-  },
-  {
-    "comment": "add on edge with neighbor two layers down",
-    "leafValue": "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454",
-    "keys": ["A0/374913", "B2/827649", "C0/451630"],
-    "adds": ["D2/269196"],
-    "dels": [],
-    "rootBeforeCommit": "bafyreigc6ay2qwfk7kuevvrczummpd64nknfo4yxpaooknfymzyb7u3ntq",
-    "rootAfterCommit": "bafyreign6kxoll35r5f2ske6hjx7vg56aw3jn6r5hcopgrepzafpvohr2a",
-    "blocksInProof": [
-      "bafyreieazvzmba35p4phksumwfoklwe5o4ncmo7otud74idcyv4orrbzxi",
-      "bafyreidicvcjgrpm5bmhm3ndh2ysqfhgzk4chwn3m4kuvwkenfusspb4uy",
-      "bafyreign6kxoll35r5f2ske6hjx7vg56aw3jn6r5hcopgrepzafpvohr2a"
-    ]
-  },
-  {
-    "comment": "merge and split in multi-op commit",
-    "leafValue": "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454",
-    "keys": ["A0/374913", "B2/827649", "D2/269196", "E0/670489"],
-    "adds": ["C2/014073"],
-    "dels": ["B2/827649", "D2/269196"],
-    "rootBeforeCommit": "bafyreiceld4icym4qjmdcn3dfgtxt7t66hdgyhvigessgmkvb56dx6amgi",
-    "rootAfterCommit": "bafyreigkalika3taqauapfha556lo36zzcjoiifny5xeru6yis3nxw5ruq",
-    "blocksInProof": [
-      "bafyreid44jgimksqqdratyste2moqu6zo4h6co2pknjppfoiplsqxtuxae",
-      "bafyreihytu6onh476trave25zuo63ziebkeong2755sc5nmf55uzdawgt4",
-      "bafyreigkalika3taqauapfha556lo36zzcjoiifny5xeru6yis3nxw5ruq",
-      "bafyreidnnkrdkcaswbflgtdsxm7nzs7p5f2rdous6wrlupzstuwqu5pfgm",
-      "bafyreia2kq243hqq3volwlzkbzzphoeqauk54sc5h7vgogq4ei5fjizxvy"
-    ]
-  },
-  {
-    "comment": "complex multi-op commit",
-    "leafValue": "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454",
-    "keys": [
-      "B0/601692",
-      "C2/014073",
-      "D0/952776",
-      "E2/819540",
-      "F0/697858",
-      "H0/131238"
-    ],
-    "adds": ["A2/827942", "G2/611528"],
-    "dels": ["C2/014073"],
-    "rootBeforeCommit": "bafyreigr3plnts7dax6yokvinbhcqpyicdfgg6npvvyx6okc5jo55slfqi",
-    "rootAfterCommit": "bafyreiftrcrbhrwmi37u4egedlg56gk3jeh3tvmqvwgowoifuklfysyx54",
-    "blocksInProof": [
-      "bafyreih62n3gjbzzvlicuggpfydyzrp3ssyx7hdgtltd3sct3ribm3u73e",
-      "bafyreihrjhuoynjvgteuefin5vwnqmupyfzvmytdobpstqt3mbawgw5qhm",
-      "bafyreibevzst4gzkxo263syohlmq3lpxdvpjhlpyqx2ay3moh43lifydca",
-      "bafyreifsdd7dv2neal7zjhyrsvndkaocelqlpgfxwo4utoq2g77klih37e",
-      "bafyreid2wwyroodj2lxx2obikac74q77lsn6vqkoetlqqwwnr3criwlcvy",
-      "bafyreie55b224oljhykpsxdjq4ajn2ysksud7qm347s6kn2ei6a775faum",
-      "bafyreiftrcrbhrwmi37u4egedlg56gk3jeh3tvmqvwgowoifuklfysyx54"
-    ]
-  },
-  {
-    "comment": "split with earlier leaves on same layer",
-    "leafValue": "bafyreie5cvv4h45feadgeuwhbcutmh6t2ceseocckahdoe6uat64zmz454",
-    "keys": [
-      "app.bsky.feed.post/3lo3kqqljmfe2",
-      "app.bsky.feed.post/3log4547dm6h2",
-      "app.bsky.feed.post/3log45inogon2",
-      "app.bsky.feed.post/3logaodrh74d2",
-      "app.bsky.feed.post/3logteazog2n2",
-      "app.bsky.feed.post/3lon5cqsbwrj2",
-      "app.bsky.feed.repost/3l6sjhvqonco2"
-    ],
-    "adds": ["app.bsky.feed.post/3lon5dzeaihj2"],
-    "dels": [],
-    "rootBeforeCommit": "bafyreigfcsro2up7qi7l3rxdpg7n6gjtteotkmgrrqztl5oy2tf4ncl4ji",
-    "rootAfterCommit": "bafyreig33hsjiplaixvmccy65n7rn3in5nsbtcittzx6k3w5wjfhk2sg3a",
-    "blocksInProof": [
-      "bafyreig33hsjiplaixvmccy65n7rn3in5nsbtcittzx6k3w5wjfhk2sg3a",
-      "bafyreih2rhjm3apcghihwfojv2em7noqkgt5qyjcnxux7do674m464oc3m",
-      "bafyreiajhswkduap4zvqvfhth3skdgckmk2eb5gow7vv3gvj45f4fqwmxm"
-    ]
-  }
-]

package/tests/commit-proofs.test.ts

@@ -1,63 +0,0 @@
-import { parseCid } from '@atproto/lex-data'
-import { BlockMap } from '../src/index.js'
-import { MST } from '../src/mst/index.js'
-import { MemoryBlockstore } from '../src/storage/index.js'
-import fixtures from './commit-proof-fixtures.json' with { type: 'json' }
-
-describe('commit proofs', () => {
-  for (const fixture of fixtures) {
-    it(fixture.comment, async () => {
-      const { leafValue, keys, adds, dels } = fixture
-      const leaf = parseCid(leafValue)
-
-      const storage = new MemoryBlockstore()
-      let mst = await MST.create(storage)
-      for (const key of keys) {
-        mst = await mst.add(key, leaf)
-      }
-
-      const rootBeforeCommit = await mst.getPointer()
-      expect(rootBeforeCommit.toString()).toEqual(fixture.rootBeforeCommit)
-
-      for (const key of adds) {
-        mst = await mst.add(key, leaf)
-      }
-      for (const key of dels) {
-        mst = await mst.delete(key)
-      }
-      const rootAfterCommit = await mst.getPointer()
-      expect(rootAfterCommit.toString()).toEqual(fixture.rootAfterCommit)
-      const proofs = await Promise.all(
-        [...adds, ...dels].map((key) => mst.getCoveringProof(key)),
-      )
-      const proof = proofs.reduce((acc, cur) => acc.addMap(cur), new BlockMap())
-      const blocksInProof = fixture.blocksInProof.map(parseCid)
-      for (const cid of blocksInProof) {
-        expect(proof.has(cid)).toBe(true)
-      }
-
-      const invertAdds = adds.map((k) => (mst: MST) => mst.delete(k))
-      const invertDels = dels.map((k) => (mst: MST) => mst.add(k, leaf))
-      const invertOrders = permutations([...invertAdds, ...invertDels])
-
-      const proofStorage = new MemoryBlockstore(proof)
-      for (const order of invertOrders) {
-        let proofMst = await MST.load(proofStorage, rootAfterCommit)
-        for (const fn of order) {
-          proofMst = await fn(proofMst)
-        }
-        const rootAfterInvert = await proofMst.getPointer()
-        expect(rootAfterInvert.toString()).toEqual(fixture.rootBeforeCommit)
-      }
-    })
-  }
-})
-
-function permutations<T>(arr: T[]): T[][] {
-  if (arr.length <= 1) return [arr]
-
-  return arr.reduce((perms: T[][], item: T, i: number) => {
-    const rest = [...arr.slice(0, i), ...arr.slice(i + 1)]
-    return perms.concat(permutations(rest).map((p) => [item, ...p]))
-  }, [])
-}