@atproto/repo 0.3.6 → 0.3.8

package/dist/mst/mst.d.ts

@@ -39,7 +39,7 @@ declare const nodeData: z.ZodObject<{
     }[];
     l?: any;
 }>;
-export declare type NodeData = z.infer<typeof nodeData>;
+export type NodeData = z.infer<typeof nodeData>;
 export declare const nodeDataDef: {
     name: string;
     schema: z.ZodObject<{
@@ -78,8 +78,8 @@ export declare const nodeDataDef: {
         l?: any;
     }>;
 };
-export declare type NodeEntry = MST | Leaf;
-export declare type MstOpts = {
+export type NodeEntry = MST | Leaf;
+export type MstOpts = {
     layer: number;
 };
 export declare class MST {

package/dist/mst/walker.d.ts

@@ -1,14 +1,14 @@
 import { MST, NodeEntry } from './mst';
-declare type WalkerStatusDone = {
+type WalkerStatusDone = {
     done: true;
 };
-declare type WalkerStatusProgress = {
+type WalkerStatusProgress = {
     done: false;
     curr: NodeEntry;
     walking: MST | null;
     index: number;
 };
-declare type WalkerStatus = WalkerStatusDone | WalkerStatusProgress;
+type WalkerStatus = WalkerStatusDone | WalkerStatusProgress;
 export declare class MstWalker {
     root: MST;
     stack: WalkerStatus[];

package/dist/readable-repo.d.ts

@@ -2,7 +2,8 @@ import { CID } from 'multiformats/cid';
 import { RepoContents, Commit } from './types';
 import { ReadableBlockstore } from './storage';
 import { MST } from './mst';
-declare type Params = {
+import { RepoRecord } from '@atproto/lexicon';
+type Params = {
     storage: ReadableBlockstore;
     data: MST;
     commit: Commit;
@@ -17,6 +18,12 @@ export declare class ReadableRepo {
     static load(storage: ReadableBlockstore, commitCid: CID): Promise<ReadableRepo>;
     get did(): string;
     get version(): number;
+    walkRecords(from?: string): AsyncIterable<{
+        collection: string;
+        rkey: string;
+        cid: CID;
+        record: RepoRecord;
+    }>;
     getRecord(collection: string, rkey: string): Promise<unknown | null>;
     getContents(): Promise<RepoContents>;
 }

package/dist/repo.d.ts

@@ -3,8 +3,10 @@ import * as crypto from '@atproto/crypto';
 import { Commit, CommitData, RecordCreateOp, RecordWriteOp } from './types';
 import { RepoStorage } from './storage';
 import { MST } from './mst';
+import BlockMap from './block-map';
 import { ReadableRepo } from './readable-repo';
-declare type Params = {
+import CidSet from './cid-set';
+type Params = {
     storage: RepoStorage;
     data: MST;
     commit: Commit;
@@ -20,5 +22,14 @@ export declare class Repo extends ReadableRepo {
     formatCommit(toWrite: RecordWriteOp | RecordWriteOp[], keypair: crypto.Keypair): Promise<CommitData>;
     applyCommit(commitData: CommitData): Promise<Repo>;
     applyWrites(toWrite: RecordWriteOp | RecordWriteOp[], keypair: crypto.Keypair): Promise<Repo>;
+    formatResignCommit(rev: string, keypair: crypto.Keypair): Promise<{
+        cid: CID;
+        rev: string;
+        since: null;
+        prev: null;
+        newBlocks: BlockMap;
+        removedCids: CidSet;
+    }>;
+    resignCommit(rev: string, keypair: crypto.Keypair): Promise<Repo>;
 }
 export default Repo;

package/dist/storage/memory-blockstore.d.ts

@@ -6,6 +6,7 @@ import { RepoStorage } from './types';
 export declare class MemoryBlockstore extends ReadableBlockstore implements RepoStorage {
     blocks: BlockMap;
     root: CID | null;
+    rev: string | null;
     constructor(blocks?: BlockMap);
     getRoot(): Promise<CID | null>;
     getBytes(cid: CID): Promise<Uint8Array | null>;
@@ -16,7 +17,7 @@ export declare class MemoryBlockstore extends ReadableBlockstore implements Repo
     }>;
     putBlock(cid: CID, block: Uint8Array): Promise<void>;
     putMany(blocks: BlockMap): Promise<void>;
-    updateRoot(cid: CID): Promise<void>;
+    updateRoot(cid: CID, rev: string): Promise<void>;
     applyCommit(commit: CommitData): Promise<void>;
     sizeInBytes(): Promise<number>;
     destroy(): Promise<void>;

package/dist/storage/types.d.ts

@@ -9,7 +9,7 @@ export interface RepoStorage {
     getRoot(): Promise<CID | null>;
     putBlock(cid: CID, block: Uint8Array, rev: string): Promise<void>;
     putMany(blocks: BlockMap, rev: string): Promise<void>;
-    updateRoot(cid: CID): Promise<void>;
+    updateRoot(cid: CID, rev: string): Promise<void>;
     applyCommit(commit: CommitData): any;
     getBytes(cid: CID): Promise<Uint8Array | null>;
     has(cid: CID): Promise<boolean>;
@@ -37,8 +37,10 @@ export interface BlobStore {
     unquarantine(cid: CID): Promise<void>;
     getBytes(cid: CID): Promise<Uint8Array>;
     getStream(cid: CID): Promise<stream.Readable>;
+    hasTemp(key: string): Promise<boolean>;
     hasStored(cid: CID): Promise<boolean>;
     delete(cid: CID): Promise<void>;
+    deleteMany(cid: CID[]): Promise<void>;
 }
 export declare class BlobNotFoundError extends Error {
 }

package/dist/sync/consumer.d.ts

@@ -3,9 +3,15 @@ import ReadableRepo from '../readable-repo';
 import { RecordClaim, VerifiedDiff, VerifiedRepo } from '../types';
 import BlockMap from '../block-map';
 export declare const verifyRepoCar: (carBytes: Uint8Array, did?: string, signingKey?: string) => Promise<VerifiedRepo>;
-export declare const verifyRepo: (blocks: BlockMap, head: CID, did?: string, signingKey?: string) => Promise<VerifiedRepo>;
-export declare const verifyDiffCar: (repo: ReadableRepo | null, carBytes: Uint8Array, did?: string, signingKey?: string) => Promise<VerifiedDiff>;
-export declare const verifyDiff: (repo: ReadableRepo | null, updateBlocks: BlockMap, updateRoot: CID, did?: string, signingKey?: string) => Promise<VerifiedDiff>;
+export declare const verifyRepo: (blocks: BlockMap, head: CID, did?: string, signingKey?: string, opts?: {
+    ensureLeaves?: boolean;
+}) => Promise<VerifiedRepo>;
+export declare const verifyDiffCar: (repo: ReadableRepo | null, carBytes: Uint8Array, did?: string, signingKey?: string, opts?: {
+    ensureLeaves?: boolean;
+}) => Promise<VerifiedDiff>;
+export declare const verifyDiff: (repo: ReadableRepo | null, updateBlocks: BlockMap, updateRoot: CID, did?: string, signingKey?: string, opts?: {
+    ensureLeaves?: boolean;
+}) => Promise<VerifiedDiff>;
 export declare const verifyProofs: (proofs: Uint8Array, claims: RecordClaim[], did: string, didKey: string) => Promise<{
     verified: RecordClaim[];
     unverified: RecordClaim[];

package/dist/sync/provider.d.ts

@@ -1,5 +1,5 @@
 import { RecordPath } from '../types';
 import { CID } from 'multiformats/cid';
-import { RepoStorage } from '../storage';
+import { ReadableBlockstore, RepoStorage } from '../storage';
 export declare const getFullRepo: (storage: RepoStorage, commitCid: CID) => AsyncIterable<Uint8Array>;
-export declare const getRecords: (storage: RepoStorage, commitCid: CID, paths: RecordPath[]) => AsyncIterable<Uint8Array>;
+export declare const getRecords: (storage: ReadableBlockstore, commitCid: CID, paths: RecordPath[]) => AsyncIterable<Uint8Array>;

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { CID } from 'multiformats';
+import * as car from '@ipld/car/api';
 import BlockMap from './block-map';
 import { RepoRecord } from '@atproto/lexicon';
 import CidSet from './cid-set';
@@ -8,13 +9,13 @@ declare const unsignedCommit: z.ZodObject<{
     version: z.ZodLiteral<3>;
     data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
     rev: z.ZodString;
-    prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
 }, "strip", z.ZodTypeAny, {
     did: string;
     data: CID;
     version: 3;
     rev: string;
-    prev?: CID | null | undefined;
+    prev: CID | null;
 }, {
     did: string;
     version: 3;
@@ -22,7 +23,7 @@ declare const unsignedCommit: z.ZodObject<{
     data?: any;
     prev?: any;
 }>;
-export declare type UnsignedCommit = z.infer<typeof unsignedCommit> & {
+export type UnsignedCommit = z.infer<typeof unsignedCommit> & {
     sig?: never;
 };
 declare const commit: z.ZodObject<{
@@ -30,15 +31,15 @@ declare const commit: z.ZodObject<{
     version: z.ZodLiteral<3>;
     data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
     rev: z.ZodString;
-    prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
     sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
 }, "strip", z.ZodTypeAny, {
     did: string;
     data: CID;
     version: 3;
     rev: string;
+    prev: CID | null;
     sig: Uint8Array;
-    prev?: CID | null | undefined;
 }, {
     did: string;
     version: 3;
@@ -47,7 +48,7 @@ declare const commit: z.ZodObject<{
     data?: any;
     prev?: any;
 }>;
-export declare type Commit = z.infer<typeof commit>;
+export type Commit = z.infer<typeof commit>;
 declare const legacyV2Commit: z.ZodObject<{
     did: z.ZodString;
     version: z.ZodLiteral<2>;
@@ -70,21 +71,21 @@ declare const legacyV2Commit: z.ZodObject<{
     rev?: string | undefined;
     prev?: any;
 }>;
-export declare type LegacyV2Commit = z.infer<typeof legacyV2Commit>;
+export type LegacyV2Commit = z.infer<typeof legacyV2Commit>;
 declare const versionedCommit: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
     did: z.ZodString;
     version: z.ZodLiteral<3>;
     data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
     rev: z.ZodString;
-    prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+    prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
     sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
 }, "strip", z.ZodTypeAny, {
     did: string;
     data: CID;
     version: 3;
     rev: string;
+    prev: CID | null;
     sig: Uint8Array;
-    prev?: CID | null | undefined;
 }, {
     did: string;
     version: 3;
@@ -114,22 +115,22 @@ declare const versionedCommit: z.ZodDiscriminatedUnion<"version", [z.ZodObject<{
     rev?: string | undefined;
     prev?: any;
 }>]>;
-export declare type VersionedCommit = z.infer<typeof versionedCommit>;
+export type VersionedCommit = z.infer<typeof versionedCommit>;
 export declare const schema: {
     commit: z.ZodObject<{
         did: z.ZodString;
         version: z.ZodLiteral<3>;
         data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
         rev: z.ZodString;
-        prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
         sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
     }, "strip", z.ZodTypeAny, {
         did: string;
         data: CID;
         version: 3;
         rev: string;
+        prev: CID | null;
         sig: Uint8Array;
-        prev?: CID | null | undefined;
     }, {
         did: string;
         version: 3;
@@ -165,15 +166,15 @@ export declare const schema: {
         version: z.ZodLiteral<3>;
         data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
         rev: z.ZodString;
-        prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+        prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
         sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
     }, "strip", z.ZodTypeAny, {
         did: string;
         data: CID;
         version: 3;
         rev: string;
+        prev: CID | null;
         sig: Uint8Array;
-        prev?: CID | null | undefined;
     }, {
         did: string;
         version: 3;
@@ -218,15 +219,15 @@ export declare const def: {
             version: z.ZodLiteral<3>;
             data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
             rev: z.ZodString;
-            prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+            prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
             sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
         }, "strip", z.ZodTypeAny, {
             did: string;
             data: CID;
             version: 3;
             rev: string;
+            prev: CID | null;
             sig: Uint8Array;
-            prev?: CID | null | undefined;
         }, {
             did: string;
             version: 3;
@@ -243,15 +244,15 @@ export declare const def: {
             version: z.ZodLiteral<3>;
             data: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
             rev: z.ZodString;
-            prev: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>>;
+            prev: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
             sig: z.ZodType<Uint8Array, z.ZodTypeDef, Uint8Array>;
         }, "strip", z.ZodTypeAny, {
             did: string;
             data: CID;
             version: 3;
             rev: string;
+            prev: CID | null;
             sig: Uint8Array;
-            prev?: CID | null | undefined;
         }, {
             did: string;
             version: 3;
@@ -293,37 +294,46 @@ export declare enum WriteOpAction {
     Update = "update",
     Delete = "delete"
 }
-export declare type RecordCreateOp = {
+export type RecordCreateOp = {
     action: WriteOpAction.Create;
     collection: string;
     rkey: string;
     record: RepoRecord;
 };
-export declare type RecordUpdateOp = {
+export type RecordUpdateOp = {
     action: WriteOpAction.Update;
     collection: string;
     rkey: string;
     record: RepoRecord;
 };
-export declare type RecordDeleteOp = {
+export type RecordDeleteOp = {
     action: WriteOpAction.Delete;
     collection: string;
     rkey: string;
 };
-export declare type RecordWriteOp = RecordCreateOp | RecordUpdateOp | RecordDeleteOp;
-export declare type RecordCreateDescript = RecordCreateOp & {
+export type RecordWriteOp = RecordCreateOp | RecordUpdateOp | RecordDeleteOp;
+export type RecordCreateDescript = {
+    action: WriteOpAction.Create;
+    collection: string;
+    rkey: string;
     cid: CID;
 };
-export declare type RecordUpdateDescript = RecordUpdateOp & {
+export type RecordUpdateDescript = {
+    action: WriteOpAction.Update;
+    collection: string;
+    rkey: string;
     prev: CID;
     cid: CID;
 };
-export declare type RecordDeleteDescript = RecordDeleteOp & {
+export type RecordDeleteDescript = {
+    action: WriteOpAction.Delete;
+    collection: string;
+    rkey: string;
     cid: CID;
 };
-export declare type RecordWriteDescript = RecordCreateDescript | RecordUpdateDescript | RecordDeleteDescript;
-export declare type WriteLog = RecordWriteDescript[][];
-export declare type CommitData = {
+export type RecordWriteDescript = RecordCreateDescript | RecordUpdateDescript | RecordDeleteDescript;
+export type WriteLog = RecordWriteDescript[][];
+export type CommitData = {
     cid: CID;
     rev: string;
     since: string | null;
@@ -331,33 +341,34 @@ export declare type CommitData = {
     newBlocks: BlockMap;
     removedCids: CidSet;
 };
-export declare type RepoUpdate = CommitData & {
+export type RepoUpdate = CommitData & {
     ops: RecordWriteOp[];
 };
-export declare type CollectionContents = Record<string, RepoRecord>;
-export declare type RepoContents = Record<string, CollectionContents>;
-export declare type RepoRecordWithCid = {
+export type CollectionContents = Record<string, RepoRecord>;
+export type RepoContents = Record<string, CollectionContents>;
+export type RepoRecordWithCid = {
     cid: CID;
     value: RepoRecord;
 };
-export declare type CollectionContentsWithCids = Record<string, RepoRecordWithCid>;
-export declare type RepoContentsWithCids = Record<string, CollectionContentsWithCids>;
-export declare type DatastoreContents = Record<string, CID>;
-export declare type RecordPath = {
+export type CollectionContentsWithCids = Record<string, RepoRecordWithCid>;
+export type RepoContentsWithCids = Record<string, CollectionContentsWithCids>;
+export type DatastoreContents = Record<string, CID>;
+export type RecordPath = {
     collection: string;
     rkey: string;
 };
-export declare type RecordClaim = {
+export type RecordClaim = {
     collection: string;
     rkey: string;
     record: RepoRecord | null;
 };
-export declare type VerifiedDiff = {
+export type VerifiedDiff = {
     writes: RecordWriteDescript[];
     commit: CommitData;
 };
-export declare type VerifiedRepo = {
+export type VerifiedRepo = {
     creates: RecordCreateDescript[];
     commit: CommitData;
 };
+export type CarBlock = car.Block;
 export {};

package/dist/util.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import { CID } from 'multiformats/cid';
+import { CarBlockIterator } from '@ipld/car';
 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 { Commit, LegacyV2Commit, RecordCreateDescript, RecordPath, RecordWriteDescript, UnsignedCommit } from './types';
+import { CarBlock, Commit, LegacyV2Commit, RecordCreateDescript, RecordPath, RecordWriteDescript, UnsignedCommit } from './types';
 import BlockMap from './block-map';
 import { Keypair } from '@atproto/crypto';
 import { Readable } from 'stream';
@@ -13,15 +13,23 @@ export declare function writeCarStream(root: CID | null, fn: (car: BlockWriter)
 export declare function writeCar(root: CID | null, fn: (car: BlockWriter) => Promise<void>): AsyncIterable<Uint8Array>;
 export declare const blocksToCarStream: (root: CID | null, blocks: BlockMap) => AsyncIterable<Uint8Array>;
 export declare const blocksToCarFile: (root: CID | null, blocks: BlockMap) => Promise<Uint8Array>;
+export declare const carToBlocks: (car: CarBlockIterator) => Promise<{
+    roots: CID[];
+    blocks: BlockMap;
+}>;
 export declare const readCar: (bytes: Uint8Array) => Promise<{
     roots: CID[];
     blocks: BlockMap;
 }>;
+export declare const readCarStream: (stream: AsyncIterable<Uint8Array>) => Promise<{
+    roots: CID[];
+    blocks: BlockMap;
+}>;
 export declare const readCarWithRoot: (bytes: Uint8Array) => Promise<{
     root: CID;
     blocks: BlockMap;
 }>;
-export declare const diffToWriteDescripts: (diff: DataDiff, blocks: BlockMap) => Promise<RecordWriteDescript[]>;
+export declare const diffToWriteDescripts: (diff: DataDiff) => Promise<RecordWriteDescript[]>;
 export declare const ensureCreates: (descripts: RecordWriteDescript[]) => RecordCreateDescript[];
 export declare const parseDataKey: (key: string) => RecordPath;
 export declare const formatDataKey: (collection: string, rkey: string) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/repo",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "license": "MIT",
   "description": "atproto repo and MST implementation",
   "keywords": [
@@ -24,8 +24,8 @@
     "@atproto/common-web": "^0.2.3",
     "@atproto/crypto": "^0.3.0",
     "@atproto/identity": "^0.3.2",
-    "@atproto/lexicon": "^0.3.1",
-    "@atproto/syntax": "^0.1.5"
+    "@atproto/lexicon": "^0.3.2",
+    "@atproto/syntax": "^0.2.0"
   },
   "scripts": {
     "test": "jest",

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './block-map'
 export * from './cid-set'
 export * from './repo'
 export * from './mst'
+export * from './parse'
 export * from './storage'
 export * from './sync'
 export * from './types'

package/src/readable-repo.ts

@@ -6,6 +6,7 @@ import log from './logger'
 import * as util from './util'
 import * as parse from './parse'
 import { MissingBlocksError } from './error'
+import { RepoRecord } from '@atproto/lexicon'
 
 type Params = {
   storage: ReadableBlockstore
@@ -47,6 +48,19 @@ export class ReadableRepo {
     return this.commit.version
   }
 
+  async *walkRecords(from?: string): AsyncIterable<{
+    collection: string
+    rkey: string
+    cid: CID
+    record: RepoRecord
+  }> {
+    for await (const leaf of this.data.walkLeavesFrom(from ?? '')) {
+      const { collection, rkey } = util.parseDataKey(leaf.key)
+      const record = await this.storage.readRecord(leaf.value)
+      yield { collection, rkey, cid: leaf.value, record }
+    }
+  }
+
   async getRecord(collection: string, rkey: string): Promise<unknown | null> {
     const dataKey = collection + '/' + rkey
     const cid = await this.data.get(dataKey)

package/src/repo.ts

@@ -16,6 +16,7 @@ import log from './logger'
 import BlockMap from './block-map'
 import { ReadableRepo } from './readable-repo'
 import * as util from './util'
+import CidSet from './cid-set'
 
 type Params = {
   storage: RepoStorage
@@ -187,6 +188,34 @@ export class Repo extends ReadableRepo {
     const commit = await this.formatCommit(toWrite, keypair)
     return this.applyCommit(commit)
   }
+
+  async formatResignCommit(rev: string, keypair: crypto.Keypair) {
+    const commit = await util.signCommit(
+      {
+        did: this.did,
+        version: 3,
+        rev,
+        prev: null, // added for backwards compatibility with v2
+        data: this.commit.data,
+      },
+      keypair,
+    )
+    const newBlocks = new BlockMap()
+    const commitCid = await newBlocks.add(commit)
+    return {
+      cid: commitCid,
+      rev,
+      since: null,
+      prev: null,
+      newBlocks,
+      removedCids: new CidSet([this.cid]),
+    }
+  }
+
+  async resignCommit(rev: string, keypair: crypto.Keypair) {
+    const formatted = await this.formatResignCommit(rev, keypair)
+    return this.applyCommit(formatted)
+  }
 }
 
 export default Repo

package/src/storage/memory-blockstore.ts

@@ -10,6 +10,7 @@ export class MemoryBlockstore
 {
   blocks: BlockMap
   root: CID | null = null
+  rev: string | null = null
 
   constructor(blocks?: BlockMap) {
     super()
@@ -43,8 +44,9 @@ export class MemoryBlockstore
     this.blocks.addMap(blocks)
   }
 
-  async updateRoot(cid: CID): Promise<void> {
+  async updateRoot(cid: CID, rev: string): Promise<void> {
     this.root = cid
+    this.rev = rev
   }
 
   async applyCommit(commit: CommitData): Promise<void> {

package/src/storage/types.ts

@@ -10,7 +10,7 @@ export interface RepoStorage {
   getRoot(): Promise<CID | null>
   putBlock(cid: CID, block: Uint8Array, rev: string): Promise<void>
   putMany(blocks: BlockMap, rev: string): Promise<void>
-  updateRoot(cid: CID): Promise<void>
+  updateRoot(cid: CID, rev: string): Promise<void>
   applyCommit(commit: CommitData)
 
   // Readable
@@ -38,8 +38,10 @@ export interface BlobStore {
   unquarantine(cid: CID): Promise<void>
   getBytes(cid: CID): Promise<Uint8Array>
   getStream(cid: CID): Promise<stream.Readable>
+  hasTemp(key: string): Promise<boolean>
   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

@@ -23,8 +23,9 @@ export const verifyRepo = async (
   head: CID,
   did?: string,
   signingKey?: string,
+  opts?: { ensureLeaves?: boolean },
 ): Promise<VerifiedRepo> => {
-  const diff = await verifyDiff(null, blocks, head, did, signingKey)
+  const diff = await verifyDiff(null, blocks, head, did, signingKey, opts)
   const creates = util.ensureCreates(diff.writes)
   return {
     creates,
@@ -37,9 +38,10 @@ export const verifyDiffCar = async (
   carBytes: Uint8Array,
   did?: string,
   signingKey?: string,
+  opts?: { ensureLeaves?: boolean },
 ): Promise<VerifiedDiff> => {
   const car = await util.readCarWithRoot(carBytes)
-  return verifyDiff(repo, car.blocks, car.root, did, signingKey)
+  return verifyDiff(repo, car.blocks, car.root, did, signingKey, opts)
 }
 
 export const verifyDiff = async (
@@ -48,7 +50,9 @@ export const verifyDiff = async (
   updateRoot: CID,
   did?: string,
   signingKey?: string,
+  opts?: { ensureLeaves?: boolean },
 ): Promise<VerifiedDiff> => {
+  const { ensureLeaves = true } = opts ?? {}
   const stagedStorage = new MemoryBlockstore(updateBlocks)
   const updateStorage = repo
     ? new SyncStorage(stagedStorage, repo.storage)
@@ -60,10 +64,10 @@ export const verifyDiff = async (
     signingKey,
   )
   const diff = await DataDiff.of(updated.data, repo?.data ?? null)
-  const writes = await util.diffToWriteDescripts(diff, updateBlocks)
+  const writes = await util.diffToWriteDescripts(diff)
   const newBlocks = diff.newMstBlocks
   const leaves = updateBlocks.getMany(diff.newLeafCids.toList())
-  if (leaves.missing.length > 0) {
+  if (leaves.missing.length > 0 && ensureLeaves) {
     throw new Error(`missing leaf blocks: ${leaves.missing}`)
   }
   newBlocks.addMap(leaves.blocks)

package/src/sync/provider.ts

@@ -3,7 +3,7 @@ import { BlockWriter } from '@ipld/car/writer'
 import { CID } from 'multiformats/cid'
 import CidSet from '../cid-set'
 import { MissingBlocksError } from '../error'
-import { RepoStorage } from '../storage'
+import { ReadableBlockstore, RepoStorage } from '../storage'
 import * as util from '../util'
 import { MST } from '../mst'
 
@@ -26,7 +26,7 @@ export const getFullRepo = (
 // -------------
 
 export const getRecords = (
-  storage: RepoStorage,
+  storage: ReadableBlockstore,
   commitCid: CID,
   paths: RecordPath[],
 ): AsyncIterable<Uint8Array> => {