@based/db 0.0.64 → 0.0.67

package/dist/src/client/query/serialize.js

@@ -1,26 +0,0 @@
-const walk = (q) => {
-    const obj = {};
-    for (const key in q) {
-        if (key === 'schema') {
-            obj[key] = q[key].type;
-        }
-        else {
-            // if PROPDEF
-            if (typeof q[key] === 'object') {
-                obj[key] = walk(q[key]);
-            }
-            else {
-                obj[key] = q[key];
-            }
-        }
-    }
-    return obj;
-};
-export const serialize = (q) => {
-    const obj = walk(q);
-    return JSON.stringify(obj);
-};
-export const parse = (str, parsedSchema) => {
-    //
-};
-//# sourceMappingURL=serialize.js.map

package/dist/src/server/DbWorker.d.ts

@@ -1,13 +0,0 @@
-import { Worker, MessagePort } from 'node:worker_threads';
-import { DbServer } from './index.js';
-export declare class DbWorker {
-    constructor(address: BigInt, db: DbServer, workerIndex: number);
-    db: DbServer;
-    channel: MessagePort;
-    worker: Worker;
-    resolvers: any[];
-    readyPromise: Promise<true>;
-    callback: (resolve: any) => void;
-    updateCtx(address: BigInt): Promise<void>;
-    getQueryBuf(buf: Uint8Array): Promise<Uint8Array>;
-}

package/dist/src/server/csmt/draw-dot.d.ts

@@ -1,4 +0,0 @@
-import { Csmt } from './index.js';
-type DataFormatter<T> = (data: T) => string;
-export default function draw<T = any>(csmt: Csmt<T>, dataFormatter?: DataFormatter<T>): string;
-export {};

package/dist/src/server/csmt/draw-dot.js

@@ -1,38 +0,0 @@
-import { encodeBase64 } from '@saulx/utils';
-function makeLabel(node) {
-    return `${node.key}\n${encodeBase64(node.hash).substring(0, 5)}`;
-}
-function wrapFormatter(dataFormatter, node) {
-    return `\n${dataFormatter(node.data).replace('"', '\\"')}`;
-}
-// This can be visualized with Graphviz dot.
-// Online: https://dreampuf.github.io/GraphvizOnline/?engine=dot
-export default function draw(csmt, dataFormatter) {
-    const root = csmt.getRoot();
-    const lines = [];
-    const nodes = [];
-    let i = 0;
-    const walk = (node, prev) => {
-        const cur = i;
-        const left = node.left;
-        const right = node.right;
-        const isLeaf = !left && !right;
-        nodes.push(`n${cur} [label="${makeLabel(node) + ((dataFormatter && node.data) ? wrapFormatter(dataFormatter, node) : '')}"${isLeaf ? ' shape=box' : ''}];`);
-        if (cur > 0) {
-            lines.push(`n${prev} -- n${cur}`);
-        }
-        if (left) {
-            i++;
-            walk(left, cur);
-        }
-        if (right) {
-            i++;
-            walk(right, cur);
-        }
-    };
-    if (root) {
-        walk(root, i);
-    }
-    return `graph ethane {\n${nodes.join('\n')}\n${lines.join('\n')}\n}`;
-}
-//# sourceMappingURL=draw-dot.js.map

package/dist/src/server/csmt/index.d.ts

@@ -1,4 +0,0 @@
-import drawDot from './draw-dot.js';
-export * from './types.js';
-export * from './tree.js';
-export { drawDot };

package/dist/src/server/csmt/index.js

@@ -1,5 +0,0 @@
-import drawDot from './draw-dot.js';
-export * from './types.js';
-export * from './tree.js';
-export { drawDot };
-//# sourceMappingURL=index.js.map

package/dist/src/server/csmt/match.d.ts

@@ -1,7 +0,0 @@
-type Predicate = (x: any) => boolean;
-type Func = (x: any) => any;
-declare const match: (x: any) => {
-    on: (pred: Predicate, fn: Func) => any;
-    otherwise: (fn: Func) => any;
-};
-export default match;

package/dist/src/server/csmt/match.js

@@ -1,10 +0,0 @@
-const matched = (x) => ({
-    on: () => matched(x),
-    otherwise: () => x,
-});
-const match = (x) => ({
-    on: (pred, fn) => (pred(x) ? matched(fn(x)) : match(x)),
-    otherwise: (fn) => fn(x),
-});
-export default match;
-//# sourceMappingURL=match.js.map

package/dist/src/server/csmt/memebership-proof.d.ts

