@web3-storage/pail 0.6.0 → 0.6.2

package/dist/test/batch.test.js

@@ -0,0 +1,126 @@
+import { expect } from 'vitest';
+// eslint-disable-next-line no-unused-vars
+import * as API from '../src/api.js';
+import { ShardBlock } from '../src/shard.js';
+import * as Pail from '../src/index.js';
+import * as Batch from '../src/batch/index.js';
+import { Blockstore, randomCID, randomString, vis } from './helpers.js';
+describe('batch', () => {
+    it('batches puts', async () => {
+        const rootblk = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(rootblk.cid, rootblk.bytes);
+        const ops = [];
+        for (let i = 0; i < 1000; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        const batch = await Batch.create(blocks, rootblk.cid);
+        for (const op of ops) {
+            await batch.put(op.key, op.value);
+        }
+        const { root, additions, removals } = await batch.commit();
+        for (const b of removals) {
+            blocks.deleteSync(b.cid);
+        }
+        for (const b of additions) {
+            blocks.putSync(b.cid, b.bytes);
+        }
+        assert.equal(removals.length, 1);
+        assert.equal(removals[0].cid.toString(), rootblk.cid.toString());
+        for (const o of ops) {
+            const value = await Pail.get(blocks, root, o.key);
+            assert(value);
+            assert.equal(value.toString(), o.value.toString());
+        }
+    });
+    it('create the same DAG as non-batched puts', async () => {
+        const root = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(root.cid, root.bytes);
+        const ops = [];
+        for (let i = 0; i < 1000; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        const batch = await Batch.create(blocks, root.cid);
+        for (const op of ops) {
+            await batch.put(op.key, op.value);
+        }
+        const { root: batchedRoot } = await batch.commit();
+        /** @type {API.ShardLink} */
+        let nonBatchedRoot = root.cid;
+        for (const op of ops) {
+            const { root, additions } = await Pail.put(blocks, nonBatchedRoot, op.key, op.value);
+            nonBatchedRoot = root;
+            for (const b of additions) {
+                blocks.putSync(b.cid, b.bytes);
+            }
+        }
+        assert.equal(batchedRoot.toString(), nonBatchedRoot.toString());
+    });
+    it('error when put after commit', async () => {
+        const root = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(root.cid, root.bytes);
+        const ops = [];
+        for (let i = 0; i < 5; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        const batch = await Batch.create(blocks, root.cid);
+        for (const op of ops) {
+            await batch.put(op.key, op.value);
+        }
+        await batch.commit();
+        await expect(async () => batch.put('test', await randomCID())).rejects.toThrowError(/batch already committed/);
+    });
+    it('error when commit after commit', async () => {
+        const root = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(root.cid, root.bytes);
+        const ops = [];
+        for (let i = 0; i < 5; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        const batch = await Batch.create(blocks, root.cid);
+        for (const op of ops) {
+            await batch.put(op.key, op.value);
+        }
+        await batch.commit();
+        await expect(async () => batch.commit()).rejects.toThrowError(/batch already committed/);
+    });
+    it('traverses existing shards to put values', async () => {
+        const rootblk = await ShardBlock.create();
+        const blocks = new Blockstore();
+        await blocks.put(rootblk.cid, rootblk.bytes);
+        const ops0 = [];
+        for (let i = 0; i < 5; i++) {
+            ops0.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        ops0.push({ type: 'put', key: 'test', value: await randomCID() });
+        const ops1 = [];
+        for (const op of ops0) {
+            ops1.push({ ...op, value: await randomCID() });
+        }
+        const batch0 = await Batch.create(blocks, rootblk.cid);
+        for (const op of ops0) {
+            await batch0.put(op.key, op.value);
+        }
+        const { root: root0, additions: additions0 } = await batch0.commit();
+        for (const b of additions0) {
+            blocks.putSync(b.cid, b.bytes);
+        }
+        const batch1 = await Batch.create(blocks, root0);
+        for (const op of ops1) {
+            await batch1.put(op.key, op.value);
+        }
+        const { root: root1, additions: additions1 } = await batch1.commit();
+        for (const b of additions1) {
+            blocks.putSync(b.cid, b.bytes);
+        }
+        vis(blocks, root1);
+        for (const o of ops1) {
+            const value = await Pail.get(blocks, root1, o.key);
+            assert(value);
+            assert.equal(value.toString(), o.value.toString());
+        }
+    });
+});

package/dist/test/clock.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clock.test.d.ts.map

package/dist/test/clock.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.test.d.ts","sourceRoot":"","sources":["../../test/clock.test.js"],"names":[],"mappings":""}

package/dist/test/clock.test.js

@@ -0,0 +1,244 @@
+// eslint-disable-next-line no-unused-vars
+import * as API from '../src/clock/api.js';
+import { advance, EventBlock, vis } from '../src/clock/index.js';
+import { Blockstore, randomCID, clockVis } from './helpers.js';
+async function randomEventData() {
+    return {
+        type: 'put',
+        key: `test-${Date.now()}`,
+        value: await randomCID(32)
+    };
+}
+describe('clock', () => {
+    it('create a new clock', async () => {
+        const blocks = new Blockstore();
+        const event = await EventBlock.create({});
+        await blocks.put(event.cid, event.bytes);
+        const head = await advance(blocks, [], event.cid);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 1);
+        assert.equal(head[0].toString(), event.cid.toString());
+    });
+    it('add an event', async () => {
+        const blocks = new Blockstore();
+        const root = await EventBlock.create(await randomEventData());
+        await blocks.put(root.cid, root.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [root.cid];
+        const event = await EventBlock.create(await randomEventData(), head);
+        await blocks.put(event.cid, event.bytes);
+        head = await advance(blocks, head, event.cid);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 1);
+        assert.equal(head[0].toString(), event.cid.toString());
+    });
+    it('add two events with shared parents', async () => {
+        const blocks = new Blockstore();
+        const root = await EventBlock.create(await randomEventData());
+        await blocks.put(root.cid, root.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [root.cid];
+        const parents = head;
+        const event0 = await EventBlock.create(await randomEventData(), parents);
+        await blocks.put(event0.cid, event0.bytes);
+        head = await advance(blocks, parents, event0.cid);
+        const event1 = await EventBlock.create(await randomEventData(), parents);
+        await blocks.put(event1.cid, event1.bytes);
+        head = await advance(blocks, head, event1.cid);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 2);
+        assert.equal(head[0].toString(), event0.cid.toString());
+        assert.equal(head[1].toString(), event1.cid.toString());
+    });
+    it('add two events with some shared parents', async () => {
+        const blocks = new Blockstore();
+        const root = await EventBlock.create(await randomEventData());
+        await blocks.put(root.cid, root.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [root.cid];
+        const parents0 = head;
+        const event0 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event0.cid, event0.bytes);
+        head = await advance(blocks, head, event0.cid);
+        const event1 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event1.cid, event1.bytes);
+        head = await advance(blocks, head, event1.cid);
+        const event2 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event2.cid, event2.bytes);
+        head = await advance(blocks, head, event2.cid);
+        const event3 = await EventBlock.create(await randomEventData(), [event0.cid, event1.cid]);
+        await blocks.put(event3.cid, event3.bytes);
+        head = await advance(blocks, head, event3.cid);
+        const event4 = await EventBlock.create(await randomEventData(), [event2.cid]);
+        await blocks.put(event4.cid, event4.bytes);
+        head = await advance(blocks, head, event4.cid);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 2);
+        assert.equal(head[0].toString(), event3.cid.toString());
+        assert.equal(head[1].toString(), event4.cid.toString());
+    });
+    it('converge when multi-root', async () => {
+        const blocks = new Blockstore();
+        const root = await EventBlock.create(await randomEventData());
+        await blocks.put(root.cid, root.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [root.cid];
+        const parents0 = head;
+        const event0 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event0.cid, event0.bytes);
+        head = await advance(blocks, head, event0.cid);
+        const event1 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event1.cid, event1.bytes);
+        head = await advance(blocks, head, event1.cid);
+        const parents1 = head;
+        const event2 = await EventBlock.create(await randomEventData(), parents1);
+        await blocks.put(event2.cid, event2.bytes);
+        head = await advance(blocks, head, event2.cid);
+        const event3 = await EventBlock.create(await randomEventData(), parents1);
+        await blocks.put(event3.cid, event3.bytes);
+        head = await advance(blocks, head, event3.cid);
+        const event4 = await EventBlock.create(await randomEventData(), parents1);
+        await blocks.put(event4.cid, event4.bytes);
+        head = await advance(blocks, head, event4.cid);
+        const parents2 = head;
+        const event5 = await EventBlock.create(await randomEventData(), parents2);
+        await blocks.put(event5.cid, event5.bytes);
+        head = await advance(blocks, head, event5.cid);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 1);
+        assert.equal(head[0].toString(), event5.cid.toString());
+    });
+    it('add an old event', async () => {
+        const blocks = new Blockstore();
+        const blockGet = blocks.get.bind(blocks);
+        let count = 0;
+        blocks.get = async (cid) => {
+            count++;
+            return blockGet(cid);
+        };
+        const root = await EventBlock.create(await randomEventData());
+        await blocks.put(root.cid, root.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [root.cid];
+        const parents0 = head;
+        const event0 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event0.cid, event0.bytes);
+        head = await advance(blocks, head, event0.cid);
+        const event1 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event1.cid, event1.bytes);
+        head = await advance(blocks, head, event1.cid);
+        const parents1 = head;
+        const event2 = await EventBlock.create(await randomEventData(), parents1);
+        await blocks.put(event2.cid, event2.bytes);
+        head = await advance(blocks, head, event2.cid);
+        const event3 = await EventBlock.create(await randomEventData(), parents1);
+        await blocks.put(event3.cid, event3.bytes);
+        head = await advance(blocks, head, event3.cid);
+        const event4 = await EventBlock.create(await randomEventData(), parents1);
+        await blocks.put(event4.cid, event4.bytes);
+        head = await advance(blocks, head, event4.cid);
+        const parents2 = head;
+        const event5 = await EventBlock.create(await randomEventData(), parents2);
+        await blocks.put(event5.cid, event5.bytes);
+        head = await advance(blocks, head, event5.cid);
+        // now very old one
+        const event6 = await EventBlock.create(await randomEventData(), parents0);
+        await blocks.put(event6.cid, event6.bytes);
+        const before = count;
+        head = await advance(blocks, head, event6.cid);
+        assert.equal(count - before, 10);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 2);
+        assert.equal(head[0].toString(), event5.cid.toString());
+        assert.equal(head[1].toString(), event6.cid.toString());
+    });
+    it('add an event with missing parents', async () => {
+        const blocks = new Blockstore();
+        const root = await EventBlock.create(await randomEventData());
+        await blocks.put(root.cid, root.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [root.cid];
+        const event0 = await EventBlock.create(await randomEventData(), head);
+        await blocks.put(event0.cid, event0.bytes);
+        const event1 = await EventBlock.create(await randomEventData(), [event0.cid]);
+        await blocks.put(event1.cid, event1.bytes);
+        head = await advance(blocks, head, event1.cid);
+        await clockVis(blocks, head);
+        assert.equal(head.length, 1);
+        assert.equal(head[0].toString(), event1.cid.toString());
+    });
+    /*
+    ```mermaid
+    flowchart TB
+        event3 --> event1
+        event3 --> event2
+        event2 --> event0
+        event1 --> event0
+        event0 --> genesis
+        event4 --> genesis
+    ```
+  
+    All we want to do is prove that `event0` and `genesis` are not fetched
+    multiple times, since there are multiple paths to it in the tree.
+  
+    We arrive at 8, because when we advance with `head: [event3], event: event4`
+    we firstly check if the head is in the event:
+  
+    * get event4 (1)
+    * get event3 (2)
+    * get genesis (3)
+  
+    Then we check if the event is in the head, with de-duping:
+  
+    * get event3 (4)
+    * get event4 (5)
+    * then get each of the nodes back to parent(s) of `event4` (`genesis`):
+        * event1 (6)
+        * event2 (7)
+        * event0 (8)
+        * (we don't fetch genesis due to existing cycle detection)
+  
+    Without deduping, we expect 9 node fetches, since we traverse across `event0`
+    again, since it is linked to by 2 nodes.
+     */
+    it('contains only traverses history once', async () => {
+        const blocks = new Blockstore();
+        const genesis = await EventBlock.create(await randomEventData());
+        await blocks.put(genesis.cid, genesis.bytes);
+        /** @type {API.EventLink<any>[]} */
+        let head = [genesis.cid];
+        const blockGet = blocks.get.bind(blocks);
+        let count = 0;
+        blocks.get = async (cid) => {
+            count++;
+            return blockGet(cid);
+        };
+        const event0 = await EventBlock.create(await randomEventData(), [genesis.cid]);
+        await blocks.put(event0.cid, event0.bytes);
+        head = await advance(blocks, head, event0.cid);
+        const event1 = await EventBlock.create(await randomEventData(), [event0.cid]);
+        await blocks.put(event1.cid, event1.bytes);
+        head = await advance(blocks, head, event1.cid);
+        const event2 = await EventBlock.create(await randomEventData(), [event0.cid]);
+        await blocks.put(event2.cid, event2.bytes);
+        head = await advance(blocks, head, event2.cid);
+        const event3 = await EventBlock.create(await randomEventData(), [event1.cid, event2.cid]);
+        await blocks.put(event3.cid, event3.bytes);
+        head = await advance(blocks, head, event3.cid);
+        const before = count;
+        const event4 = await EventBlock.create(await randomEventData(), [genesis.cid]);
+        await blocks.put(event4.cid, event4.bytes);
+        head = await advance(blocks, head, event4.cid);
+        assert.equal(head.length, 2);
+        assert.equal(head[1].toString(), event4.cid.toString());
+        assert.equal(head[0].toString(), event3.cid.toString());
+        assert.equal(count - before, 8, 'The number of traversals should be 8 with optimization');
+    });
+    it('sorts event links', async () => {
+        const parent0 = await EventBlock.create(await randomEventData());
+        const parent1 = await EventBlock.create(await randomEventData());
+        const child0 = await EventBlock.create({}, [parent0.cid, parent1.cid]);
+        const child1 = await EventBlock.create({}, [parent1.cid, parent0.cid]);
+        assert.deepEqual(child0.bytes, child1.bytes);
+    });
+});

