@fireproof/core 0.4.0 → 0.4.1

package/dist/main.js.LICENSE.txt

@@ -1,17 +0,0 @@
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
- * @license  MIT
- */
-
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
-
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-
-/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */

package/dist/prolly.js

@@ -1,316 +0,0 @@
-import { advance, EventFetcher, EventBlock, findCommonAncestorWithSortedEvents, findEventsToSync, vis as visClock } from './clock.js';
-// import { create, load } from '../../../../prolly-trees/src/map.js'
-// @ts-ignore
-import { create, load } from 'prolly-trees/map';
-// @ts-ignore
-import { nocache as cache } from 'prolly-trees/cache';
-// @ts-ignore
-import { CIDCounter, bf, simpleCompare as compare } from 'prolly-trees/utils';
-import * as codec from '@ipld/dag-cbor';
-import { sha256 as hasher } from 'multiformats/hashes/sha2';
-import { doTransaction } from './blockstore.js';
-import { create as createBlock } from 'multiformats/block';
-const blockOpts = { cache, chunker: bf(3), codec, hasher, compare };
-const withLog = async (label, fn) => {
-    const resp = await fn();
-    // console.log('withLog', label, !!resp)
-    return resp;
-};
-// should also return a CIDCounter
-export const makeGetBlock = (blocks) => {
-    // const cids = new CIDCounter() // this could be used for proofs of mutations
-    const getBlockFn = async (address) => {
-        const { cid, bytes } = await withLog(address, () => blocks.get(address));
-        // cids.add({ address: cid })
-        return createBlock({ cid, bytes, hasher, codec });
-    };
-    return {
-        // cids,
-        getBlock: getBlockFn
-    };
-};
-/**
- *
- * @param {*} param0
- * @returns
- */
-async function createAndSaveNewEvent({ inBlocks, bigPut, root, event: inEvent, head, additions, removals = [] }) {
-    let cids;
-    const { key, value, del } = inEvent;
-    const data = {
-        root: (root
-            ? {
-                cid: root.cid,
-                bytes: root.bytes,
-                value: root.value // can we remove this?
-            }
-            : null),
-        key
-    };
-    // import('./clock').EventLink<import('./clock').EventData>
-    if (del) {
-        data.value = null;
-        data.type = 'del';
-    }
-    else {
-        data.value = value;
-        data.type = 'put';
-    }
-    /** @type {import('./clock').EventData} */
-    // @ts-ignore
-    const event = await EventBlock.create(data, head);
-    bigPut(event);
-    ({ head, cids } = await advance(inBlocks, head, event.cid));
-    return {
-        root,
-        additions,
-        removals,
-        head,
-        clockCIDs: cids,
-        event
-    };
-}
-const makeGetAndPutBlock = (inBlocks) => {
-    // const mblocks = new MemoryBlockstore()
-    // const blocks = new MultiBlockFetcher(mblocks, inBlocks)
-    const { getBlock, cids } = makeGetBlock(inBlocks);
-    const put = inBlocks.put.bind(inBlocks);
-    const bigPut = async (block, additions) => {
-        // console.log('bigPut', block.cid.toString())
-        const { cid, bytes } = block;
-        put(cid, bytes);
-        // mblocks.putSync(cid, bytes)
-        if (additions) {
-            additions.set(cid.toString(), block);
-        }
-    };
-    return { getBlock, bigPut, blocks: inBlocks, cids };
-};
-const bulkFromEvents = (sorted, event) => {
-    if (event) {
-        const update = { value: { data: { key: event.key } } };
-        if (event.del) {
-            update.value.data.type = 'del';
-        }
-        else {
-            update.value.data.type = 'put';
-            update.value.data.value = event.value;
-        }
-        sorted.push(update);
-    }
-    const bulk = new Map();
-    for (const { value: event } of sorted) {
-        const { data: { type, value, key } } = event;
-        const bulkEvent = type === 'put' ? { key, value } : { key, del: true };
-        bulk.set(bulkEvent.key, bulkEvent); // last wins
-    }
-    return Array.from(bulk.values());
-};
-// Get the value of the root from the ancestor event
-/**
- *
- * @param {EventFetcher} events
- * @param {import('./clock').EventLink<import('./clock').EventData>} ancestor
- * @param {*} getBlock
- * @returns
- */
-const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
-    // console.log('prollyRootFromAncestor', ancestor)
-    const event = await events.get(ancestor);
-    const { root } = event.value.data;
-    // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
-    if (root) {
-        return load({ cid: root.cid, get: getBlock, ...blockOpts });
-    }
-    else {
-        return null;
-    }
-};
-const doProllyBulk = async (inBlocks, head, event) => {
-    const { getBlock, blocks } = makeGetAndPutBlock(inBlocks);
-    let bulkSorted = [];
-    let prollyRootNode = null;
-    if (head.length) {
-        // Otherwise, we find the common ancestor and update the root and other blocks
-        const events = new EventFetcher(blocks);
-        // todo this is returning more events than necessary, lets define the desired semantics from the top down
-        // good semantics mean we can cache the results of this call
-        const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head);
-        bulkSorted = sorted;
-        // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
-        prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock);
-        // console.log('event', event)
-    }
-    const bulkOperations = bulkFromEvents(bulkSorted, event);
-    // if prolly root node is null, we need to create a new one
-    if (!prollyRootNode) {
-        let root;
-        const newBlocks = [];
-        // if all operations are deletes, we can just return an empty root
-        if (bulkOperations.every((op) => op.del)) {
-            return { root: null, blocks: [] };
-        }
-        for await (const node of create({ get: getBlock, list: bulkOperations, ...blockOpts })) {
-            root = await node.block;
-            newBlocks.push(root);
-        }
-        return { root, blocks: newBlocks };
-    }
-    else {
-        return await prollyRootNode.bulk(bulkOperations); // { root: newProllyRootNode, blocks: newBlocks }
-    }
-};
-/**
- * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
- *
- * @param {import('./blockstore.js').Blockstore} inBlocks Bucket block storage.
- * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
-* @param {{key: string, value: import('./clock').EventLink<import('./clock').EventData>}} event The key of the value to put.
- * @param {object} [options]
- * @returns {Promise<any>}
- */
-export async function put(inBlocks, head, event, options) {
-    const { bigPut } = makeGetAndPutBlock(inBlocks);
-    // If the head is empty, we create a new event and return the root and addition blocks
-    if (!head.length) {
-        const additions = new Map();
-        const { root, blocks } = await doProllyBulk(inBlocks, head, event);
-        for (const b of blocks) {
-            bigPut(b, additions);
-        }
-        return createAndSaveNewEvent({ inBlocks, bigPut, root, event, head, additions: Array.from(additions.values()) });
-    }
-    const { root: newProllyRootNode, blocks: newBlocks } = await doProllyBulk(inBlocks, head, event);
-    if (!newProllyRootNode) {
-        return createAndSaveNewEvent({
-            inBlocks,
-            bigPut,
-            root: null,
-            event,
-            head,
-            additions: []
-        });
-    }
-    else {
-        const prollyRootBlock = await newProllyRootNode.block;
-        const additions = new Map(); // ; const removals = new Map()
-        bigPut(prollyRootBlock, additions);
-        for (const nb of newBlocks) {
-            bigPut(nb, additions);
-        }
-        // additions are new blocks
-        return createAndSaveNewEvent({
-            inBlocks,
-            bigPut,
-            root: prollyRootBlock,
-            event,
-            head,
-            additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
-        });
-    }
-}
-/**
- * Determine the effective prolly root given the current merkle clock head.
- *
- * @param {import('./blockstore.js').TransactionBlockstore} inBlocks Bucket block storage.
- * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
- */
-export async function root(inBlocks, head) {
-    if (!head.length) {
-        throw new Error('no head');
-    }
-    const { root: newProllyRootNode, blocks: newBlocks, cids } = await doProllyBulk(inBlocks, head);
-    // todo maybe these should go to a temp blockstore?
-    await doTransaction('root', inBlocks, async (transactionBlockstore) => {
-        const { bigPut } = makeGetAndPutBlock(transactionBlockstore);
-        for (const nb of newBlocks) {
-            bigPut(nb);
-        }
-    });
-    return { cids, node: newProllyRootNode };
-}
-/**
- * Get the list of events not known by the `since` event
- * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
- * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
- * @param {import('./clock').EventLink<import('./clock').EventData>} since Event to compare against.
- * @returns {Promise<{clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
- */
-export async function eventsSince(blocks, head, since) {
-    if (!head.length) {
-        throw new Error('no head');
-    }
-    // @ts-ignore
-    const sinceHead = [...since, ...head]; // ?
-    const { cids, events: unknownSorted3 } = await findEventsToSync(blocks, sinceHead);
-    return { clockCIDs: cids, result: unknownSorted3.map(({ value: { data } }) => data) };
-}
-/**
- *
- * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
- * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
- *
- * @returns {Promise<{cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
- *
- */
-export async function getAll(blocks, head) {
-    // todo use the root node left around from put, etc
-    // move load to a central place
-    if (!head.length) {
-        return { clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] };
-    }
-    const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
-    if (!prollyRootNode) {
-        return { clockCIDs, cids: new CIDCounter(), result: [] };
-    }
-    const { result, cids } = await prollyRootNode.getAllEntries(); // todo params
-    return { clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) };
-}
-/**
- * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
- * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
- * @param {string} key The key of the value to retrieve.
- */
-export async function get(blocks, head, key) {
-    // instead pass root from db? and always update on change
-    if (!head.length) {
-        return { cids: new CIDCounter(), result: null };
-    }
-    const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
-    if (!prollyRootNode) {
-        return { clockCIDs, cids: new CIDCounter(), result: null };
-    }
-    const { result, cids } = await prollyRootNode.get(key);
-    return { result, cids, clockCIDs };
-}
-export async function* vis(blocks, head) {
-    if (!head.length) {
-        return { cids: new CIDCounter(), result: null };
-    }
-    const { node: prollyRootNode, cids } = await root(blocks, head);
-    const lines = [];
-    for await (const line of prollyRootNode.vis()) {
-        yield line;
-        lines.push(line);
-    }
-    return { vis: lines.join('\n'), cids };
-}
-export async function visMerkleTree(blocks, head) {
-    if (!head.length) {
-        return { cids: new CIDCounter(), result: null };
-    }
-    const { node: prollyRootNode, cids } = await root(blocks, head);
-    const lines = [];
-    for await (const line of prollyRootNode.vis()) {
-        lines.push(line);
-    }
-    return { vis: lines.join('\n'), cids };
-}
-export async function visMerkleClock(blocks, head) {
-    const lines = [];
-    for await (const line of visClock(blocks, head)) {
-        // yield line
-        lines.push(line);
-    }
-    return { vis: lines.join('\n') };
-}