@@ -1,7 +0,0 @@
-import { TreeKey, TreeNode } from './types.js';
-export declare enum Direction {
-    Left = "L",
-    Right = "R"
-}
-export type Proof = [TreeKey | null, TreeKey | null] | [TreeKey | Uint8Array, TreeKey | Direction][];
-export default function membershipProof<T = any>(root: TreeNode<T> | null, k: TreeKey): Proof;

package/dist/src/server/csmt/memebership-proof.js

@@ -1,122 +0,0 @@
-import { minInSubtree, maxInSubtree } from './tree-utils.js';
-import match from './match.js';
-export var Direction;
-(function (Direction) {
-    Direction["Left"] = "L";
-    Direction["Right"] = "R";
-})(Direction || (Direction = {}));
-function reverse(direction) {
-    switch (direction) {
-        case Direction.Left:
-            return Direction.Right;
-        case Direction.Right:
-            return Direction.Left;
-        default:
-            throw new TypeError('"direction" is not type of Direction');
-    }
-}
-function aeq(arr) {
-    return (x) => x.every((y, i) => y === arr[i]);
-}
-function isList(x) {
-    return Array.isArray(x) && x.length > 0 && Array.isArray(x[0]);
-}
-function nonMembershipProof(k, key, direction, sibling) {
-    return match([k > key, direction])
-        .on(aeq([true, Direction.Left]), () => [key, minInSubtree(sibling)])
-        .on(aeq([true, Direction.Right]), () => [key, null])
-        .on(aeq([false, Direction.Left]), () => [null, key])
-        .on(aeq([false, Direction.Right]), () => [maxInSubtree(sibling), key])
-        .otherwise(() => {
-        throw new TypeError('"direction" is not type of Direction');
-    });
-}
-function membershipProofR(sibling, direction, node, k) {
-    const left = node.left;
-    const right = node.right;
-    if (k === undefined || k === null) {
-        throw new TypeError('k is not a TreeKey');
-    }
-    // && would be more accurate here but there is never a case where only one
-    // would be set and thus this way we save on error handling later on.
-    if (!left || !right) {
-        if (!direction) {
-            throw new Error('"direction" must be set');
-        }
-        if (!sibling) {
-            throw new Error('"sibling" must be set');
-        }
-        // This is a leaf node
-        if (node.key === k) {
-            return [
-                [sibling.hash, reverse(direction)],
-                [node.hash, node.key],
-            ];
-        }
-        else {
-            // Find the non-membership proof otherwise
-            return nonMembershipProof(k, node.key, direction, sibling);
-        }
-    }
-    let result;
-    if (k <= left.key) {
-        // Going towards left child
-        result = membershipProofR(right, Direction.Left, left, k);
-    }
-    else if (k <= right.key) {
-        // Going towards right child
-        result = membershipProofR(left, Direction.Right, right, k);
-    }
-    else {
-        if (k > right.key) {
-            // The given key `k` is greater than any key in this tree.
-            // Trigger a proof for the largest key
-            return [right.key, null];
-        }
-        if (!direction) {
-            // TODO How should we set direction?
-            throw new TypeError('"Direction" must be set');
-        }
-        if (!sibling) {
-            throw new Error('"sibling" must be set');
-        }
-        // Find the non-membership proof otherwise
-        return nonMembershipProof(k, node.key, direction, sibling);
-    }
-    if (sibling) {
-        if (isList(result) && direction) {
-            // @ts-ignore the array thing is confusing for TS
-            return [[sibling.hash, reverse(direction)], ...result];
-        }
-        else if (result[1] === null && direction === Direction.Left) {
-            return [node.key, minInSubtree(sibling)];
-        }
-        else if (result[0] === null && direction === Direction.Right) {
-            return [maxInSubtree(sibling), node.key];
-        }
-    }
-    return result;
-}
-export default function membershipProof(root, k) {
-    if (!root) {
-        return [];
-    }
-    // Root has no sibling or direction so null is used
-    return (match(membershipProofR(null, null, root, k))
-        // The key is present in the tree
-        // Provide the proof in reverse order
-        .on((x) => isList(x), (r) => r.reverse())
-        // The key is greater than the largest element in the tree
-        // Provide a proof for the largest key
-        .on(([_, y]) => y === null, ([x, _]) => [...membershipProof(root, x), null])
-        // The key is smaller than the smallest element in the tree
-        // Provide a proof for the smallest key
-        .on(([x, _]) => x === null, ([_, y]) => [null, ...membershipProof(root, y)])
-        // The key is bounded by by two keys in the case of non-membership proff
-        // provide a proof for the bounding keys to exist
-        .otherwise(([x, y]) => [
-        membershipProof(root, x),
-        membershipProof(root, y),
-    ]));
-}
-//# sourceMappingURL=memebership-proof.js.map

