@atproto/repo 0.0.1 → 0.1.0

package/dist/types.d.ts

@@ -1,355 +1,159 @@
 import { z } from 'zod';
 import { BlockWriter } from '@ipld/car/writer';
 import { CID } from 'multiformats';
-import { DataDiff } from './mst';
-declare const repoMeta: z.ZodObject<{
+import BlockMap from './block-map';
+import { RepoRecord } from '@atproto/lexicon';
+declare const unsignedCommit: z.ZodObject<{
     did: z.ZodString;
     version: z.ZodNumber;
-    datastore: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    version: number;
-    did: string;
-    datastore: string;
-}, {
-    version: number;
-    did: string;
-    datastore: string;
-}>;
-export declare type RepoMeta = z.infer<typeof repoMeta>;
-declare const repoRoot: z.ZodObject<{
-    meta: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
     prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
-    auth_token: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
     data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
 }, "strip", z.ZodTypeAny, {
     data: CID;
-    meta: CID;
+    did: string;
+    version: number;
     prev: CID | null;
-    auth_token: CID | null;
 }, {
     data?: any;
-    meta?: any;
     prev?: any;
-    auth_token?: any;
+    did: string;
+    version: number;
 }>;
-export declare type RepoRoot = z.infer<typeof repoRoot>;
+export declare type UnsignedCommit = z.infer<typeof unsignedCommit> & {
+    sig?: never;
+};
 declare const commit: z.ZodObject<{
-    root: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+    did: z.ZodString;
+    version: z.ZodNumber;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
     sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
 }, "strip", z.ZodTypeAny, {
-    root: CID;
+    data: CID;
+    did: string;
+    version: number;
+    prev: CID | null;
     sig: Uint8Array;
 }, {
-    root?: any;
+    data?: any;
+    prev?: any;
+    did: string;
+    version: number;
     sig: Uint8Array;
 }>;
 export declare type Commit = z.infer<typeof commit>;
-export declare const cidCreateOp: z.ZodObject<{
-    action: z.ZodLiteral<"create">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "create";
-    rkey: string;
-    cid: CID;
-}, {
-    cid?: any;
-    collection: string;
-    action: "create";
-    rkey: string;
-}>;
-export declare type CidCreateOp = z.infer<typeof cidCreateOp>;
-export declare const cidUpdateOp: z.ZodObject<{
-    action: z.ZodLiteral<"update">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "update";
-    rkey: string;
-    cid: CID;
-}, {
-    cid?: any;
-    collection: string;
-    action: "update";
-    rkey: string;
-}>;
-export declare type CidUpdateOp = z.infer<typeof cidUpdateOp>;
-export declare const deleteOp: z.ZodObject<{
-    action: z.ZodLiteral<"delete">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "delete";
-    rkey: string;
-}, {
-    collection: string;
-    action: "delete";
-    rkey: string;
-}>;
-export declare type DeleteOp = z.infer<typeof deleteOp>;
-export declare const cidWriteOp: z.ZodUnion<[z.ZodObject<{
-    action: z.ZodLiteral<"create">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "create";
-    rkey: string;
-    cid: CID;
-}, {
-    cid?: any;
-    collection: string;
-    action: "create";
-    rkey: string;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"update">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "update";
-    rkey: string;
-    cid: CID;
-}, {
-    cid?: any;
-    collection: string;
-    action: "update";
-    rkey: string;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"delete">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "delete";
-    rkey: string;
-}, {
-    collection: string;
-    action: "delete";
-    rkey: string;
-}>]>;
-export declare type CidWriteOp = z.infer<typeof cidWriteOp>;
-export declare const recordCreateOp: z.ZodObject<{
-    action: z.ZodLiteral<"create">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    value?: any;
-    collection: string;
-    action: "create";
-    rkey: string;
-}, {
-    value?: any;
-    collection: string;
-    action: "create";
-    rkey: string;
-}>;
-export declare type RecordCreateOp = z.infer<typeof recordCreateOp>;
-export declare const recordUpdateOp: z.ZodObject<{
-    action: z.ZodLiteral<"update">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    value?: any;
-    collection: string;
-    action: "update";
-    rkey: string;
-}, {
-    value?: any;
-    collection: string;
-    action: "update";
-    rkey: string;
-}>;
-export declare type RecordUpdateOp = z.infer<typeof recordUpdateOp>;
-export declare const recordWriteOp: z.ZodUnion<[z.ZodObject<{
-    action: z.ZodLiteral<"create">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    value?: any;
-    collection: string;
-    action: "create";
-    rkey: string;
-}, {
-    value?: any;
-    collection: string;
-    action: "create";
-    rkey: string;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"update">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-    value: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    value?: any;
-    collection: string;
-    action: "update";
-    rkey: string;
-}, {
-    value?: any;
-    collection: string;
-    action: "update";
-    rkey: string;
-}>, z.ZodObject<{
-    action: z.ZodLiteral<"delete">;
-    collection: z.ZodString;
-    rkey: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    collection: string;
-    action: "delete";
-    rkey: string;
-}, {
-    collection: string;
-    action: "delete";
-    rkey: string;
-}>]>;
-export declare type RecordWriteOp = z.infer<typeof recordWriteOp>;
-export declare const def: {
-    repoMeta: z.ZodObject<{
+export declare const schema: {
+    commit: z.ZodObject<{
         did: z.ZodString;
         version: z.ZodNumber;
-        datastore: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        version: number;
-        did: string;
-        datastore: string;
-    }, {
-        version: number;
-        did: string;
-        datastore: string;
-    }>;
-    repoRoot: z.ZodObject<{
-        meta: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
         prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
-        auth_token: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
         data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
     }, "strip", z.ZodTypeAny, {
         data: CID;
-        meta: CID;
+        did: string;
+        version: number;
         prev: CID | null;
-        auth_token: CID | null;
+        sig: Uint8Array;
     }, {
         data?: any;
-        meta?: any;
         prev?: any;
-        auth_token?: any;
-    }>;
-    commit: z.ZodObject<{
-        root: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-        sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
-    }, "strip", z.ZodTypeAny, {
-        root: CID;
-        sig: Uint8Array;
-    }, {
-        root?: any;
+        did: string;
+        version: number;
         sig: Uint8Array;
     }>;
-    cidWriteOp: z.ZodUnion<[z.ZodObject<{
-        action: z.ZodLiteral<"create">;
-        collection: z.ZodString;
-        rkey: z.ZodString;
-        cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-    }, "strip", z.ZodTypeAny, {
-        collection: string;
-        action: "create";
-        rkey: string;
-        cid: CID;
-    }, {
-        cid?: any;
-        collection: string;
-        action: "create";
-        rkey: string;
-    }>, z.ZodObject<{
-        action: z.ZodLiteral<"update">;
-        collection: z.ZodString;
-        rkey: z.ZodString;
-        cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-    }, "strip", z.ZodTypeAny, {
-        collection: string;
-        action: "update";
-        rkey: string;
-        cid: CID;
-    }, {
-        cid?: any;
-        collection: string;
-        action: "update";
-        rkey: string;
-    }>, z.ZodObject<{
-        action: z.ZodLiteral<"delete">;
-        collection: z.ZodString;
-        rkey: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        collection: string;
-        action: "delete";
-        rkey: string;
-    }, {
-        collection: string;
-        action: "delete";
-        rkey: string;
-    }>]>;
-    recordWriteOp: z.ZodUnion<[z.ZodObject<{
-        action: z.ZodLiteral<"create">;
-        collection: z.ZodString;
-        rkey: z.ZodString;
-        value: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        value?: any;
-        collection: string;
-        action: "create";
-        rkey: string;
-    }, {
-        value?: any;
-        collection: string;
-        action: "create";
-        rkey: string;
-    }>, z.ZodObject<{
-        action: z.ZodLiteral<"update">;
-        collection: z.ZodString;
-        rkey: z.ZodString;
-        value: z.ZodAny;
-    }, "strip", z.ZodTypeAny, {
-        value?: any;
-        collection: string;
-        action: "update";
-        rkey: string;
-    }, {
-        value?: any;
-        collection: string;
-        action: "update";
-        rkey: string;
-    }>, z.ZodObject<{
-        action: z.ZodLiteral<"delete">;
-        collection: z.ZodString;
-        rkey: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        collection: string;
-        action: "delete";
-        rkey: string;
-    }, {
-        collection: string;
-        action: "delete";
-        rkey: string;
-    }>]>;
-    string: z.ZodString;
     cid: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
-    strToCid: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, CID, string>;
     bytes: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
-    strToInt: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, number, string>;
-    strToBool: z.ZodEffects<z.ZodString, boolean, string>;
+    string: z.ZodString;
+    array: z.ZodArray<z.ZodUnknown, "many">;
+    map: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    unknown: z.ZodUnknown;
 };
-export interface CarStreamable {
-    writeToCarStream(car: BlockWriter): Promise<void>;
+export declare const def: {
+    commit: {
+        name: string;
+        schema: z.ZodObject<{
+            did: z.ZodString;
+            version: z.ZodNumber;
+            prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+            data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+            sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
+        }, "strip", z.ZodTypeAny, {
+            data: CID;
+            did: string;
+            version: number;
+            prev: CID | null;
+            sig: Uint8Array;
+        }, {
+            data?: any;
+            prev?: any;
+            did: string;
+            version: number;
+            sig: Uint8Array;
+        }>;
+    };
+    cid: import("@atproto/common-web/src/check").Def<CID>;
+    bytes: import("@atproto/common-web/src/check").Def<Uint8Array>;
+    string: import("@atproto/common-web/src/check").Def<string>;
+    map: import("@atproto/common-web/src/check").Def<Record<string, unknown>>;
+    unknown: import("@atproto/common-web/src/check").Def<unknown>;
+};
+export declare enum WriteOpAction {
+    Create = "create",
+    Update = "update",
+    Delete = "delete"
 }
+export declare type RecordCreateOp = {
+    action: WriteOpAction.Create;
+    collection: string;
+    rkey: string;
+    record: RepoRecord;
+};
+export declare type RecordUpdateOp = {
+    action: WriteOpAction.Update;
+    collection: string;
+    rkey: string;
+    record: RepoRecord;
+};
+export declare type RecordDeleteOp = {
+    action: WriteOpAction.Delete;
+    collection: string;
+    rkey: string;
+};
+export declare type RecordWriteOp = RecordCreateOp | RecordUpdateOp | RecordDeleteOp;
+export declare type RecordCreateDescript = RecordCreateOp & {
+    cid: CID;
+};
+export declare type RecordUpdateDescript = RecordUpdateOp & {
+    prev: CID;
+    cid: CID;
+};
+export declare type RecordDeleteDescript = RecordDeleteOp & {
+    cid: CID;
+};
+export declare type RecordWriteDescript = RecordCreateDescript | RecordUpdateDescript | RecordDeleteDescript;
+export declare type WriteLog = RecordWriteDescript[][];
+export declare type CommitBlockData = {
+    commit: CID;
+    blocks: BlockMap;
+};
+export declare type CommitData = CommitBlockData & {
+    prev: CID | null;
+};
+export declare type RepoUpdate = CommitData & {
+    ops: RecordWriteOp[];
+};
+export declare type CollectionContents = Record<string, RepoRecord>;
+export declare type RepoContents = Record<string, CollectionContents>;
+export declare type RecordPath = {
+    collection: string;
+    rkey: string;
+};
+export declare type RecordClaim = {
+    collection: string;
+    rkey: string;
+    record: RepoRecord | null;
+};
 export declare type DataValue = {
     key: string;
     value: CID;
@@ -359,10 +163,13 @@ export interface DataStore {
     update(key: string, value: CID): Promise<DataStore>;
     delete(key: string): Promise<DataStore>;
     get(key: string): Promise<CID | null>;
-    list(count: number, after?: string, before?: string): Promise<DataValue[]>;
+    list(count?: number, after?: string, before?: string): Promise<DataValue[]>;
     listWithPrefix(prefix: string, count?: number): Promise<DataValue[]>;
-    diff(other: DataStore): Promise<DataDiff>;
-    stage(): Promise<CID>;
+    getUnstoredBlocks(): Promise<{
+        root: CID;
+        blocks: BlockMap;
+    }>;
     writeToCarStream(car: BlockWriter): Promise<void>;
+    cidsForPath(key: string): Promise<CID[]>;
 }
 export {};

package/dist/util.d.ts

@@ -1,13 +1,32 @@
 import { CID } from 'multiformats/cid';
-import * as auth from '@atproto/auth';
-import { DataDiff } from './mst';
-import { IpldStore } from './blockstore';
-import { DataStore, RecordWriteOp } from './types';
-export declare const ucanForOperation: (prevData: DataStore, newData: DataStore, rootDid: string, authStore: auth.AuthStore) => Promise<string>;
-export declare const getCommitPath: (blockstore: IpldStore, earliest: CID | null, latest: CID) => Promise<CID[] | null>;
-export declare const getWriteOpLog: (blockstore: IpldStore, earliest: CID | null, latest: CID) => Promise<RecordWriteOp[][]>;
-export declare const diffToWriteOps: (blockstore: IpldStore, diff: DataDiff) => Promise<RecordWriteOp[]>;
-export declare const parseRecordKey: (key: string) => {
-    collection: string;
-    rkey: string;
-};
+import { BlockWriter } from '@ipld/car/writer';
+import { Block as CarBlock } from '@ipld/car/api';
+import { LexValue, RepoRecord } from '@atproto/lexicon';
+import DataDiff from './data-diff';
+import { RepoStorage } from './storage';
+import { Commit, RecordPath, RecordWriteDescript, UnsignedCommit, WriteLog } from './types';
+import BlockMap from './block-map';
+import { Keypair } from '@atproto/crypto';
+export declare function verifyIncomingCarBlocks(car: AsyncIterable<CarBlock>): AsyncIterable<CarBlock>;
+export declare const writeCar: (root: CID | null, fn: (car: BlockWriter) => Promise<void>) => Promise<Uint8Array>;
+export declare const blocksToCar: (root: CID | null, blocks: BlockMap) => Promise<Uint8Array>;
+export declare const readCar: (bytes: Uint8Array) => Promise<{
+    roots: CID[];
+    blocks: BlockMap;
+}>;
+export declare const readCarWithRoot: (bytes: Uint8Array) => Promise<{
+    root: CID;
+    blocks: BlockMap;
+}>;
+export declare const getWriteLog: (storage: RepoStorage, latest: CID, earliest: CID | null) => Promise<WriteLog>;
+export declare const diffToWriteDescripts: (diff: DataDiff, blocks: BlockMap) => Promise<RecordWriteDescript[]>;
+export declare const collapseWriteLog: (log: WriteLog) => RecordWriteDescript[];
+export declare const collapseDiffs: (diffs: DataDiff[]) => DataDiff;
+export declare const parseDataKey: (key: string) => RecordPath;
+export declare const formatDataKey: (collection: string, rkey: string) => string;
+export declare const metaEqual: (a: Commit, b: Commit) => boolean;
+export declare const signCommit: (unsigned: UnsignedCommit, keypair: Keypair) => Promise<Commit>;
+export declare const verifyCommitSig: (commit: Commit, didKey: string) => Promise<boolean>;
+export declare const cborToLex: (val: Uint8Array) => LexValue;
+export declare const cborToLexRecord: (val: Uint8Array) => RepoRecord;
+export declare const cidForRecord: (val: LexValue) => Promise<CID>;

package/dist/verify.d.ts

@@ -1,5 +1,27 @@
 import { CID } from 'multiformats/cid';
-import * as auth from '@atproto/auth';
-import { IpldStore } from './blockstore';
-import { DataDiff } from './mst';
-export declare const verifyUpdates: (blockstore: IpldStore, earliest: CID | null, latest: CID, verifier: auth.Verifier) => Promise<DataDiff>;
+import { ReadableBlockstore, RepoStorage } from './storage';
+import DataDiff from './data-diff';
+import ReadableRepo from './readable-repo';
+import CidSet from './cid-set';
+import { RecordClaim, RepoContents } from './types';
+export declare type VerifiedCheckout = {
+    contents: RepoContents;
+    newCids: CidSet;
+};
+export declare const verifyCheckout: (storage: ReadableBlockstore, head: CID, did: string, signingKey: string) => Promise<VerifiedCheckout>;
+export declare type VerifiedUpdate = {
+    commit: CID;
+    prev: CID | null;
+    diff: DataDiff;
+    newCids: CidSet;
+};
+export declare const verifyFullHistory: (storage: RepoStorage, head: CID, did: string, signingKey: string) => Promise<VerifiedUpdate[]>;
+export declare const verifyUpdates: (repo: ReadableRepo, updateStorage: RepoStorage, updateRoot: CID, did: string, signingKey: string) => Promise<VerifiedUpdate[]>;
+export declare const verifyCommitPath: (baseRepo: ReadableRepo, storage: ReadableBlockstore, commitPath: CID[], did: string, signingKey: string) => Promise<VerifiedUpdate[]>;
+export declare const verifyProofs: (proofs: Uint8Array, claims: RecordClaim[], did: string, didKey: string) => Promise<{
+    verified: RecordClaim[];
+    unverified: RecordClaim[];
+}>;
+export declare const verifyRecords: (proofs: Uint8Array, did: string, signingKey: string) => Promise<RecordClaim[]>;
+export declare class RepoVerificationError extends Error {
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/repo",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "license": "MIT",
   "scripts": {
@@ -22,8 +22,10 @@
     "postpublish": "npm run update-main-to-src"
   },
   "dependencies": {
-    "@atproto/auth": "*",
     "@atproto/common": "*",
+    "@atproto/crypto": "*",
+    "@atproto/did-resolver": "*",
+    "@atproto/lexicon": "*",
     "@atproto/nsid": "*",
     "@ipld/car": "^3.2.3",
     "@ipld/dag-cbor": "^7.0.0",

package/src/block-map.ts

@@ -0,0 +1,95 @@
+import { lexToIpld, LexValue } from '@atproto/lexicon'
+import { dataToCborBlock } from '@atproto/common'
+import { CID } from 'multiformats/cid'
+import * as uint8arrays from 'uint8arrays'
+
+export class BlockMap {
+  private map: Map<string, Uint8Array> = new Map()
+
+  async add(value: LexValue): Promise<CID> {
+    const block = await dataToCborBlock(lexToIpld(value))
+    this.set(block.cid, block.bytes)
+    return block.cid
+  }
+
+  set(cid: CID, bytes: Uint8Array) {
+    this.map.set(cid.toString(), bytes)
+  }
+
+  get(cid: CID): Uint8Array | undefined {
+    return this.map.get(cid.toString())
+  }
+
+  getMany(cids: CID[]): { blocks: BlockMap; missing: CID[] } {
+    const missing: CID[] = []
+    const blocks = new BlockMap()
+    for (const cid of cids) {
+      const got = this.map.get(cid.toString())
+      if (got) {
+        blocks.set(cid, got)
+      } else {
+        missing.push(cid)
+      }
+    }
+    return { blocks, missing }
+  }
+
+  has(cid: CID): boolean {
+    return this.map.has(cid.toString())
+  }
+
+  clear(): void {
+    this.map.clear()
+  }
+
+  forEach(cb: (bytes: Uint8Array, cid: CID) => void): void {
+    this.map.forEach((val, key) => cb(val, CID.parse(key)))
+  }
+
+  entries(): Entry[] {
+    const entries: Entry[] = []
+    this.forEach((bytes, cid) => {
+      entries.push({ cid, bytes })
+    })
+    return entries
+  }
+
+  addMap(toAdd: BlockMap) {
+    toAdd.forEach((bytes, cid) => {
+      this.set(cid, bytes)
+    })
+  }
+
+  get size(): number {
+    return this.map.size
+  }
+
+  get byteSize(): number {
+    let size = 0
+    this.forEach((bytes) => {
+      size += bytes.length
+    })
+    return size
+  }
+
+  equals(other: BlockMap): boolean {
+    if (this.size !== other.size) {
+      return false
+    }
+    for (const entry of this.entries()) {
+      const otherBytes = other.get(entry.cid)
+      if (!otherBytes) return false
+      if (!uint8arrays.equals(entry.bytes, otherBytes)) {
+        return false
+      }
+    }
+    return true
+  }
+}
+
+type Entry = {
+  cid: CID
+  bytes: Uint8Array
+}
+
+export default BlockMap

package/src/cid-set.ts

@@ -42,8 +42,7 @@ export class CidSet {
   }
 
   toList(): CID[] {
-    const arr = [...this.set]
-    return arr.map((c) => CID.parse(c))
+    return [...this.set].map((c) => CID.parse(c))
   }
 }