package/dist/sha1.js

@@ -1,74 +0,0 @@
-// @ts-nocheck
-// from https://github.com/duzun/sync-sha1/blob/master/rawSha1.js
-// MIT License Copyright (c) 2020 Dumitru Uzun
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-// import {
-//   isLittleEndian, switchEndianness32
-// } from 'string-encode'
-/**
-* SHA1 on binary array
-*
-* @param   {Uint8Array}  b  Data to hash
-*
-* @return  {Uint8Array}  sha1 hash
-*/
-export function rawSha1(b) {
-    let i = b.byteLength;
-    let bs = 0;
-    let A;
-    let B;
-    let C;
-    let D;
-    let G;
-    const H = Uint32Array.from([A = 0x67452301, B = 0xEFCDAB89, ~A, ~B, 0xC3D2E1F0]);
-    const W = new Uint32Array(80);
-    const nrWords = (i / 4 + 2) | 15;
-    const words = new Uint32Array(nrWords + 1);
-    let j;
-    words[nrWords] = i * 8;
-    words[i >> 2] |= 0x80 << (~i << 3);
-    for (; i--;) {
-        words[i >> 2] |= b[i] << (~i << 3);
-    }
-    for (A = H.slice(); bs < nrWords; bs += 16, A.set(H)) {
-        for (i = 0; i < 80; A[0] = (G = ((b = A[0]) << 5 | b >>> 27) +
-            A[4] +
-            (W[i] = (i < 16) ? words[bs + i] : G << 1 | G >>> 31) +
-            0x5A827999,
-            B = A[1],
-            C = A[2],
-            D = A[3],
-            G + ((j = i / 5 >> 2) // eslint-disable-line no-cond-assign
-                ? j !== 2
-                    ? (B ^ C ^ D) + (j & 2 ? 0x6FE0483D : 0x14577208)
-                    : (B & C | B & D | C & D) + 0x34994343
-                : B & C | ~B & D))
-            , A[1] = b
-            , A[2] = B << 30 | B >>> 2
-            , A[3] = C
-            , A[4] = D
-            , ++i) {
-            G = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
-        }
-        for (i = 5; i;)
-            H[--i] = H[i] + A[i];
-    }
-    // if (isLittleEndian()) {
-    //   H = H.map(switchEndianness32)
-    // }
-    return new Uint8Array(H.buffer, H.byteOffset, H.byteLength);
-}