package/dist/src/server/csmt/tree-utils.d.ts

@@ -1,6 +0,0 @@
-import { TreeKey, TreeNode } from './types.js';
-export declare function distance(x: TreeKey, y: TreeKey): TreeKey;
-export declare function min(x: TreeNode<any> | null, y: TreeNode<any> | null): TreeKey;
-export declare function max(x: TreeNode<any> | null, y: TreeNode<any> | null): TreeKey;
-export declare function minInSubtree(node: TreeNode<any>): TreeKey;
-export declare function maxInSubtree(node: TreeNode<any>): TreeKey;

package/dist/src/server/csmt/tree-utils.js

@@ -1,33 +0,0 @@
-import { TreeKeyNil } from './types.js';
-export function distance(x, y) {
-    let v = x ^ y;
-    let r = TreeKeyNil;
-    while ((v >>= 1)) {
-        r++;
-    }
-    return r;
-}
-export function min(x, y) {
-    const a = (x && x.key) || TreeKeyNil;
-    const b = (y && y.key) || TreeKeyNil;
-    return a < b ? a : b;
-}
-export function max(x, y) {
-    const a = (x && x.key) || TreeKeyNil;
-    const b = (y && y.key) || TreeKeyNil;
-    return a > b ? a : b;
-}
-// Find min key in a subtree.
-export function minInSubtree(node) {
-    if (!node.left) {
-        // We assume that the tree is always full and the last left node we can
-        // find is the min.
-        return node.key;
-    }
-    return minInSubtree(node.left);
-}
-// Find max key in a subtree.
-export function maxInSubtree(node) {
-    return node.key;
-}
-//# sourceMappingURL=tree-utils.js.map

package/dist/src/server/csmt/tree.d.ts

@@ -1,3 +0,0 @@
-import { Hash, Csmt } from './types.js';
-export declare function hashEq(a: Hash, b: Hash): boolean;
-export declare function createTree<T>(createHash: () => any): Csmt<T>;

package/dist/src/server/csmt/tree.js

