@atproto/repo 0.1.0 → 0.2.0

package/dist/mst/mst.d.ts

@@ -1,7 +1,6 @@
 import z from 'zod';
 import { CID } from 'multiformats';
 import { ReadableBlockstore } from '../storage';
-import { DataStore } from '../types';
 import { BlockWriter } from '@ipld/car/api';
 import BlockMap from '../block-map';
 import CidSet from '../cid-set';
@@ -18,27 +17,27 @@ declare const nodeData: z.ZodObject<{
         v: CID;
         t: CID | null;
     }, {
-        v?: any;
-        t?: any;
         p: number;
         k: Uint8Array;
+        v?: any;
+        t?: any;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    l: CID | null;
     e: {
         p: number;
         k: Uint8Array;
         v: CID;
         t: CID | null;
     }[];
+    l: CID | null;
 }, {
-    l?: any;
     e: {
-        v?: any;
-        t?: any;
         p: number;
         k: Uint8Array;
+        v?: any;
+        t?: any;
     }[];
+    l?: any;
 }>;
 export declare type NodeData = z.infer<typeof nodeData>;
 export declare const nodeDataDef: {
@@ -56,34 +55,34 @@ export declare const nodeDataDef: {
             v: CID;
             t: CID | null;
         }, {
-            v?: any;
-            t?: any;
             p: number;
             k: Uint8Array;
+            v?: any;
+            t?: any;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
-        l: CID | null;
         e: {
             p: number;
             k: Uint8Array;
             v: CID;
             t: CID | null;
         }[];
+        l: CID | null;
     }, {
-        l?: any;
         e: {
-            v?: any;
-            t?: any;
             p: number;
             k: Uint8Array;
+            v?: any;
+            t?: any;
         }[];
+        l?: any;
     }>;
 };
 export declare type NodeEntry = MST | Leaf;
 export declare type MstOpts = {
     layer: number;
 };
