@based/db 0.0.1

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

@@ -0,0 +1,122 @@
+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

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

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,2 @@
+import { Csmt } from './types.js';
+export declare function createTree(createHash: () => any): Csmt;

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

@@ -0,0 +1,209 @@
+import { TreeKeyNil } from './types.js';
+import { distance, min, max } from './tree-utils.js';
+import membershipProof from './memebership-proof.js';
+export function createTree(createHash) {
+    let root = null;
+    function genHash(s) {
+        return createHash().update(s).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)
+            : genHash(Buffer.from(''));
+        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('Key exist');
+            }
+        }
+        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) {
+            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 diffAB(diffA, diffB, nodeA, nodeB) {
+        if (nodeA &&
+            nodeB &&
+            nodeA.key === nodeB.key &&
+            nodeA.hash.compare(nodeB.hash) === 0) {
+            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 && bHash.compare(nodeA.hash) === 0) {
+                // 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 && aHash.compare(nodeB.hash) === 0) {
+                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 && k <= left.key)
+            return search(left, k);
+        if (right && k <= right.key)
+            return search(right, k);
+        return null;
+    }
+    return {
+        getRoot: () => root,
+        insert: (k, h, data = null) => {
+            if (!(h instanceof Buffer)) {
+                throw new TypeError('`h` must be a Buffer');
+            }
+            const newLeaf = createLeaf(k, h, data);
+            root = root ? insert(root, newLeaf) : newLeaf;
+        },
+        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

@@ -0,0 +1,40 @@
+import { Proof } from './memebership-proof.js';
+export type TreeKey = number;
+export declare const TreeKeyNil = 0;
+export interface TreeNode {
+    hash: Buffer;
+    key: TreeKey;
+    data?: any;
+    left: TreeNode | null;
+    right: TreeNode | null;
+}
+export type KeyHashPair = [TreeKey, Buffer];
+export interface TreeDiff {
+    left: KeyHashPair[];
+    right: KeyHashPair[];
+}
+export interface Csmt {
+    /**
+     * Get the root node.
+     */
+    getRoot: () => TreeNode | null;
+    /**
+     * Insert a new key-hash pair.
+     */
+    insert: (k: TreeKey, h: Buffer, data?: any) => void;
+    /**
+     * Delete a key-hash pair from the tree.
+     */
+    delete: (k: TreeKey) => void;
+    /**
+     * Compute the diff between this and a given tree.
+     */
+    diff: (tree: Csmt) => 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) => void) => void;
+    search: (k: TreeKey) => TreeNode;
+}

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

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

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

@@ -0,0 +1,85 @@
+import { StrictSchema } from '@based/schema';
+import { SchemaTypeDef } from './schema/types.js';
+import { createTree } from './csmt/index.js';
+import { Worker, MessagePort } from 'node:worker_threads';
+import { TransformFns } from './migrate/index.js';
+export declare class DbWorker {
+    constructor(address: BigInt, db: DbServer);
+    db: DbServer;
+    channel: MessagePort;
+    worker: Worker;
+    resolvers: any[];
+    callback: (resolve: any) => void;
+    updateCtx(address: BigInt): Promise<void>;
+    getQueryBuf(buf: Buffer): Promise<Buffer>;
+}
+type OnSchemaChange = (schema: StrictSchema) => void;
+export declare class DbServer {
+    #private;
+    modifyBuf: SharedArrayBuffer;
+    dbCtxExternal: any;
+    schema: StrictSchema & {
+        lastId: number;
+    };
+    migrating: number;
+    schemaTypesParsed: {
+        [key: string]: SchemaTypeDef;
+    };
+    schemaTypesParsedById: Record<number, SchemaTypeDef>;
+    fileSystemPath: string;
+    maxModifySize: number;
+    merkleTree: ReturnType<typeof createTree>;
+    dirtyRanges: Set<number>;
+    csmtHashFun: {
+        update: (buf: Buffer) => any;
+        digest: (encoding?: BufferEncoding) => Buffer | string;
+        reset: () => void;
+    };
+    workers: DbWorker[];
+    availableWorkerIndex: number;
+    processingQueries: number;
+    modifyQueue: Buffer[];
+    queryQueue: Map<Function, Buffer>;
+    stopped: boolean;
+    onSchemaChange: OnSchemaChange;
+    constructor({ path, maxModifySize, onSchemaChange, }: {
+        path: string;
+        maxModifySize?: number;
+        onSchemaChange?: OnSchemaChange;
+    });
+    start(opts?: {
+        clean?: boolean;
+    }): Promise<void>;
+    save(): Promise<void>;
+    createCsmtHashFun: () => {
+        update: (buf: Buffer) => any;
+        digest: (encoding?: BufferEncoding) => Buffer | string;
+        reset: () => void;
+    };
+    sortIndexes: {
+        [type: number]: {
+            [field: number]: {
+                [start: number]: any;
+            };
+        };
+    };
+    createSortIndex(type: string, field: string): any;
+    destroySortIndex(type: string, field: string): any;
+    hasSortIndex(typeId: number, field: number, start: number): boolean;
+    migrateSchema(schema: StrictSchema, transform?: Record<string, (node: Record<string, any>) => Record<string, any> | [string, Record<string, any>]>): Promise<StrictSchema & {
+        lastId: number;
+    }>;
+    createSortIndexBuffer(typeId: number, field: number, start: number): any;
+    updateMerkleTree(): void;
+    putSchema(strictSchema: StrictSchema, fromStart?: boolean, transformFns?: TransformFns): (StrictSchema & {
+        lastId: number;
+    }) | Promise<StrictSchema & {
+        lastId: number;
+    }>;
+    modify(buf: Buffer): Record<number, number>;
+    getQueryBuf(buf: Buffer): Promise<Uint8Array>;
+    onQueryEnd(): void;
+    stop(noSave?: boolean): Promise<void>;
+    destroy(): Promise<void>;
+}
+export {};