@@ -1,270 +0,0 @@
-import { TreeKeyNil } from './types.js';
-import { distance, min, max } from './tree-utils.js';
-import membershipProof from './memebership-proof.js';
-import { equals } from '@saulx/utils';
-export function hashEq(a, b) {
-    return equals(a, b);
-}
-export function createTree(createHash) {
-    let root = null;
-    const emptyHash = createHash().digest();
-    function genNodeHash(lHash, rHash) {
-        return createHash().update(lHash).update(rHash).digest();
-    }
-    function createNode(left, right) {
-        const hash = left && right ? genNodeHash(left.hash, right.hash) : emptyHash;
-        return {
-            hash,
-            key: max(left, right),
-            left,
-            right,
-        };
-    }
-    function createLeaf(k, h, data) {
-        return {
-            hash: h,
-            key: k,
-            data,
-            left: null,
-            right: null,
-        };
-    }
-    /**
-     * Update node properties.
-     */
-    function updateNode(node) {
-        if (node.left || node.right) {
-            node.key = max(node.left, node.right);
-            if (node.left && node.right) {
-                node.hash = genNodeHash(node.left.hash, node.right.hash);
-            }
-        }
-    }
-    function insert(node, newLeaf) {
-        const { key: k } = newLeaf;
-        let left = node.left;
-        let right = node.right;
-        // Check if this is a leaf
-        if (!left && !right) {
-            const nodeKey = node.key;
-            if (nodeKey < k) {
-                return createNode(node, newLeaf);
-            }
-            else if (nodeKey > k) {
-                return createNode(newLeaf, node);
-            }
-            else {
-                throw new Error(`k=${k} exists`);
-            }
-        }
-        const lDist = distance(k, (left && left.key) || TreeKeyNil);
-        const rDist = distance(k, (right && right.key) || TreeKeyNil);
-        if (lDist < rDist) {
-            node.left = left ? insert(left, newLeaf) : newLeaf;
-        }
-        else if (lDist > rDist) {
-            node.right = right ? insert(right, newLeaf) : newLeaf;
-        }
-        else {
-            return k < min(left, right)
-                ? createNode(newLeaf, node)
-                : createNode(node, newLeaf);
-        }
-        updateNode(node);
-        return node;
-    }
-    function checkForLeaf(node, k) {
-        return !node.left && !node.right && node.key === k;
-    }
-    function deleteNode(node, k) {
-        const left = node.left;
-        const right = node.right;
-        if (!left || !right) {
-            if (node.data) {
-                if (node.key === k) {
-                    return null;
-                }
-                throw new Error(`k=${k} does not exist`);
-            }
-            else {
-                throw new Error('The tree is broken');
-            }
-        }
-        if (checkForLeaf(left, k) || checkForLeaf(right, k)) {
-            if (left.key === k) {
-                // The `left` node is discarded
-                return right;
-            }
-            else {
-                // The `right` node is discarded
-                return left;
-            }
-        }
-        else {
-            const lDist = distance(k, left.key);
-            const rDist = distance(k, right.key);
-            if (lDist < rDist) {
-                node.left = deleteNode(left, k);
-                updateNode(node);
-                return node;
-            }
-            else if (lDist > rDist) {
-                node.right = deleteNode(right, k);
-                updateNode(node);
-                return node;
-            }
-            else {
-                throw new Error(`k=${k} does not exist`);
-            }
-        }
-    }
-    function updateNodeHash(node) {
-        if (node.left && node.right) {
-            node.hash = genNodeHash(node.left.hash, node.right.hash);
-        }
-    }
-    function updateHash(node, k, hash) {
-        if (!node)
-            return;
-        const { left, right } = node;
-        if (k === node.key && !left && !right) {
-            node.hash = hash;
-        }
-        else {
-            if (left && left.key === k) {
-                updateHash(left, k, hash);
-                updateNodeHash(left);
-                updateNodeHash(node);
-                return;
-            }
-            if (right && right.key === k) {
-                updateHash(right, k, hash);
-                updateNodeHash(right);
-                updateNodeHash(node);
-                return;
-            }
-            const lDist = distance(k, (left && left.key) || TreeKeyNil);
-            const rDist = distance(k, (right && right.key) || TreeKeyNil);
-            if (left && lDist <= rDist) {
-                updateHash(left, k, hash);
-                updateNodeHash(left);
-                updateNodeHash(node);
-                return;
-            }
-            if (right && rDist <= lDist) {
-                updateHash(right, k, hash);
-                updateNodeHash(right);
-                updateNodeHash(node);
-                return;
-            }
-        }
-    }
-    function diffAB(diffA, diffB, nodeA, nodeB) {
-        if (nodeA &&
-            nodeB &&
-            nodeA.key === nodeB.key &&
-            hashEq(nodeA.hash, nodeB.hash)) {
-            return;
-        }
-        // No hash match
-        const leftA = nodeA && nodeA.left;
-        const leftB = nodeB && nodeB.left;
-        const rightA = nodeA && nodeA.right;
-        const rightB = nodeB && nodeB.right;
-        // Check if this is a leaf that is missing from the right tree
-        if (nodeA && !leftA && !rightA) {
-            const bHash = diffB.get(nodeA.key);
-            if (bHash && hashEq(bHash, nodeA.hash)) {
-                // The same leaf appears to exist in both trees
-                diffB.delete(nodeA.key);
-            }
-            else {
-                // The leaf doesn't exist or differs from the right tree
-                diffA.set(nodeA.key, nodeA.hash);
-            }
-        }
-        // Check if this is a leaf that is missing from the left tree
-        if (nodeB && !leftB && !rightB) {
-            const aHash = diffA.get(nodeB.key);
-            if (aHash && hashEq(aHash, nodeB.hash)) {
-                diffA.delete(nodeB.key);
-            }
-            else {
-                diffB.set(nodeB.key, nodeB.hash);
-            }
-        }
-        if (leftA || leftB) {
-            // Recurse to the left branch
-            diffAB(diffA, diffB, leftA, leftB);
-        }
-        if (rightA || rightB) {
-            // Recurse to the right branch
-            diffAB(diffA, diffB, rightA, rightB);
-        }
-    }
-    function diff(tree) {
-        const leftMap = new Map();
-        const rightMap = new Map();
-        const nodeA = root;
-        const nodeB = tree.getRoot();
-        diffAB(leftMap, rightMap, nodeA, nodeB);
-        return {
-            left: [...leftMap],
-            right: [...rightMap],
-        };
-    }
-    function _visitLeafNodes(node, cb) {
-        if (!node)
-            return;
-        if (!node.left && !node.right)
-            cb(node);
-        else {
-            if (node.left)
-                _visitLeafNodes(node.left, cb);
-            if (node.right)
-                _visitLeafNodes(node.right, cb);
-        }
-    }
-    function search(node, k) {
-        if (!node || (k === node.key && !node.left && !node.right))
-            return node;
-        const { left, right } = node;
-        if (left && left.key === k)
-            return search(left, k);
-        if (right && right.key === k)
-            return search(right, k);
-        const lDist = distance(k, (left && left.key) || TreeKeyNil);
-        const rDist = distance(k, (right && right.key) || TreeKeyNil);
-        if (left && lDist <= rDist)
-            return search(left, k);
-        if (right && rDist <= lDist)
-            return search(right, k);
-        return null;
-    }
-    return {
-        emptyHash,
-        getRoot: () => root,
-        insert: (k, h, data = null) => {
-            if (!(h instanceof Uint8Array)) {
-                throw new TypeError('`h` must be a Uint8Array');
-            }
-            const newLeaf = createLeaf(k, h, data);
-            root = root ? insert(root, newLeaf) : newLeaf;
-        },
-        update: (k, h) => {
-            if (root) {
-                updateHash(root, k, h);
-            }
-        },
-        delete: (k) => {
-            if (root) {
-                root = deleteNode(root, k);
-            }
-        },
-        diff,
-        membershipProof: (k) => membershipProof(root, k),
-        visitLeafNodes: (cb) => _visitLeafNodes(root, cb),
-        search: (k) => search(root, k),
-    };
-}
-//# sourceMappingURL=tree.js.map