-export declare class MST implements DataStore {
+export declare class MST {
     storage: ReadableBlockstore;
     entries: NodeEntry[] | null;
     layer: number | null;

package/dist/readable-repo.d.ts

@@ -1,15 +1,16 @@
 import { CID } from 'multiformats/cid';
-import { Commit, DataStore, RepoContents } from './types';
+import { Commit, RepoContents } from './types';
 import { ReadableBlockstore } from './storage';
+import { MST } from './mst';
 declare type Params = {
     storage: ReadableBlockstore;
-    data: DataStore;
+    data: MST;
     commit: Commit;
     cid: CID;
 };
 export declare class ReadableRepo {
     storage: ReadableBlockstore;
-    data: DataStore;
+    data: MST;
     commit: Commit;
     cid: CID;
     constructor(params: Params);

package/dist/repo.d.ts

@@ -1,11 +1,12 @@
 import { CID } from 'multiformats/cid';
 import * as crypto from '@atproto/crypto';
-import { Commit, DataStore, RecordCreateOp, RecordWriteOp, CommitData } from './types';
+import { Commit, RecordCreateOp, RecordWriteOp, CommitData, RebaseData } from './types';
 import { RepoStorage } from './storage';
+import { MST } from './mst';
 import { ReadableRepo } from './readable-repo';
 declare type Params = {
     storage: RepoStorage;
-    data: DataStore;
+    data: MST;
     commit: Commit;
     cid: CID;
 };
@@ -19,5 +20,8 @@ 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>;
+    formatRebase(keypair: crypto.Keypair): Promise<RebaseData>;
+    applyRebase(rebase: RebaseData): Promise<Repo>;
+    rebase(keypair: crypto.Keypair): Promise<Repo>;
 }
 export default Repo;

package/dist/src/block-map.d.ts

@@ -0,0 +1,23 @@
+import { CID } from 'multiformats/cid';
+export declare class BlockMap {
+    private map;
+    add(value: unknown): Promise<CID>;
+    set(cid: CID, bytes: Uint8Array): void;
+    get(cid: CID): Uint8Array | undefined;
+    getMany(cids: CID[]): {
+        blocks: BlockMap;
+        missing: CID[];
+    };
+    has(cid: CID): boolean;
+    clear(): void;
+    forEach(cb: (bytes: Uint8Array, cid: CID) => void): void;
+    entries(): Entry[];
+    addMap(toAdd: BlockMap): void;
+    get size(): number;
+    equals(other: BlockMap): boolean;
+}
+declare type Entry = {
+    cid: CID;
+    bytes: Uint8Array;
+};
+export default BlockMap;

package/dist/src/blockstore/persistent-blockstore.d.ts

@@ -0,0 +1,12 @@
+import level from 'level';
+import { CID } from 'multiformats/cid';
+import IpldStore from './ipld-store';
+export declare class PersistentBlockstore extends IpldStore {
+    store: level.Level;
+    constructor(location?: string);
+    getBytes(cid: CID): Promise<Uint8Array>;
+    putBytes(cid: CID, bytes: Uint8Array): Promise<void>;
+    has(cid: CID): Promise<boolean>;
+    destroy(): Promise<void>;
+}
+export default PersistentBlockstore;

package/dist/src/cid-set.d.ts

@@ -0,0 +1,14 @@
+import { CID } from 'multiformats';
+export declare class CidSet {
+    private set;
+    constructor(arr?: CID[]);
+    add(cid: CID): CidSet;
+    addSet(toMerge: CidSet): CidSet;
+    subtractSet(toSubtract: CidSet): CidSet;
+    delete(cid: CID): this;
+    has(cid: CID): boolean;
+    size(): number;
+    clear(): CidSet;
+    toList(): CID[];
+}
+export default CidSet;

package/dist/src/collection.d.ts

@@ -0,0 +1,22 @@
+import { NSID } from '@atproto/nsid';
+import { CID } from 'multiformats/cid';
+import Repo from './repo';
+export declare class Collection {
+    repo: Repo;
+    nsid: NSID;
+    constructor(repo: Repo, nsid: NSID | string);
+    name(): string;
+    dataIdForRecord(key: string): string;
+    getRecord(key: string): Promise<unknown | null>;
+    listRecords(count?: number, after?: string, before?: string): Promise<{
+        key: string;
+        value: unknown;
+    }[]>;
+    createRecord(record: unknown, rkey?: string): Promise<{
+        rkey: string;
+        cid: CID;
+    }>;
+    updateRecord(rkey: string, record: unknown): Promise<CID>;
+    deleteRecord(rkey: string): Promise<void>;
+}
+export default Collection;

package/dist/src/data-diff.d.ts

@@ -0,0 +1,34 @@
+import { CID } from 'multiformats';
+import CidSet from './cid-set';
+import { DataStore } from './types';
+export declare class DataDiff {
+    adds: Record<string, DataAdd>;
+    updates: Record<string, DataUpdate>;
+    deletes: Record<string, DataDelete>;
+    newCids: CidSet;
+    static of(curr: DataStore, prev: DataStore | null): Promise<DataDiff>;
+    recordAdd(key: string, cid: CID): void;
+    recordUpdate(key: string, prev: CID, cid: CID): void;
+    recordDelete(key: string, cid: CID): void;
+    recordNewCid(cid: CID): void;
+    addDiff(diff: DataDiff): void;
+    addList(): DataAdd[];
+    updateList(): DataUpdate[];
+    deleteList(): DataDelete[];
+    newCidList(): CID[];
+    updatedKeys(): string[];
+}
+export declare type DataAdd = {
+    key: string;
+    cid: CID;
+};
+export declare type DataUpdate = {
+    key: string;
+    prev: CID;
+    cid: CID;
+};
+export declare type DataDelete = {
+    key: string;
+    cid: CID;
+};
+export default DataDiff;

package/dist/src/error.d.ts

@@ -0,0 +1,21 @@
+import { Def } from '@atproto/common/src/check';
+import { CID } from 'multiformats/cid';
+export declare class MissingBlockError extends Error {
+    cid: CID;
+    constructor(cid: CID, def?: Def<unknown>);
+}
+export declare class MissingBlocksError extends Error {
+    context: string;
+    cids: CID[];
+    constructor(context: string, cids: CID[]);
+}
+export declare class MissingCommitBlocksError extends Error {
+    commit: CID;
+    cids: CID[];
+    constructor(commit: CID, cids: CID[]);
+}
+export declare class UnexpectedObjectError extends Error {
+    cid: CID;
+    def: Def<unknown>;
+    constructor(cid: CID, def: Def<unknown>);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './blockstore';
+export * from './repo';
+export * from './mst';
+export * from './storage';
+export * from './types';
+export * from './verify';
+export * from './util';

package/dist/src/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").default.Logger<import("pino").default.LoggerOptions>;
+export default logger;

package/dist/src/mst/diff.d.ts

@@ -0,0 +1,33 @@
+import * as auth from '@atproto/auth';
+import { CID } from 'multiformats';
+import CidSet from '../cid-set';
+export declare class DataDiff {
+    adds: Record<string, DataAdd>;
+    updates: Record<string, DataUpdate>;
+    deletes: Record<string, DataDelete>;
+    newCids: CidSet;
+    recordAdd(key: string, cid: CID): void;
+    recordUpdate(key: string, prev: CID, cid: CID): void;
+    recordDelete(key: string, cid: CID): void;
+    recordNewCid(cid: CID): void;
+    addDiff(diff: DataDiff): void;
+    addList(): DataAdd[];
+    updateList(): DataUpdate[];
+    deleteList(): DataDelete[];
+    newCidList(): CID[];
+    updatedKeys(): string[];
+    neededCapabilities(rootDid: string): auth.ucans.Capability[];
+}
+export declare type DataAdd = {
+    key: string;
+    cid: CID;
+};
+export declare type DataUpdate = {
+    key: string;
+    prev: CID;
+    cid: CID;
+};
+export declare type DataDelete = {
+    key: string;
+    cid: CID;
+};

package/dist/src/mst/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mst';
+export * from './diff';
+export * from './walker';
+export * as mstUtil from './util';

package/dist/src/mst/mst.d.ts

@@ -0,0 +1,106 @@
+import z from 'zod';
+import { CID } from 'multiformats';
+import IpldStore from '../blockstore/ipld-store';
+import { DataDiff } from './diff';
+import { DataStore } from '../types';
+import { BlockWriter } from '@ipld/car/api';
+export declare const nodeDataDef: z.ZodObject<{
+    l: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    e: z.ZodArray<z.ZodObject<{
+        p: z.ZodNumber;
+        k: z.ZodString;
+        v: z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>;
+        t: z.ZodNullable<z.ZodEffects<z.ZodEffects<z.ZodAny, any, any>, CID, any>>;
+    }, "strip", z.ZodTypeAny, {
+        t: CID | null;
+        p: number;
+        k: string;
+        v: CID;
+    }, {
+        t?: any;
+        v?: any;
+        p: number;
+        k: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    l: CID | null;
+    e: {
+        t: CID | null;
+        p: number;
+        k: string;
+        v: CID;
+    }[];
+}, {
+    l?: any;
+    e: {
+        t?: any;
+        v?: any;
+        p: number;
+        k: string;
+    }[];
+}>;
+export declare type NodeData = z.infer<typeof nodeDataDef>;
+export declare type NodeEntry = MST | Leaf;
+export declare type Fanout = 2 | 8 | 16 | 32 | 64;
+export declare type MstOpts = {
+    layer: number;
+    fanout: Fanout;
+};
+export declare class MST implements DataStore {
+    blockstore: IpldStore;
+    fanout: Fanout;
+    entries: NodeEntry[] | null;
+    layer: number | null;
+    pointer: CID;
+    outdatedPointer: boolean;
+    constructor(blockstore: IpldStore, fanout: Fanout, pointer: CID, entries: NodeEntry[] | null, layer: number | null);
+    static create(blockstore: IpldStore, entries?: NodeEntry[], opts?: Partial<MstOpts>): Promise<MST>;
+    static fromData(blockstore: IpldStore, data: NodeData, opts?: Partial<MstOpts>): Promise<MST>;
+    static load(blockstore: IpldStore, cid: CID, opts?: Partial<MstOpts>): MST;
+    newTree(entries: NodeEntry[]): Promise<MST>;
+    getEntries(): Promise<NodeEntry[]>;
+    getPointer(): Promise<CID>;
+    getLayer(): Promise<number>;
+    attemptGetLayer(): Promise<number | null>;
+    stage(): Promise<CID>;
+    stageRecurse(trimTop?: boolean): Promise<CID>;
+    add(key: string, value: CID, knownZeros?: number): Promise<MST>;
+    get(key: string): Promise<CID | null>;
+    update(key: string, value: CID): Promise<MST>;
+    delete(key: string): Promise<MST>;
+    diff(other: MST): Promise<DataDiff>;
+    updateEntry(index: number, entry: NodeEntry): Promise<MST>;
+    removeEntry(index: number): Promise<MST>;
+    append(entry: NodeEntry): Promise<MST>;
+    prepend(entry: NodeEntry): Promise<MST>;
+    atIndex(index: number): Promise<NodeEntry | null>;
+    slice(start?: number | undefined, end?: number | undefined): Promise<NodeEntry[]>;
+    spliceIn(entry: NodeEntry, index: number): Promise<MST>;
+    replaceWithSplit(index: number, left: MST | null, leaf: Leaf, right: MST | null): Promise<MST>;
+    splitAround(key: string): Promise<[MST | null, MST | null]>;
+    appendMerge(toMerge: MST): Promise<MST>;
+    createChild(): Promise<MST>;
+    createParent(): Promise<MST>;
+    findGtOrEqualLeafIndex(key: string): Promise<number>;
+    walkLeavesFrom(key: string): AsyncIterable<Leaf>;
+    list(count: number, after?: string, before?: string): Promise<Leaf[]>;
+    listWithPrefix(prefix: string, count?: number): Promise<Leaf[]>;
+    walk(): AsyncIterable<NodeEntry>;
+    paths(): Promise<NodeEntry[][]>;
+    allNodes(): Promise<NodeEntry[]>;
+    leaves(): Promise<Leaf[]>;
+    leafCount(): Promise<number>;
+    writeToCarStream(car: BlockWriter): Promise<void>;
+    isTree(): this is MST;
+    isLeaf(): this is Leaf;
+    equals(other: NodeEntry): Promise<boolean>;
+}
+export declare class Leaf {
+    key: string;
+    value: CID;
+    constructor(key: string, value: CID);
+    isTree(): this is MST;
+    isLeaf(): this is Leaf;
+    equals(entry: NodeEntry): boolean;
+}
+export default MST;

package/dist/src/mst/util.d.ts

@@ -0,0 +1,9 @@
+import { CID } from 'multiformats';
+import IpldStore from '../blockstore/ipld-store';
+import { NodeEntry, NodeData, MstOpts, Fanout } from './mst';
+export declare const leadingZerosOnHash: (key: string, fanout: Fanout) => Promise<number>;
+export declare const layerForEntries: (entries: NodeEntry[], fanout: Fanout) => Promise<number | null>;
+export declare const deserializeNodeData: (blockstore: IpldStore, data: NodeData, opts?: Partial<MstOpts>) => Promise<NodeEntry[]>;
+export declare const serializeNodeData: (entries: NodeEntry[]) => NodeData;
+export declare const countPrefixLen: (a: string, b: string) => number;
+export declare const cidForEntries: (entries: NodeEntry[]) => Promise<CID>;

package/dist/src/mst/walker.d.ts

@@ -0,0 +1,22 @@
+import { MST, NodeEntry } from './mst';
+declare type WalkerStatusDone = {
+    done: true;
+};
+declare type WalkerStatusProgress = {
+    done: false;
+    curr: NodeEntry;
+    walking: MST | null;
+    index: number;
+};
+declare type WalkerStatus = WalkerStatusDone | WalkerStatusProgress;
+export declare class MstWalker {
+    root: MST;
+    stack: WalkerStatus[];
+    status: WalkerStatus;
+    constructor(root: MST);
+    layer(): number;
+    stepOver(): Promise<void>;
+    stepInto(): Promise<void>;
+    advance(): Promise<void>;
+}
+export default MstWalker;

package/dist/src/parse.d.ts

@@ -0,0 +1,11 @@
+import { check } from '@atproto/common';
+import { CID } from 'multiformats/cid';
+import BlockMap from './block-map';
+export declare const getAndParse: <T>(blocks: BlockMap, cid: CID, def: check.Def<T>) => Promise<{
+    obj: T;
+    bytes: Uint8Array;
+}>;
+export declare const parseObj: <T>(bytes: Uint8Array, cid: CID, def: check.Def<T>) => {
+    obj: T;
+    bytes: Uint8Array;
+};

package/dist/src/readable-repo.d.ts

@@ -0,0 +1,25 @@
+import { CID } from 'multiformats/cid';
+import { RepoRoot, Commit, DataStore, RepoMeta, RepoContents } from './types';
+import { ReadableBlockstore } from './storage';
+declare type Params = {
+    storage: ReadableBlockstore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+};
+export declare class ReadableRepo {
+    storage: ReadableBlockstore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    constructor(params: Params);
+    static load(storage: ReadableBlockstore, commitCid: CID): Promise<ReadableRepo>;
+    get did(): string;
+    getRecord(collection: string, rkey: string): Promise<unknown | null>;
+    getContents(): Promise<RepoContents>;
+}
+export default ReadableRepo;

package/dist/src/repo.d.ts

@@ -0,0 +1,39 @@
+import { CID } from 'multiformats/cid';
+import { BlockWriter } from '@ipld/car/writer';
+import { RepoRoot, Commit, DataStore, RepoMeta, RecordCreateOp, RecordWriteOp } from './types';
+import IpldStore from './blockstore/ipld-store';
+import * as auth from '@atproto/auth';
+declare type Params = {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: RecordWriteOp[];
+};
+export declare class Repo {
+    blockstore: IpldStore;
+    data: DataStore;
+    commit: Commit;
+    root: RepoRoot;
+    meta: RepoMeta;
+    cid: CID;
+    stagedWrites: RecordWriteOp[];
+    constructor(params: Params);
+    static create(blockstore: IpldStore, did: string, authStore: auth.AuthStore, initialRecords?: RecordCreateOp[]): Promise<Repo>;
+    static load(blockstore: IpldStore, cid: CID): Promise<Repo>;
+    private updateRepo;
+    get did(): string;
+    getRecord(collection: string, rkey: string): Promise<unknown | null>;
+    stageUpdate(write: RecordWriteOp | RecordWriteOp[]): Repo;
+    createCommit(authStore: auth.AuthStore, performUpdate?: (prev: CID, curr: CID) => Promise<CID | null>): Promise<Repo>;
+    revert(count: number): Promise<Repo>;
+    getCarNoHistory(): Promise<Uint8Array>;
+    getDiffCar(to: CID | null): Promise<Uint8Array>;
+    getFullHistory(): Promise<Uint8Array>;
+    private openCar;
+    writeCheckoutToCarStream(car: BlockWriter): Promise<void>;
+    writeCommitsToCarStream(car: BlockWriter, oldestCommit: CID | null, recentCommit: CID): Promise<void>;
+}
+export default Repo;

package/dist/src/storage/error.d.ts

@@ -0,0 +1,22 @@
+import { Def } from '@atproto/common/src/check';
+import { CID } from 'multiformats/cid';
+export declare class MissingBlockError extends Error {
+    cid: CID;
+    def?: Def<unknown> | undefined;
+    constructor(cid: CID, def?: Def<unknown> | undefined);
+}
+export declare class MissingBlocksError extends Error {
+    context: string;
+    cids: CID[];
+    constructor(context: string, cids: CID[]);
+}
+export declare class MissingCommitBlocksError extends Error {
+    commit: CID;
+    cids: CID[];
+    constructor(commit: CID, cids: CID[]);
+}
+export declare class UnexpectedObjectError extends Error {
+    cid: CID;
+    def: Def<unknown>;
+    constructor(cid: CID, def: Def<unknown>);
+}

package/dist/src/storage/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/src/storage/memory-blobstore.d.ts

@@ -0,0 +1 @@
+export declare const thing = 1;

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

@@ -0,0 +1,28 @@
+import { CID } from 'multiformats/cid';
+import { CommitData } from '../types';
+import BlockMap from '../block-map';
+import RepoStorage from './repo-storage';
+export declare class MemoryBlockstore extends RepoStorage {
+    blocks: BlockMap;
+    head: CID | null;
+    constructor(blocks?: BlockMap);
+    getHead(): Promise<CID | null>;
+    getBytes(cid: CID): Promise<Uint8Array | null>;
+    has(cid: CID): Promise<boolean>;
+    getBlocks(cids: CID[]): Promise<{
+        blocks: BlockMap;
+        missing: CID[];
+    }>;
+    putBlock(cid: CID, block: Uint8Array): Promise<void>;
+    putMany(blocks: BlockMap): Promise<void>;
+    indexCommits(commits: CommitData[]): Promise<void>;
+    updateHead(cid: CID, _prev: CID | null): Promise<void>;
+    applyCommit(commit: CommitData): Promise<void>;
+    getCommitPath(latest: CID, earliest: CID | null): Promise<CID[] | null>;
+    getBlocksForCommits(commits: CID[]): Promise<{
+        [commit: string]: BlockMap;
+    }>;
+    sizeInBytes(): Promise<number>;
+    destroy(): Promise<void>;
+}
+export default MemoryBlockstore;

package/dist/src/storage/readable-blockstore.d.ts

@@ -0,0 +1,21 @@
+import { check } from '@atproto/common';
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+export declare 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[];
+    }>;
+    attemptRead<T>(cid: CID, def: check.Def<T>): Promise<{
+        obj: T;
+        bytes: Uint8Array;
+    } | null>;
+    readObjAndBytes<T>(cid: CID, def: check.Def<T>): Promise<{
+        obj: T;
+        bytes: Uint8Array;
+    }>;
+    readObj<T>(cid: CID, def: check.Def<T>): Promise<T>;
+}
+export default ReadableBlockstore;

package/dist/src/storage/repo-storage.d.ts

@@ -0,0 +1,18 @@
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+import { CommitBlockData, CommitData } from '../types';
+import ReadableBlockstore from './readable-blockstore';
+export declare abstract class RepoStorage extends ReadableBlockstore {
+    abstract getHead(forUpdate?: boolean): Promise<CID | null>;
+    abstract getCommitPath(latest: CID, earliest: CID | null): Promise<CID[] | null>;
+    abstract getBlocksForCommits(commits: CID[]): Promise<{
+        [commit: string]: BlockMap;
+    }>;
+    abstract putBlock(cid: CID, block: Uint8Array): Promise<void>;
+    abstract putMany(blocks: BlockMap): Promise<void>;
+    abstract updateHead(cid: CID, prev: CID | null): Promise<void>;
+    abstract indexCommits(commit: CommitData[]): Promise<void>;
+    applyCommit(commit: CommitData): Promise<void>;
+    getCommits(latest: CID, earliest: CID | null): Promise<CommitBlockData[] | null>;
+}
+export default RepoStorage;

package/dist/src/storage/sync-storage.d.ts

@@ -0,0 +1,15 @@
+import { CID } from 'multiformats/cid';
+import BlockMap from '../block-map';
+import ReadableBlockstore from './readable-blockstore';
+export declare class SyncStorage extends ReadableBlockstore {
+    staged: ReadableBlockstore;
+    saved: ReadableBlockstore;
+    constructor(staged: ReadableBlockstore, saved: ReadableBlockstore);
+    getBytes(cid: CID): Promise<Uint8Array | null>;
+    getBlocks(cids: CID[]): Promise<{
+        blocks: BlockMap;
+        missing: CID[];
+    }>;
+    has(cid: CID): Promise<boolean>;
+}
+export default SyncStorage;

package/dist/src/storage/types.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import stream from 'stream';
+import { CID } from 'multiformats/cid';
+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>;
+    getBytes(cid: CID): Promise<Uint8Array>;
+    getStream(cid: CID): Promise<stream.Readable>;
+}
+export declare class BlobNotFoundError extends Error {
+}