@atproto/repo 0.8.13 → 0.9.1

package/src/mst/mst.ts

@@ -1,12 +1,12 @@
-import { CID } from 'multiformats'
 import { z } from 'zod'
-import { cidForCbor, dataToCborBlock, schema as common } from '@atproto/common'
+import { cidForLex, encode } from '@atproto/lex-cbor'
+import { Cid, cidForCbor } from '@atproto/lex-data'
 import { BlockMap } from '../block-map'
 import { CidSet } from '../cid-set'
 import { MissingBlockError, MissingBlocksError } from '../error'
 import * as parse from '../parse'
 import { ReadableBlockstore } from '../storage'
-import { CarBlock } from '../types'
+import { CarBlock, schema } from '../types'
 import * as util from './util'
 
 /**
@@ -16,7 +16,7 @@ import * as util from './util'
  * Keys are laid out in alphabetic order.
  * The key insight of an MST is that each key is hashed and starting 0s are counted
  * to determine which layer it falls on (5 zeros for ~32 fanout).
- * This is a merkle tree, so each subtree is referred to by it's hash (CID).
+ * This is a merkle tree, so each subtree is referred to by it's hash (Cid).
  * When a leaf is changed, ever tree on the path to that leaf is changed as well,
  * thereby updating the root hash.
  *
@@ -42,11 +42,11 @@ import * as util from './util'
  * Then the first will be described as `prefix: 0, key: 'bsky/posts/abcdefg'`,
  * and the second will be described as `prefix: 16, key: 'hi'.`
  */
