@fireproof/core 0.8.0 → 0.10.1-dev

package/dist/clock.js

@@ -1,459 +0,0 @@
-import { Block, encode, decode } from 'multiformats/block';
-import { sha256 } from 'multiformats/hashes/sha2';
-import * as cbor from '@ipld/dag-cbor';
-// @ts-ignore
-import { CIDCounter } from 'prolly-trees/utils';
-/**
- * @template T
- * @typedef {{ parents: EventLink<T>[], data: T }} EventView
- */
-/**
- * @template T
- * @typedef {import('multiformats').BlockView<EventView<T>>} EventBlockView
- */
-/**
- * @template T
- * @typedef {import('multiformats').Link<EventView<T>>} EventLink
- */
-/**
- * @typedef {{
- *   type: 'put'|'del'
- *   key: string
- *   value: import('./link').AnyLink
- *   root: import('./link').AnyLink
- * }} EventData
- * @typedef {{
- *   root: import('./link').AnyLink
- *   head: import('./clock').EventLink<EventData>[]
- *   event: import('./clock').EventBlockView<EventData>
- * }} Result
- */
-/**
- * Advance the clock by adding an event.
- *
- * @template T
- * @param {import('./blockstore').TransactionBlockstore} blocks Block storage.
- * @param {EventLink<T>[]} head The head of the clock.
- * @param {EventLink<T>} event The event to add.
- * @returns {Promise<{head:EventLink<T>[], cids:any[]}>} The new head of the clock.
- */
-export async function advance(blocks, head, event) {
-    /** @type {EventFetcher<T>} */
-    const events = new EventFetcher(blocks);
-    const headmap = new Map(head.map(cid => [cid.toString(), cid]));
-    // Check if the headmap already includes the event, return head if it does
-    if (headmap.has(event.toString()))
-        return { head, cids: await events.all() };
-    // Does event contain the clock?
-    let changed = false;
-    for (const cid of head) {
-        if (await contains(events, event, cid)) {
-            headmap.delete(cid.toString());
-            headmap.set(event.toString(), event);
-            changed = true;
-        }
-    }
-    // If the headmap has been changed, return the new headmap values
-    if (changed) {
-        return { head: [...headmap.values()], cids: await events.all() };
-    }
-    // Does clock contain the event?
-    for (const p of head) {
-        if (await contains(events, p, event)) {
-            return { head, cids: await events.all() };
-        }
-    }
-    // Return the head concatenated with the new event if it passes both checks
-    return { head: head.concat(event), cids: await events.all() };
-}
-/**
- * @template T
- * @implements {EventBlockView<T>}
- */
-export class EventBlock extends Block {
-    /**
-     * @param {object} config
-     * @param {EventLink<T>} config.cid
-     * @param {Event} config.value
-     * @param {Uint8Array} config.bytes
-     */
-    constructor({ cid, value, bytes }) {
-        // @ts-ignore
-        super({ cid, value, bytes });
-    }
-    /**
-     * @template T
-     * @param {T} data
-     * @param {EventLink<T>[]} [parents]
-     */
-    static create(data, parents) {
-        return encodeEventBlock({ data, parents: parents ?? [] });
-    }
-}
-/** @template T */
-export class EventFetcher {
-    /** @param {import('./blockstore').TransactionBlockstore} blocks */
-    constructor(blocks) {
-        /** @private */
-        this._blocks = blocks;
-        this._cids = new CIDCounter();
-        this._cache = new Map();
-    }
-    /**
-     * @param {EventLink<T>} link
-     * @returns {Promise<EventBlockView<T>>}
-     */
-    async get(link) {
-        const slink = link.toString();
-        // console.log('get', link.toString())
-        if (this._cache.has(slink))
-            return this._cache.get(slink);
-        const block = await this._blocks.get(link);
-        this._cids.add({ address: link });
-        if (!block)
-            throw new Error(`missing block: ${link}`);
-        const got = decodeEventBlock(block.bytes);
-        this._cache.set(slink, got);
-        return got;
-    }
-    async all() {
-        // await Promise.all([...this._cids])
-        return this._cids.all();
-    }
-}
-/**
- * @template T
- * @param {EventView<T>} value
- * @returns {Promise<EventBlockView<T>>}
- */
-export async function encodeEventBlock(value) {
-    // TODO: sort parents
-    const { cid, bytes } = await encode({ value, codec: cbor, hasher: sha256 });
-    // @ts-ignore
-    return new Block({ cid, value, bytes });
-}
-/**
- * @template T
- * @param {Uint8Array} bytes
- * @returns {Promise<EventBlockView<T>>}
- */
-export async function decodeEventBlock(bytes) {
-    const { cid, value } = await decode({ bytes, codec: cbor, hasher: sha256 });
-    // @ts-ignore
-    return new Block({ cid, value, bytes });
-}
-/**
- * Returns true if event "a" contains event "b". Breadth first search.
- * @template T
- * @param {EventFetcher} events
- * @param {EventLink<T>} a
- * @param {EventLink<T>} b
- */
-async function contains(events, a, b) {
-    if (a.toString() === b.toString())
-        return true;
-    const [{ value: aevent }, { value: bevent }] = await Promise.all([events.get(a), events.get(b)]);
-    // const links = [...aevent.parents]
-    // console.log('aevent', aevent.parents)
-    const links = [...(aevent.parents || [])];
-    while (links.length) {
-        const link = links.shift();
-        if (!link)
-            break;
-        if (link.toString() === b.toString())
-            return true;
-        // if any of b's parents are this link, then b cannot exist in any of the
-        // tree below, since that would create a cycle.
-        if (bevent.parents.some(p => link.toString() === p.toString()))
-            continue;
-        const { value: event } = await events.get(link);
-        links.push(...event.parents);
-    }
-    return false;
-}
-/**
- * @template T
- * @param {import('./blockstore').TransactionBlockstore} blocks Block storage.
- * @param {EventLink<T>[]} head
- * @param {object} [options]
- * @param {(b: EventBlockView<T>) => string} [options.renderNodeLabel]
- */
-export async function* vis(blocks, head, options = {}) {
-    // @ts-ignore
-    const renderNodeLabel = options.renderNodeLabel ??
-        (b => {
-            // @ts-ignore
-            const { key, root, type } = b.value.data;
-            return (b.cid.toString() + '\n' + JSON.stringify({ key, root: root.cid.toString(), type }, null, 2).replace(/"/g, "'"));
-        });
-    const events = new EventFetcher(blocks);
-    yield 'digraph clock {';
-    yield '  node [shape=point fontname="Courier"]; head;';
-    const hevents = await Promise.all(head.map(link => events.get(link)));
-    const links = [];
-    const nodes = new Set();
-    for (const e of hevents) {
-        nodes.add(e.cid.toString());
-        yield `  node [shape=oval fontname="Courier"]; ${e.cid} [label="${renderNodeLabel(e)}"];`;
-        yield `  head -> ${e.cid};`;
-        for (const p of e.value.parents) {
-            yield `  ${e.cid} -> ${p};`;
-        }
-        links.push(...e.value.parents);
-    }
-    while (links.length) {
-        const link = links.shift();
-        if (!link)
-            break;
-        if (nodes.has(link.toString()))
-            continue;
-        nodes.add(link.toString());
-        const block = await events.get(link);
-        yield `  node [shape=oval]; ${link} [label="${renderNodeLabel(block)}" fontname="Courier"];`;
-        for (const p of block.value.parents) {
-            yield `  ${link} -> ${p};`;
-        }
-        links.push(...block.value.parents);
-    }
-    yield '}';
-}
-export async function findEventsToSync(blocks, head) {
-    // const callTag = Math.random().toString(36).substring(7)
-    const events = new EventFetcher(blocks);
-    // console.time(callTag + '.findCommonAncestorWithSortedEvents')
-    const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head);
-    // console.timeEnd(callTag + '.findCommonAncestorWithSortedEvents')
-    // console.log('sorted', !!ancestor, sorted)
-    // console.time(callTag + '.contains')
-    const toSync = ancestor ? await asyncFilter(sorted, async (uks) => !(await contains(events, ancestor, uks.cid))) : sorted;
-    // console.timeEnd(callTag + '.contains')
-    const sortDifference = sorted.length - toSync.length;
-    if (sortDifference / sorted.length > 0.6)
-        console.log('optimize sorted', !!ancestor, sortDifference);
-    return { cids: events, events: toSync };
-}
-const asyncFilter = async (arr, predicate) => Promise.all(arr.map(predicate)).then(results => arr.filter((_v, index) => results[index]));
-export async function findCommonAncestorWithSortedEvents(events, children, doFull = false) {
-    // console.trace('findCommonAncestorWithSortedEvents')
-    // const callTag = Math.random().toString(36).substring(7)
-    // console.log(callTag + '.children', children.map((c) => c.toString()))
-    // console.time(callTag + '.findCommonAncestor')
-    const ancestor = await findCommonAncestor(events, children);
-    // console.timeEnd(callTag + '.findCommonAncestor')
-    // console.log('ancestor', ancestor.toString())
-    if (!ancestor) {
-        console.log('no common ancestor', children);
-        // throw new Error('no common ancestor')
-        const sorted = await findSortedEvents(events, children, children, doFull);
-        return { ancestor: null, sorted };
-    }
-    // console.time(callTag + '.findSortedEvents')
-    const sorted = await findSortedEvents(events, children, [ancestor], doFull);
-    // console.timeEnd(callTag + '.findSortedEvents')
-    // console.log('sorted', sorted.length)
-    // console.log('ancestor', JSON.stringify(ancestor, null, 2))
-    return { ancestor, sorted };
-}
-/**
- * Find the common ancestor event of the passed children. A common ancestor is
- * the first single event in the DAG that _all_ paths from children lead to.
- *
- * @param {import('./clock').EventFetcher} events
- * @param  {import('./clock').EventLink<EventData>[]} children
- */
-// async function NEWfindCommonAncestor (events, children) {
-//   if (!children.length) return
-//   if (children.length === 1) return children[0]
-//   const candidates = children.map(c => [c])
-//   const visited = new Set()
-//   while (true) {
-//     let changed = false
-//     for (const c of candidates) {
-//       const candidate = await findAncestorCandidate(events, c[c.length - 1])
-//       if (!candidate) continue
-//       if (visited.has(candidate)) {
-//         return candidate // Common ancestor found
-//       }
-//       visited.add(candidate)
-//       changed = true
-//       c.push(candidate)
-//     }
-//     if (!changed) {
-//       // No common ancestor found, exhausted candidates
-//       return null
-//     }
-//   }
-// }
-async function findCommonAncestor(events, children) {
-    if (!children.length)
-        return;
-    children = [...new Set(children)];
-    if (children.length === 1)
-        return children[0];
-    const candidates = children.map((c) => [c]);
-    // console.log(
-    //   'og candidates',
-    //   candidates.map((c) => c.toString())
-    // )
-    while (true) {
-        let changed = false;
-        for (const c of candidates) {
-            const candidate = await findAncestorCandidate(events, c[c.length - 1]);
-            if (!candidate)
-                continue;
-            // Check if the candidate is already in the list, and if so, skip it.
-            if (c.includes(candidate))
-                continue;
-            // if set size is all cids, then no common ancestor
-            changed = true;
-            c.push(candidate); // make set?
-            // console.log('candidate', candidates.map((c) => c.toString()))
-            const ancestor = findCommonString(candidates);
-            if (ancestor)
-                return ancestor;
-        }
-        if (!changed)
-            return;
-    }
-}
-// async function OGfindCommonAncestor (events, children) {
-//   if (!children.length) return
-//   if (children.length === 1) return children[0]
-//   const candidates = children.map(c => [c])
-//   console.log(
-//     'og candidates',
-//     candidates.map(c => c.toString())
-//   )
-//   while (true) {
-//     let changed = false
-//     for (const c of candidates) {
-//       const candidate = await findAncestorCandidate(events, c[c.length - 1])
-//       if (!candidate) continue
-//       // if set size is all cids, then no common ancestor
-//       changed = true
-//       c.push(candidate) // make set?
-//       console.log(
-//         'candidate',
-//         candidates.map(c => c.toString())
-//       )
-//       const ancestor = findCommonString(candidates)
-//       if (ancestor) return ancestor
-//     }
-//     if (!changed) return
-//   }
-// }
-/**
- * @param {import('./clock').EventFetcher} events
- * @param {import('./clock').EventLink<EventData>} root
- */
-async function findAncestorCandidate(events, root) {
-    const { value: event } = await events.get(root); // .catch(() => ({ value: { parents: [] } }))
-    // console.log(
-    //   'findAncestorCandidate',
-    //   root.toString(),
-    //   'parents',
-    //   event.parents.map(p => p.toString())
-    // )
-    if (!event.parents.length)
-        return root;
-    return event.parents.length === 1 ? event.parents[0] : findCommonAncestor(events, event.parents);
-}
-/**
- * @template {{ toString: () => string }} T
- * @param  {Array<T[]>} arrays
- */
-function findCommonString(arrays) {
-    // console.log('findCommonString', arrays.map((a) => a.map((i) => String(i))))
-    arrays = arrays.map(a => [...a]);
-    for (const arr of arrays) {
-        for (const item of arr) {
-            let matched = true;
-            for (const other of arrays) {
-                if (arr === other)
-                    continue;
-                matched = other.some(i => String(i) === String(item));
-                if (!matched)
-                    break;
-            }
-            if (matched)
-                return item;
-        }
-    }
-}
-/**
- * Find and sort events between the head(s) and the tail.
- * @param {import('./clock').EventFetcher} events
- * @param {any[]} head
- * @param {import('./clock').EventLink<EventData>[]} tails
- */
-async function findSortedEvents(events, head, tails, doFull) {
-    // const callTag = Math.random().toString(36).substring(7)
-    // get weighted events - heavier events happened first
-    // const callTag = Math.random().toString(36).substring(7)
-    /** @type {Map<string, { event: import('./clock').EventBlockView<EventData>, weight: number }>} */
-    const weights = new Map();
-    head = [...new Set([...head.map(h => h.toString())])];
-    // console.log(callTag + '.head', head.length)
-    const allEvents = new Set([tails.map((t) => t.toString()).toString(), ...head]);
-    if (!doFull && allEvents.size === 1) {
-        // console.log('head contains tail', tail.toString())
-        return [];
-        // const event = await events.get(tail)
-        // return [event]
-    }
-    // console.log('finding events')
-    // console.log(callTag + '.head', head.length, [...head.map((h) => h.toString())], tail.toString())
-    // console.time(callTag + '.findEvents')
-    const all = await (await Promise.all(tails.map((t) => Promise.all(head.map(h => findEvents(events, h, t)))))).flat();
-    // console.log('all', all.length)
-    // console.timeEnd(callTag + '.findEvents')
-    for (const arr of all) {
-        for (const { event, depth } of arr) {
-            // console.log('event value', event.value.data.value)
-            const info = weights.get(event.cid.toString());
-            if (info) {
-                info.weight += depth;
-            }
-            else {
-                weights.set(event.cid.toString(), { event, weight: depth });
-            }
-        }
-    }
-    // group events into buckets by weight
-    /** @type {Map<number, import('./clock').EventBlockView<EventData>[]>} */
-    const buckets = new Map();
-    for (const { event, weight } of weights.values()) {
-        const bucket = buckets.get(weight);
-        if (bucket) {
-            bucket.push(event);
-        }
-        else {
-            buckets.set(weight, [event]);
-        }
-    }
-    // sort by weight, and by CID within weight
-    const sorted = Array.from(buckets)
-        .sort((a, b) => b[0] - a[0])
-        .flatMap(([, es]) => es.sort((a, b) => (String(a.cid) < String(b.cid) ? -1 : 1)));
-    // console.log('sorted', sorted.map(s => s.cid))
-    return sorted;
-}
-/**
- * @param {EventFetcher} events
- * @param {EventLink<EventData>} start
- * @param {EventLink<EventData>} end
- * @returns {Promise<Array<{ event: EventBlockView<EventData>, depth: number }>>}
- */
-async function findEvents(events, start, end, depth = 0) {
-    // console.log('findEvents', start.toString(), end.toString(), depth)
-    const event = await events.get(start);
-    const send = String(end);
-    const acc = [{ event, depth }];
-    const { parents } = event.value;
-    // if (parents.length === 1 && String(parents[0]) === send) return acc
-    if (parents.findIndex(p => String(p) === send) !== -1)
-        return acc;
-    // if (parents.length === 1) return acc
-    const rest = await Promise.all(parents.map(p => findEvents(events, p, end, depth + 1)));
-    return acc.concat(...rest);
-}

package/dist/crypto.js

@@ -1,63 +0,0 @@
-// @ts-nocheck
-import * as codec from './encrypted-block.js';
-import { create, load } from 'prolly-trees/cid-set';
-import { CID } from 'multiformats';
-import { encode, decode, create as mfCreate } from 'multiformats/block';
-import * as dagcbor from '@ipld/dag-cbor';
-import { sha256 as hasher } from 'multiformats/hashes/sha2';
-const createBlock = (bytes, cid) => mfCreate({ cid, bytes, hasher, codec });
-const encrypt = async function* ({ get, cids, hasher, key, cache, chunker, root }) {
-    const set = new Set();
-    let eroot;
-    for (const string of cids) {
-        const cid = CID.parse(string);
-        let unencrypted = await get(cid);
-        if (!unencrypted.cid) {
-            unencrypted = { cid, bytes: unencrypted };
-        }
-        // console.log('unencrypted', unencrypted)
-        const block = await encode({ ...await codec.encrypt({ ...unencrypted, key }), codec, hasher });
-        // console.log(`encrypting ${string} as ${block.cid}`)
-        yield block;
-        set.add(block.cid.toString());
-        if (unencrypted.cid.equals(root))
-            eroot = block.cid;
-    }
-    if (!eroot)
-        throw new Error('cids does not include root');
-    const list = [...set].map(s => CID.parse(s));
-    let last;
-    for await (const node of create({ list, get, cache, chunker, hasher, codec: dagcbor })) {
-        const block = await node.block;
-        yield block;
-        last = block;
-    }
-    const head = [eroot, last.cid];
-    const block = await encode({ value: head, codec: dagcbor, hasher });
-    yield block;
-};
-const decrypt = async function* ({ root, get, key, cache, chunker, hasher }) {
-    const o = { ...await get(root), codec: dagcbor, hasher };
-    const decodedRoot = await decode(o);
-    // console.log('decodedRoot', decodedRoot)
-    const { value: [eroot, tree] } = decodedRoot;
-    const rootBlock = await get(eroot); // should I decrypt?
-    const cidset = await load({ cid: tree, get, cache, chunker, codec, hasher });
-    const { result: nodes } = await cidset.getAllEntries();
-    const unwrap = async (eblock) => {
-        const { bytes, cid } = await codec.decrypt({ ...eblock, key }).catch(e => {
-            // console.log('ekey', e)
-            throw new Error('bad key: ' + key.toString('hex'));
-        });
-        const block = await createBlock(bytes, cid);
-        return block;
-    };
-    const promises = [];
-    for (const { cid } of nodes) {
-        if (!rootBlock.cid.equals(cid))
-            promises.push(get(cid).then(unwrap));
-    }
-    yield* promises;
-    yield unwrap(rootBlock);
-};
-export { encrypt, decrypt };