package/dist/src/server/csmt/types.d.ts

@@ -1,46 +0,0 @@
-import { Proof } from './memebership-proof.js';
-export type TreeKey = number;
-export declare const TreeKeyNil = 0;
-export type Hash = Uint8Array;
-export interface TreeNode<T> {
-    hash: Hash;
-    key: TreeKey | null;
-    data?: T | null;
-    left: TreeNode<T> | null;
-    right: TreeNode<T> | null;
-}
-export type KeyHashPair = [TreeKey, Hash];
-export interface TreeDiff {
-    left: KeyHashPair[];
-    right: KeyHashPair[];
-}
-export interface Csmt<T> {
-    emptyHash: Uint8Array;
-    /**
-     * Get the root node.
-     */
-    getRoot: () => TreeNode<T> | null;
-    /**
-     * Insert a new key-hash pair.
-     */
-    insert: (k: TreeKey, h: Hash, data?: any) => void;
-    /**
-     * Delete a key-hash pair from the tree.
-     */
-    delete: (k: TreeKey) => void;
-    /**
-     * Update node hash.
-     */
-    update: (k: TreeKey, h: Hash) => void;
-    /**
-     * Compute the diff between this and a given tree.
-     */
-    diff: (tree: Csmt<T>) => TreeDiff;
-    /**
-     * Provide a proof of membership if a key exist in the three;
-     * Otherwise a proof of non-membership is returned.
-     */
-    membershipProof: (k: TreeKey) => Proof;
-    visitLeafNodes: (cb: (leaf: TreeNode<T>) => void) => void;
-    search: (k: TreeKey) => TreeNode<T>;
-}

package/dist/src/server/csmt/types.js

@@ -1,2 +0,0 @@
-export const TreeKeyNil = 0;
-//# sourceMappingURL=types.js.map

package/dist/src/server/worker.js

@@ -1,33 +0,0 @@
-import { isMainThread, parentPort, workerData } from 'node:worker_threads';
-import native from '../native.js';
-if (isMainThread) {
-    console.warn('running query worker.ts in mainthread - incorrect');
-}
-else if (workerData?.isDbWorker) {
-    let { address, channel } = workerData;
-    let dbCtx = native.externalFromInt(address);
-    native.workerCtxInit();
-    const handleMsg = (msg) => {
-        try {
-            if (typeof msg === 'bigint') {
-                // it's a ctx address
-                address = msg;
-                dbCtx = native.externalFromInt(address);
-                channel.postMessage(null);
-            }
-            else {
-                const arrayBuf = native.getQueryBuf(msg, dbCtx);
-                channel.postMessage(arrayBuf, [arrayBuf]);
-            }
-        }
-        catch (e) {
-            channel.postMessage(e);
-        }
-    };
-    channel.on('message', handleMsg);
-    parentPort.postMessage('READY');
-}
-else {
-    console.info('incorrect worker db query');
-}
-//# sourceMappingURL=worker.js.map