package/dist/test/crdt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=crdt.test.d.ts.map

package/dist/test/crdt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crdt.test.d.ts","sourceRoot":"","sources":["../../test/crdt.test.js"],"names":[],"mappings":""}

package/dist/test/crdt.test.js

@@ -0,0 +1,271 @@
+import { expect } from 'vitest';
+// eslint-disable-next-line no-unused-vars
+import * as API from '../src/crdt/api.js';
+import { advance, vis } from '../src/clock/index.js';
+import { put, get, root, entries } from '../src/crdt/index.js';
+import * as Batch from '../src/crdt/batch/index.js';
+import { Blockstore, clockVis, randomCID, randomString } from './helpers.js';
+describe('CRDT', () => {
+    it('put a value to a new clock', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        const key = 'key';
+        const value = await randomCID(32);
+        const { event, head } = await alice.put(key, value);
+        await alice.vis();
+        assert(event);
+        assert(event?.value.data.type === 'put');
+        assert.equal(event?.value.data.key, key);
+        assert.equal(event?.value.data.value.toString(), value.toString());
+        assert.equal(head.length, 1);
+        assert.equal(head[0].toString(), event.cid.toString());
+    });
+    it('linear put multiple values', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        const key0 = 'key0';
+        const value0 = await randomCID(32);
+        await alice.put(key0, value0);
+        const key1 = 'key1';
+        const value1 = await randomCID(32);
+        const result = await alice.put(key1, value1);
+        await alice.vis();
+        assert(result.event);
+        assert(result.event.value.data.type === 'put');
+        assert.equal(result.event.value.data.key, key1);
+        assert.equal(result.event.value.data.value.toString(), value1.toString());
+        assert.equal(result.head.length, 1);
+        assert.equal(result.head[0].toString(), result.event.cid.toString());
+    });
+    it('simple parallel put multiple values', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        await alice.put('apple', await randomCID(32));
+        const bob = new TestPail(blocks, alice.head);
+        /** @type {Array<[string, API.UnknownLink]>} */
+        const data = [
+            ['banana', await randomCID(32)],
+            ['kiwi', await randomCID(32)],
+            ['mango', await randomCID(32)],
+            ['orange', await randomCID(32)],
+            ['pear', await randomCID(32)]
+        ];
+        const { event: aevent0 } = await alice.put(data[0][0], data[0][1]);
+        const { event: bevent0 } = await bob.put(data[1][0], data[1][1]);
+        assert(aevent0);
+        assert(bevent0);
+        const carol = new TestPail(blocks, bob.head);
+        const { event: bevent1 } = await bob.put(data[2][0], data[2][1]);
+        const { event: cevent1 } = await carol.put(data[3][0], data[3][1]);
+        assert(bevent1);
+        assert(cevent1);
+        await alice.advance(cevent1.cid);
+        await alice.advance(bevent0.cid);
+        await alice.advance(bevent1.cid);
+        await bob.advance(aevent0.cid);
+        const { event: aevent1 } = await alice.put(data[4][0], data[4][1]);
+        await alice.vis();
+        assert(aevent1);
+        await bob.advance(aevent1.cid);
+        await carol.advance(aevent1.cid);
+        assert(alice.root);
+        assert(bob.root);
+        assert(carol.root);
+        assert.equal(bob.root.toString(), alice.root.toString());
+        assert.equal(carol.root.toString(), alice.root.toString());
+        // get item put to bob from alice
+        const avalue = await alice.get(data[1][0]);
+        assert(avalue);
+        assert.equal(avalue.toString(), data[1][1].toString());
+        // get item put to alice from bob
+        const bvalue = await bob.get(data[0][0]);
+        assert(bvalue);
+        assert.equal(bvalue.toString(), data[0][1].toString());
+        // get item put to alice from carol
+        const cvalue = await bob.get(data[4][0]);
+        assert(cvalue);
+        assert.equal(cvalue.toString(), data[4][1].toString());
+    });
+    it('get from multi event head', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        await alice.put('apple', await randomCID(32));
+        const bob = new TestPail(blocks, alice.head);
+        /** @type {Array<[string, API.UnknownLink]>} */
+        const data = [
+            ['banana', await randomCID(32)],
+            ['kiwi', await randomCID(32)]
+        ];
+        await alice.put(data[0][0], data[0][1]);
+        const { event } = await bob.put(data[1][0], data[1][1]);
+        assert(event);
+        await alice.advance(event.cid);
+        const value = await alice.get(data[1][0]);
+        assert(value);
+        assert.equal(value.toString(), data[1][1].toString());
+    });
+    it('entries from multi event head', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        await alice.put('apple', await randomCID(32));
+        const bob = new TestPail(blocks, alice.head);
+        /** @type {Array<[string, API.UnknownLink]>} */
+        const data = [
+            ['banana', await randomCID(32)],
+            ['kiwi', await randomCID(32)]
+        ];
+        await alice.put(data[0][0], data[0][1]);
+        const { event } = await bob.put(data[1][0], data[1][1]);
+        assert(event);
+        await alice.advance(event.cid);
+        for await (const [k, v] of alice.entries()) {
+            assert(v.toString(), new Map(data).get(k)?.toString());
+        }
+    });
+    it('put same value to existing key', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        const key0 = 'key0';
+        const value0 = await randomCID(32);
+        const r0 = await alice.put(key0, value0);
+        assert(r0.additions.map(s => s.cid.toString()).includes(r0.root.toString()));
+        assert(!r0.removals.map(s => s.cid.toString()).includes(r0.root.toString()));
+        const r1 = await alice.put(key0, value0);
+        // nothing was added or removed
+        assert.equal(r1.root.toString(), r0.root.toString());
+        assert.equal(r1.additions.length, 0);
+        assert.equal(r1.removals.length, 0);
+        // no event should have been added to the clock
+        assert.deepEqual(r1.head.map(cid => cid.toString()), r0.head.map(cid => cid.toString()));
+        assert.equal(r1.event, undefined);
+    });
+});
+describe('CRDT batch', () => {
+    it('error when put after commit', async () => {
+        const blocks = new Blockstore();
+        const ops = [];
+        for (let i = 0; i < 5; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        const batch = await Batch.create(blocks, []);
+        for (const op of ops) {
+            await batch.put(op.key, op.value);
+        }
+        await batch.commit();
+        await expect(async () => batch.put('test', await randomCID())).rejects.toThrow(/batch already committed/);
+    });
+    it('error when commit after commit', async () => {
+        const blocks = new Blockstore();
+        const ops = [];
+        for (let i = 0; i < 5; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        const batch = await Batch.create(blocks, []);
+        for (const op of ops) {
+            await batch.put(op.key, op.value);
+        }
+        await batch.commit();
+        await expect(async () => batch.commit()).rejects.toThrow(/batch already committed/);
+    });
+    it('linear put with batch', async () => {
+        const blocks = new Blockstore();
+        const alice = new TestPail(blocks, []);
+        const key0 = 'test0';
+        const value0 = await randomCID(32);
+        await alice.put(key0, value0);
+        const ops = [];
+        for (let i = 0; i < 25; i++) {
+            ops.push({ type: 'put', key: `test${randomString(10)}`, value: await randomCID() });
+        }
+        await alice.putBatch(ops);
+        // put a new value for the first batch key
+        const key1 = ops[0].key;
+        const value1 = await randomCID(32);
+        await alice.put(key1, value1);
+        await alice.vis();
+        const res0 = await alice.get(key0);
+        assert(res0);
+        assert.equal(res0.toString(), value0.toString());
+        for (const op of ops.slice(1)) {
+            const res = await alice.get(op.key);
+            assert(res);
+            assert.equal(res.toString(), op.value.toString());
+        }
+        const res1 = await alice.get(key1);
+        assert(res1);
+        assert.equal(res1.toString(), value1.toString());
+    });
+});
+class TestPail {
+    /**
+     * @param {Blockstore} blocks
+     * @param {API.EventLink<API.Operation>[]} head
+     */
+    constructor(blocks, head) {
+        this.blocks = blocks;
+        this.head = head;
+        /** @type {API.ShardLink?} */
+        this.root = null;
+    }
+    /** @param {API.EventLink<API.Operation>} event */
+    async advance(event) {
+        this.head = await advance(this.blocks, this.head, event);
+        const result = await root(this.blocks, this.head);
+        result.additions.forEach(a => this.blocks.putSync(a.cid, a.bytes));
+        this.root = result.root;
+        return this.head;
+    }
+    /**
+     * @param {string} key
+     * @param {API.UnknownLink} value
+     */
+    async put(key, value) {
+        const result = await put(this.blocks, this.head, key, value);
+        if (result.event)
+            this.blocks.putSync(result.event.cid, result.event.bytes);
+        result.additions.forEach(a => this.blocks.putSync(a.cid, a.bytes));
+        this.head = result.head;
+        this.root = (await root(this.blocks, this.head)).root;
+        return result;
+    }
+    /**
+     * @param {Array<{ key: string, value: API.UnknownLink }>} items
+     */
+    async putBatch(items) {
+        const batch = await Batch.create(this.blocks, this.head);
+        for (const { key, value } of items) {
+            await batch.put(key, value);
+        }
+        const result = await batch.commit();
+        if (result.event)
+            this.blocks.putSync(result.event.cid, result.event.bytes);
+        result.additions.forEach(a => this.blocks.putSync(a.cid, a.bytes));
+        this.head = result.head;
+        this.root = (await root(this.blocks, this.head)).root;
+        return result;
+    }
+    async vis() {
+        /** @param {API.UnknownLink} l */
+        const shortLink = l => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`;
+        /**
+         * @param {API.PutOperation|API.DeleteOperation|API.BatchOperation} o
+         * @returns {string}
+         **/
+        const renderOp = o => o.type === 'batch'
+            ? `${o.ops.slice(0, 10).map(renderOp).join('\\n')}${o.ops.length > 10 ? `\\n...${o.ops.length - 10} more` : ''}`
+            : `${o.type}(${o.key}${o.type === 'put'
+                ? `, ${shortLink(o.value)}`
+                : ''})`;
+        /** @type {(e: API.EventBlockView<API.Operation>) => string} */
+        const renderNodeLabel = event => `${shortLink(event.cid)}\\n${renderOp(event.value.data)}`;
+        await clockVis(this.blocks, this.head, { renderNodeLabel });
+    }
+    /** @param {string} key */
+    async get(key) {
+        return get(this.blocks, this.head, key);
+    }
+    /** @param {API.EntriesOptions} [options] */
+    async *entries(options) {
+        yield* entries(this.blocks, this.head, options);
+    }
+}

package/dist/test/del.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=del.test.d.ts.map

package/dist/test/del.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"del.test.d.ts","sourceRoot":"","sources":["../../test/del.test.js"],"names":[],"mappings":""}