-const subTreePointer = z.nullable(common.cid)
+const subTreePointer = z.nullable(schema.cid)
 const treeEntry = z.object({
   p: z.number(), // prefix count of ascii chars that this key shares with the prev key
-  k: common.bytes, // the rest of the key outside the shared prefix
-  v: common.cid, // value
+  k: schema.bytes, // the rest of the key outside the shared prefix
+  v: schema.cid, // value
   t: subTreePointer, // next subtree (to the right of leaf)
 })
 const nodeData = z.object({
@@ -70,12 +70,12 @@ export class MST {
   storage: ReadableBlockstore
   entries: NodeEntry[] | null
   layer: number | null
-  pointer: CID
+  pointer: Cid
   outdatedPointer = false
 
   constructor(
     storage: ReadableBlockstore,
-    pointer: CID,
+    pointer: Cid,
     entries: NodeEntry[] | null,
     layer: number | null,
   ) {
@@ -102,14 +102,14 @@ export class MST {
   ): Promise<MST> {
     const { layer = null } = opts || {}
     const entries = await util.deserializeNodeData(storage, data, opts)
-    const pointer = await cidForCbor(data)
+    const pointer = await cidForLex(data)
     return new MST(storage, pointer, entries, layer)
   }
 
   // this is really a *lazy* load, doesn't actually touch storage
   static load(
     storage: ReadableBlockstore,
-    cid: CID,
+    cid: Cid,
     opts?: Partial<MstOpts>,
   ): MST {
     const { layer = null } = opts || {}
@@ -145,12 +145,12 @@ export class MST {
 
       return this.entries
     }
-    throw new Error('No entries or CID provided')
+    throw new Error('No entries or Cid provided')
   }
 
   // We don't hash the node on every mutation for performance reasons
   // Instead we keep track of whether the pointer is outdated and only (recursively) calculate when needed
-  async getPointer(): Promise<CID> {
+  async getPointer(): Promise<Cid> {
     if (!this.outdatedPointer) return this.pointer
     const { cid } = await this.serialize()
     this.pointer = cid
@@ -158,7 +158,7 @@ export class MST {
     return this.pointer
   }
 
-  async serialize(): Promise<{ cid: CID; bytes: Uint8Array }> {
+  async serialize(): Promise<{ cid: Cid; bytes: Uint8Array }> {
     let entries = await this.getEntries()
     const outdated = entries.filter(
       (e) => e.isTree() && e.outdatedPointer,
@@ -168,11 +168,9 @@ export class MST {
       entries = await this.getEntries()
     }
     const data = util.serializeNodeData(entries)
-    const block = await dataToCborBlock(data)
-    return {
-      cid: block.cid,
-      bytes: block.bytes,
-    }
+    const bytes = encode(data)
+    const cid = await cidForCbor(bytes)
+    return { cid, bytes }
   }
 
   // In most cases, we get the layer of a node from a hint on creation
@@ -208,7 +206,7 @@ export class MST {
   // -------------------
 
   // Return the necessary blocks to persist the MST to repo storage
-  async getUnstoredBlocks(): Promise<{ root: CID; blocks: BlockMap }> {
+  async getUnstoredBlocks(): Promise<{ root: Cid; blocks: BlockMap }> {
     const blocks = new BlockMap()
     const pointer = await this.getPointer()
     const alreadyHas = await this.storage.has(pointer)
@@ -227,7 +225,7 @@ export class MST {
 
   // Adds a new leaf for the given key/value pair
   // Throws if a leaf with that key already exists
-  async add(key: string, value: CID, knownZeros?: number): Promise<MST> {
+  async add(key: string, value: Cid, knownZeros?: number): Promise<MST> {
     util.ensureValidMstKey(key)
     const keyZeros = knownZeros ?? (await util.leadingZerosOnHash(key))
     const layer = await this.getLayer()
@@ -297,7 +295,7 @@ export class MST {
   }
 
   // Gets the value at the given key
-  async get(key: string): Promise<CID | null> {
+  async get(key: string): Promise<Cid | null> {
     const index = await this.findGtOrEqualLeafIndex(key)
     const found = await this.atIndex(index)
     if (found && found.isLeaf() && found.key === key) {
@@ -312,7 +310,7 @@ export class MST {
 
   // Edits the value at the given key
   // Throws if the given key does not exist
-  async update(key: string, value: CID): Promise<MST> {
+  async update(key: string, value: Cid): Promise<MST> {
     util.ensureValidMstKey(key)
     const index = await this.findGtOrEqualLeafIndex(key)
     const found = await this.atIndex(index)
@@ -765,8 +763,8 @@ export class MST {
     }
   }
 
-  async cidsForPath(key: string): Promise<CID[]> {
-    const cids: CID[] = [await this.getPointer()]
+  async cidsForPath(key: string): Promise<Cid[]> {
+    const cids: Cid[] = [await this.getPointer()]
     const index = await this.findGtOrEqualLeafIndex(key)
     const found = await this.atIndex(index)
     if (found && found.isLeaf() && found.key === key) {
@@ -873,7 +871,7 @@ export class MST {
 export class Leaf {
   constructor(
     public key: string,
-    public value: CID,
+    public value: Cid,
   ) {}
 
   isTree(): this is MST {

package/src/mst/util.ts

@@ -1,10 +1,25 @@
-import { CID } from 'multiformats'
-import * as uint8arrays from 'uint8arrays'
-import { cidForCbor } from '@atproto/common'
 import { sha256 } from '@atproto/crypto'
+import { cidForLex } from '@atproto/lex-cbor'
+import { Cid } from '@atproto/lex-data'
 import { ReadableBlockstore } from '../storage'
 import { Leaf, MST, MstOpts, NodeData, NodeEntry } from './mst'
 
+function toAscii(bytes: Uint8Array): string {
+  let string = ''
+  for (let i = 0; i < bytes.length; i++) {
+    string += String.fromCharCode(bytes[i])
+  }
+  return string
+}
+
+function fromAscii(str: string): Uint8Array {
+  const bytes = new Uint8Array(str.length)
+  for (let i = 0; i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i)
+  }
+  return bytes
+}
+
 export const leadingZerosOnHash = async (key: string | Uint8Array) => {
   const hash = await sha256(key)
   let leadingZeros = 0
@@ -46,8 +61,8 @@ export const deserializeNodeData = async (
   }
   let lastKey = ''
   for (const entry of data.e) {
-    const keyStr = uint8arrays.toString(entry.k, 'ascii')
-    const key = lastKey.slice(0, entry.p) + keyStr
+    const keyStr = toAscii(entry.k)
+    const key = `${lastKey.slice(0, entry.p)}${keyStr}`
     ensureValidMstKey(key)
     entries.push(new Leaf(key, entry.v))
     lastKey = key
@@ -80,7 +95,7 @@ export const serializeNodeData = (entries: NodeEntry[]): NodeData => {
       throw new Error('Not a valid node: two subtrees next to each other')
     }
     i++
-    let subtree: CID | null = null
+    let subtree: Cid | null = null
     if (next?.isTree()) {
       subtree = next.pointer
       i++
@@ -89,7 +104,7 @@ export const serializeNodeData = (entries: NodeEntry[]): NodeData => {
     const prefixLen = countPrefixLen(lastKey, leaf.key)
     data.e.push({
       p: prefixLen,
-      k: uint8arrays.fromString(leaf.key.slice(prefixLen), 'ascii'),
+      k: fromAscii(leaf.key.slice(prefixLen)),
       v: leaf.value,
       t: subtree,
     })
@@ -109,9 +124,9 @@ export const countPrefixLen = (a: string, b: string): number => {
   return i
 }
 
-export const cidForEntries = async (entries: NodeEntry[]): Promise<CID> => {
+export const cidForEntries = async (entries: NodeEntry[]): Promise<Cid> => {
   const data = serializeNodeData(entries)
-  return cidForCbor(data)
+  return cidForLex(data)
 }
 
 export const isValidMstKey = (str: string): boolean => {

package/src/parse.ts

@@ -1,14 +1,14 @@
-import { CID } from 'multiformats/cid'
-import { cborDecode, check } from '@atproto/common'
-import { RepoRecord } from '@atproto/lexicon'
+import { check } from '@atproto/common-web'
+import { decode } from '@atproto/lex-cbor'
+import { Cid, LexMap } from '@atproto/lex-data'
 import { BlockMap } from './block-map'
 import { MissingBlockError, UnexpectedObjectError } from './error'
 import { cborToLexRecord } from './util'
 
 export const getAndParseRecord = async (
   blocks: BlockMap,
-  cid: CID,
-): Promise<{ record: RepoRecord; bytes: Uint8Array }> => {
+  cid: Cid,
+): Promise<{ record: LexMap; bytes: Uint8Array }> => {
   const bytes = blocks.get(cid)
   if (!bytes) {
     throw new MissingBlockError(cid, 'record')
@@ -19,7 +19,7 @@ export const getAndParseRecord = async (
 
 export const getAndParseByDef = async <T>(
   blocks: BlockMap,
-  cid: CID,
+  cid: Cid,
   def: check.Def<T>,
 ): Promise<{ obj: T; bytes: Uint8Array }> => {
   const bytes = blocks.get(cid)
@@ -31,10 +31,10 @@ export const getAndParseByDef = async <T>(
 
 export const parseObjByDef = <T>(
   bytes: Uint8Array,
-  cid: CID,
+  cid: Cid,
   def: check.Def<T>,
 ): { obj: T; bytes: Uint8Array } => {
-  const obj = cborDecode(bytes)
+  const obj = decode(bytes)
   const res = def.schema.safeParse(obj)
   if (res.success) {
     return { obj: res.data, bytes }

package/src/readable-repo.ts

@@ -1,5 +1,4 @@
-import { CID } from 'multiformats/cid'
-import { RepoRecord } from '@atproto/lexicon'
+import { Cid, LexMap } from '@atproto/lex-data'
 import { MissingBlocksError } from './error'
 import log from './logger'
 import { MST } from './mst'
@@ -12,14 +11,14 @@ type Params = {
   storage: ReadableBlockstore
   data: MST
   commit: Commit
-  cid: CID
+  cid: Cid
 }
 
 export class ReadableRepo {
   storage: ReadableBlockstore
   data: MST
   commit: Commit
-  cid: CID
+  cid: Cid
 
   constructor(params: Params) {
     this.storage = params.storage
@@ -28,7 +27,7 @@ export class ReadableRepo {
     this.cid = params.cid
   }
 
-  static async load(storage: ReadableBlockstore, commitCid: CID) {
+  static async load(storage: ReadableBlockstore, commitCid: Cid) {
     const commit = await storage.readObj(commitCid, def.versionedCommit)
     const data = await MST.load(storage, commit.data)
     log.info({ did: commit.did }, 'loaded repo for')
@@ -51,8 +50,8 @@ export class ReadableRepo {
   async *walkRecords(from?: string): AsyncIterable<{
     collection: string
     rkey: string
-    cid: CID
-    record: RepoRecord
+    cid: Cid
+    record: LexMap
   }> {
     for await (const leaf of this.data.walkLeavesFrom(from ?? '')) {
       const { collection, rkey } = util.parseDataKey(leaf.key)

package/src/repo.ts

@@ -1,7 +1,7 @@
-import { CID } from 'multiformats/cid'
-import { TID, dataToCborBlock } from '@atproto/common'
+import { TID } from '@atproto/common-web'
 import * as crypto from '@atproto/crypto'
-import { lexToIpld } from '@atproto/lexicon'
+import { encode } from '@atproto/lex-cbor'
+import { Cid, cidForCbor } from '@atproto/lex-data'
 import { BlockMap } from './block-map'
 import { CidSet } from './cid-set'
 import { DataDiff } from './data-diff'
@@ -23,7 +23,7 @@ type Params = {
   storage: RepoStorage
   data: MST
   commit: Commit
-  cid: CID
+  cid: Cid
 }
 
 export class Repo extends ReadableRepo {
@@ -99,7 +99,7 @@ export class Repo extends ReadableRepo {
     return Repo.createFromCommit(storage, commit)
   }
 
-  static async load(storage: RepoStorage, cid?: CID) {
+  static async load(storage: RepoStorage, cid?: Cid) {
     const commitCid = cid || (await storage.getRoot())
     if (!commitCid) {
       throw new Error('No cid provided and none in storage')
@@ -169,15 +169,18 @@ export class Repo extends ReadableRepo {
       },
       keypair,
     )
-    const commitBlock = await dataToCborBlock(lexToIpld(commit))
-    if (!commitBlock.cid.equals(this.cid)) {
-      newBlocks.set(commitBlock.cid, commitBlock.bytes)
-      relevantBlocks.set(commitBlock.cid, commitBlock.bytes)
+
+    const commitBytes = encode(commit)
+    const commitCid = await cidForCbor(commitBytes)
+
+    if (!commitCid.equals(this.cid)) {
+      newBlocks.set(commitCid, commitBytes)
+      relevantBlocks.set(commitCid, commitBytes)
       removedCids.add(this.cid)
     }
 
     return {
-      cid: commitBlock.cid,
+      cid: commitCid,
       rev,
       since: this.commit.rev,
       prev: this.cid,

package/src/storage/memory-blockstore.ts

@@ -1,4 +1,4 @@
-import { CID } from 'multiformats/cid'
+import { Cid } from '@atproto/lex-data'
 import { BlockMap } from '../block-map'
 import { CommitData } from '../types'
 import { ReadableBlockstore } from './readable-blockstore'
@@ -9,7 +9,7 @@ export class MemoryBlockstore
   implements RepoStorage
 {
   blocks: BlockMap
-  root: CID | null = null
+  root: Cid | null = null
   rev: string | null = null
 
   constructor(blocks?: BlockMap) {
@@ -20,23 +20,23 @@ export class MemoryBlockstore
     }
   }
 
-  async getRoot(): Promise<CID | null> {
+  async getRoot(): Promise<Cid | null> {
     return this.root
   }
 
-  async getBytes(cid: CID): Promise<Uint8Array | null> {
+  async getBytes(cid: Cid): Promise<Uint8Array | null> {
     return this.blocks.get(cid) || null
   }
 
-  async has(cid: CID): Promise<boolean> {
+  async has(cid: Cid): Promise<boolean> {
     return this.blocks.has(cid)
   }
 
-  async getBlocks(cids: CID[]): Promise<{ blocks: BlockMap; missing: CID[] }> {
+  async getBlocks(cids: Cid[]): Promise<{ blocks: BlockMap; missing: Cid[] }> {
     return this.blocks.getMany(cids)
   }
 
-  async putBlock(cid: CID, block: Uint8Array): Promise<void> {
+  async putBlock(cid: Cid, block: Uint8Array): Promise<void> {
     this.blocks.set(cid, block)
   }
 
@@ -44,7 +44,7 @@ export class MemoryBlockstore
     this.blocks.addMap(blocks)
   }
 
-  async updateRoot(cid: CID, rev: string): Promise<void> {
+  async updateRoot(cid: Cid, rev: string): Promise<void> {
     this.root = cid
     this.rev = rev
   }

package/src/storage/readable-blockstore.ts

@@ -1,27 +1,26 @@
-import { CID } from 'multiformats/cid'
-import { check } from '@atproto/common'
-import { RepoRecord } from '@atproto/lexicon'
+import { check } from '@atproto/common-web'
+import { Cid, LexMap } from '@atproto/lex-data'
 import { BlockMap } from '../block-map'
 import { MissingBlockError } from '../error'
-import * as parse from '../parse'
+import { parseObjByDef } from '../parse'
 import { cborToLexRecord } from '../util'
 
 export abstract class ReadableBlockstore {
-  abstract getBytes(cid: CID): Promise<Uint8Array | null>
-  abstract has(cid: CID): Promise<boolean>
-  abstract getBlocks(cids: CID[]): Promise<{ blocks: BlockMap; missing: CID[] }>
+  abstract getBytes(cid: Cid): Promise<Uint8Array | null>
+  abstract has(cid: Cid): Promise<boolean>
+  abstract getBlocks(cids: Cid[]): Promise<{ blocks: BlockMap; missing: Cid[] }>
 
   async attemptRead<T>(
-    cid: CID,
+    cid: Cid,
     def: check.Def<T>,
   ): Promise<{ obj: T; bytes: Uint8Array } | null> {
     const bytes = await this.getBytes(cid)
     if (!bytes) return null
-    return parse.parseObjByDef(bytes, cid, def)
+    return parseObjByDef(bytes, cid, def)
   }
 
   async readObjAndBytes<T>(
-    cid: CID,
+    cid: Cid,
     def: check.Def<T>,
   ): Promise<{ obj: T; bytes: Uint8Array }> {
     const read = await this.attemptRead(cid, def)
@@ -31,12 +30,12 @@ export abstract class ReadableBlockstore {
     return read
   }
 
-  async readObj<T>(cid: CID, def: check.Def<T>): Promise<T> {
+  async readObj<T>(cid: Cid, def: check.Def<T>): Promise<T> {
     const obj = await this.readObjAndBytes(cid, def)
     return obj.obj
   }
 
-  async attemptReadRecord(cid: CID): Promise<RepoRecord | null> {
+  async attemptReadRecord(cid: Cid): Promise<LexMap | null> {
     try {
       return await this.readRecord(cid)
     } catch {
@@ -44,7 +43,7 @@ export abstract class ReadableBlockstore {
     }
   }
 
-  async readRecord(cid: CID): Promise<RepoRecord> {
+  async readRecord(cid: Cid): Promise<LexMap> {
     const bytes = await this.getBytes(cid)
     if (!bytes) {
       throw new MissingBlockError(cid)

package/src/storage/sync-storage.ts

@@ -1,4 +1,4 @@
-import { CID } from 'multiformats/cid'
+import { Cid } from '@atproto/lex-data'
 import { BlockMap } from '../block-map'
 import { ReadableBlockstore } from './readable-blockstore'
 
@@ -10,13 +10,13 @@ export class SyncStorage extends ReadableBlockstore {
     super()
   }
 
-  async getBytes(cid: CID): Promise<Uint8Array | null> {
+  async getBytes(cid: Cid): Promise<Uint8Array | null> {
     const got = await this.staged.getBytes(cid)
     if (got) return got
     return this.saved.getBytes(cid)
   }
 
-  async getBlocks(cids: CID[]): Promise<{ blocks: BlockMap; missing: CID[] }> {
+  async getBlocks(cids: Cid[]): Promise<{ blocks: BlockMap; missing: Cid[] }> {
     const fromStaged = await this.staged.getBlocks(cids)
     const fromSaved = await this.saved.getBlocks(fromStaged.missing)
     const blocks = fromStaged.blocks
@@ -27,7 +27,7 @@ export class SyncStorage extends ReadableBlockstore {
     }
   }
 
-  async has(cid: CID): Promise<boolean> {
+  async has(cid: Cid): Promise<boolean> {
     return (await this.staged.has(cid)) || (await this.saved.has(cid))
   }
 }

package/src/storage/types.ts

@@ -1,47 +1,47 @@
-import stream from 'node:stream'
-import { CID } from 'multiformats/cid'
-import { check } from '@atproto/common'
-import { RepoRecord } from '@atproto/lexicon'
+import type { Readable } from 'node:stream'
+import { check } from '@atproto/common-web'
+import { Cid, LexMap } from '@atproto/lex-data'
 import { BlockMap } from '../block-map'
 import { CommitData } from '../types'
 
 export interface RepoStorage {
   // Writable
-  getRoot(): Promise<CID | null>
-  putBlock(cid: CID, block: Uint8Array, rev: string): Promise<void>
+  getRoot(): Promise<Cid | null>
+  putBlock(cid: Cid, block: Uint8Array, rev: string): Promise<void>
   putMany(blocks: BlockMap, rev: string): Promise<void>
-  updateRoot(cid: CID, rev: string): Promise<void>
+  updateRoot(cid: Cid, rev: string): Promise<void>
   applyCommit(commit: CommitData)
 
   // Readable
-  getBytes(cid: CID): Promise<Uint8Array | null>
-  has(cid: CID): Promise<boolean>
-  getBlocks(cids: CID[]): Promise<{ blocks: BlockMap; missing: CID[] }>
+  getBytes(cid: Cid): Promise<Uint8Array | null>
+  has(cid: Cid): Promise<boolean>
+  getBlocks(cids: Cid[]): Promise<{ blocks: BlockMap; missing: Cid[] }>
   attemptRead<T>(
-    cid: CID,
+    cid: Cid,
     def: check.Def<T>,
   ): Promise<{ obj: T; bytes: Uint8Array } | null>
   readObjAndBytes<T>(
-    cid: CID,
+    cid: Cid,
     def: check.Def<T>,
   ): Promise<{ obj: T; bytes: Uint8Array }>
-  readObj<T>(cid: CID, def: check.Def<T>): Promise<T>
-  attemptReadRecord(cid: CID): Promise<RepoRecord | null>
-  readRecord(cid: CID): Promise<RepoRecord>
+  readObj<T>(cid: Cid, def: check.Def<T>): Promise<T>
+  attemptReadRecord(cid: Cid): Promise<LexMap | null>
+  readRecord(cid: Cid): Promise<LexMap>
 }
 
+// @TODO make this less node-js specific by using AsyncIterable<Uint8Array> instead of Readable
 export interface BlobStore {
-  putTemp(bytes: Uint8Array | stream.Readable): Promise<string>
-  makePermanent(key: string, cid: CID): Promise<void>
-  putPermanent(cid: CID, bytes: Uint8Array | stream.Readable): Promise<void>
-  quarantine(cid: CID): Promise<void>
-  unquarantine(cid: CID): Promise<void>
-  getBytes(cid: CID): Promise<Uint8Array>
-  getStream(cid: CID): Promise<stream.Readable>
+  putTemp(bytes: Uint8Array | Readable): Promise<string>
+  makePermanent(key: string, cid: Cid): Promise<void>
+  putPermanent(cid: Cid, bytes: Uint8Array | Readable): Promise<void>
+  quarantine(cid: Cid): Promise<void>
+  unquarantine(cid: Cid): Promise<void>
+  getBytes(cid: Cid): Promise<Uint8Array>
+  getStream(cid: Cid): Promise<Readable>
   hasTemp(key: string): Promise<boolean>
-  hasStored(cid: CID): Promise<boolean>
-  delete(cid: CID): Promise<void>
-  deleteMany(cid: CID[]): Promise<void>
+  hasStored(cid: Cid): Promise<boolean>
+  delete(cid: Cid): Promise<void>
+  deleteMany(cid: Cid[]): Promise<void>
 }
 
 export class BlobNotFoundError extends Error {}

package/src/sync/consumer.ts

@@ -1,4 +1,4 @@
-import { CID } from 'multiformats/cid'
+import { Cid } from '@atproto/lex-data'
 import { BlockMap } from '../block-map'
 import { readCarWithRoot } from '../car'
 import { DataDiff } from '../data-diff'
@@ -25,7 +25,7 @@ export const verifyRepoCar = async (
 
 export const verifyRepo = async (
   blocks: BlockMap,
-  head: CID,
+  head: Cid,
   did?: string,
   signingKey?: string,
   opts?: { ensureLeaves?: boolean },
@@ -52,7 +52,7 @@ export const verifyDiffCar = async (
 export const verifyDiff = async (
   repo: ReadableRepo | null,
   updateBlocks: BlockMap,
-  updateRoot: CID,
+  updateRoot: Cid,
   did?: string,
   signingKey?: string,
   opts?: { ensureLeaves?: boolean },
@@ -103,7 +103,7 @@ export const verifyDiff = async (
 // @NOTE only verifies the root, not the repo contents
 const verifyRepoRoot = async (
   storage: ReadableBlockstore,
-  head: CID,
+  head: Cid,
   did?: string,
   signingKey?: string,
 ): Promise<ReadableRepo> => {
@@ -155,7 +155,7 @@ export const verifyProofs = async (
         unverified.push(claim)
       }
     } else {
-      if (claim.cid.equals(found)) {
+      if (found?.equals(claim.cid)) {
         verified.push(claim)
       } else {
         unverified.push(claim)