package/dist/src/blockstore.js

@@ -1,242 +0,0 @@
-import { parse } from 'multiformats/link';
-import { CID } from 'multiformats';
-import { Valet } from './valet.js';
-// const sleep = ms => new Promise(r => setTimeout(r, ms))
-const husherMap = new Map();
-const husher = (id, workFn) => {
-    if (!husherMap.has(id)) {
-        husherMap.set(id, workFn().finally(() => setTimeout(() => husherMap.delete(id), 100)));
-    }
-    return husherMap.get(id);
-};
-/**
- * @typedef {{ get: (link: import('../src/link').AnyLink) => Promise<AnyBlock | undefined> }} BlockFetcher
- */
-/**
- * @typedef {Object} AnyBlock
- * @property {import('./link').AnyLink} cid - The CID of the block
- * @property {Uint8Array} bytes - The block's data
- *
- * @typedef {Object} Blockstore
- * @property {function(import('./link').AnyLink): Promise<AnyBlock|undefined>} get - A function to retrieve a block by CID
- * @property {function(import('./link').AnyLink, Uint8Array): Promise<void>} put - A function to store a block's data and CID
- *
- * A blockstore that caches writes to a transaction and only persists them when committed.
-*/
-export class TransactionBlockstore {
-    /** @type {Map<string, Uint8Array>} */
-    committedBlocks = new Map();
-    valet = null;
-    instanceId = 'blkz.' + Math.random().toString(36).substring(2, 4);
-    inflightTransactions = new Set();
-    constructor(name, encryptionKey) {
-        if (name) {
-            this.valet = new Valet(name, encryptionKey);
-        }
-        this.remoteBlockFunction = null;
-    }
-    /**
-     * Get a block from the store.
-     *
-     * @param {import('./link').AnyLink} cid
-     * @returns {Promise<AnyBlock | undefined>}
-     */
-    async get(cid) {
-        const key = cid.toString();
-        // it is safe to read from the in-flight transactions becauase they are immutable
-        const bytes = await Promise.any([this.transactionsGet(key), this.committedGet(key)]).catch(e => {
-            // console.log('networkGet', cid.toString(), e)
-            return this.networkGet(key);
-        });
-        if (!bytes)
-            throw new Error('Missing block: ' + key);
-        return { cid, bytes };
-    }
-    // this iterates over the in-flight transactions
-    // and returns the first matching block it finds
-    async transactionsGet(key) {
-        for (const transaction of this.inflightTransactions) {
-            const got = await transaction.get(key);
-            if (got && got.bytes)
-                return got.bytes;
-        }
-        throw new Error('Missing block: ' + key);
-    }
-    async committedGet(key) {
-        const old = this.committedBlocks.get(key);
-        if (old)
-            return old;
-        if (!this.valet)
-            throw new Error('Missing block: ' + key);
-        const got = await this.valet.getBlock(key);
-        // console.log('committedGet: ' + key)
-        this.committedBlocks.set(key, got);
-        return got;
-    }
-    async clearCommittedCache() {
-        this.committedBlocks.clear();
-    }
-    async networkGet(key) {
-        if (this.remoteBlockFunction) {
-            // todo why is this on valet?
-            const value = await husher(key, async () => await this.remoteBlockFunction(key));
-            if (value) {
-                // console.log('networkGot: ' + key, value.length)
-                doTransaction('networkGot: ' + key, this, async (innerBlockstore) => {
-                    await innerBlockstore.put(CID.parse(key), value);
-                });
-                return value;
-            }
-        }
-        else {
-            return false;
-        }
-    }
-    /**
-     * Add a block to the store. Usually bound to a transaction by a closure.
-     * It sets the lastCid property to the CID of the block that was put.
-     * This is used by the transaction as the head of the car when written to the valet.
-     * We don't have to worry about which transaction we are when we are here because
-     * we are the transactionBlockstore.
-     *
-     * @param {import('./link').AnyLink} cid
-     * @param {Uint8Array} bytes
-     */
-    put(cid, bytes) {
-        throw new Error('use a transaction to put');
-    }
-    /**
-     * Iterate over all blocks in the store.
-     *
-     * @yields {AnyBlock}
-     * @returns {AsyncGenerator<AnyBlock>}
-     */
-    // * entries () {
-    //   // needs transaction blocks?
-    //   // for (const [str, bytes] of this.blocks) {
-    //   //   yield { cid: parse(str), bytes }
-    //   // }
-    //   for (const [str, bytes] of this.committedBlocks) {
-    //     yield { cid: parse(str), bytes }
-    //   }
-    // }
-    /**
-     * Begin a transaction. Ensures the uncommited blocks are empty at the begining.
-     * Returns the blocks to read and write during the transaction.
-     * @returns {InnerBlockstore}
-     * @memberof TransactionBlockstore
-     */
-    begin(label = '') {
-        const innerTransactionBlockstore = new InnerBlockstore(label, this);
-        this.inflightTransactions.add(innerTransactionBlockstore);
-        return innerTransactionBlockstore;
-    }
-    /**
-     * Commit the transaction. Writes the blocks to the store.
-     * @returns {Promise<void>}
-     * @memberof TransactionBlockstore
-     */
-    async commit(innerBlockstore) {
-        await this.doCommit(innerBlockstore);
-    }
-    // first get the transaction blockstore from the map of transaction blockstores
-    // then copy it to committedBlocks
-    // then write the transaction blockstore to a car
-    // then write the car to the valet
-    // then remove the transaction blockstore from the map of transaction blockstores
-    doCommit = async (innerBlockstore) => {
-        const cids = new Set();
-        for (const { cid, bytes } of innerBlockstore.entries()) {
-            const stringCid = cid.toString(); // unnecessary string conversion, can we fix upstream?
-            if (this.committedBlocks.has(stringCid)) {
-                // console.log('Duplicate block: ' + stringCid) // todo some of this can be avoided, cost is extra size on car files
-            }
-            else {
-                this.committedBlocks.set(stringCid, bytes);
-                cids.add(stringCid);
-            }
-        }
-        if (cids.size > 0 && this.valet) {
-            // console.log(innerBlockstore.label, 'committing', cids.size, 'blocks')
-            await this.valet.writeTransaction(innerBlockstore, cids);
-        }
-    };
-    /**
-     * Retire the transaction. Clears the uncommited blocks.
-     * @returns {void}
-     * @memberof TransactionBlockstore
-     */
-    retire(innerBlockstore) {
-        this.inflightTransactions.delete(innerBlockstore);
-    }
-}
-/**
- * Runs a function on an inner blockstore, then persists the change to a car writer
- * or other outer blockstore.
- * @param {string} label
- * @param {TransactionBlockstore} blockstore
- * @param {(innerBlockstore: Blockstore) => Promise<any>} doFun
- * @returns {Promise<any>}
- * @memberof TransactionBlockstore
- */
-export const doTransaction = async (label, blockstore, doFun) => {
-    // @ts-ignore
-    if (!blockstore.commit)
-        return await doFun(blockstore);
-    // @ts-ignore
-    const innerBlockstore = blockstore.begin(label);
-    try {
-        const result = await doFun(innerBlockstore);
-        // @ts-ignore
-        await blockstore.commit(innerBlockstore);
-        return result;
-    }
-    catch (e) {
-        console.error(`Transaction ${label} failed`, e, e.stack);
-        throw e;
-    }
-    finally {
-        // @ts-ignore
-        blockstore.retire(innerBlockstore);
-    }
-};
-export class InnerBlockstore {
-    /** @type {Map<string, Uint8Array>} */
-    blocks = new Map();
-    lastCid = null;
-    label = '';
-    parentBlockstore = null;
-    constructor(label, parentBlockstore) {
-        this.label = label;
-        this.parentBlockstore = parentBlockstore;
-    }
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @returns {Promise<AnyBlock | undefined>}
-     */
-    async get(cid) {
-        const key = cid.toString();
-        let bytes = this.blocks.get(key);
-        if (bytes) {
-            return { cid, bytes };
-        }
-        bytes = await this.parentBlockstore.committedGet(key);
-        if (bytes) {
-            return { cid, bytes };
-        }
-    }
-    /**
-     * @param {import('./link').AnyLink} cid
-     * @param {Uint8Array} bytes
-     */
-    async put(cid, bytes) {
-        // console.log('put', cid)
-        this.blocks.set(cid.toString(), bytes);
-        this.lastCid = cid;
-    }
-    *entries() {
-        for (const [str, bytes] of this.blocks) {
-            yield { cid: parse(str), bytes };
-        }
-    }
-}