@iden3/js-merkletree/dist/node/esm/lib/db/indexedDB.js

javascript sparse merkle tree library

var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _IndexedDBStorage_currentRoot;
import { Hash, ZERO_HASH } from '../hash/hash';
import { bytes2Hex } from '../utils';
import { get, set, createStore } from 'idb-keyval';
import { NODE_TYPE_EMPTY, NODE_TYPE_LEAF, NODE_TYPE_MIDDLE } from '../../constants';
import { NodeEmpty, NodeLeaf, NodeMiddle } from '../node/node';
export class IndexedDBStorage {
    constructor(_prefix, databaseName) {
        this._prefix = _prefix;
        _IndexedDBStorage_currentRoot.set(this, void 0);
        __classPrivateFieldSet(this, _IndexedDBStorage_currentRoot, ZERO_HASH, "f");
        this._prefixHash = bytes2Hex(_prefix);
        this._store = createStore(`${databaseName ?? IndexedDBStorage.storageName}-db`, IndexedDBStorage.storageName);
    }
    async get(k) {
        const kBytes = new Uint8Array([...this._prefix, ...k]);
        const key = bytes2Hex(kBytes);
        const obj = await get(key, this._store);
        if (obj === null || obj === undefined) {
            return undefined;
        }
        if (obj.type === NODE_TYPE_EMPTY) {
            return new NodeEmpty();
        }
        if (obj.type === NODE_TYPE_MIDDLE) {
            const cL = new Hash(Uint8Array.from(obj.childL.bytes));
            const cR = new Hash(Uint8Array.from(obj.childR.bytes));
            return new NodeMiddle(cL, cR);
        }
        if (obj.type === NODE_TYPE_LEAF) {
            const k = new Hash(Uint8Array.from(obj.entry[0].bytes));
            const v = new Hash(Uint8Array.from(obj.entry[1].bytes));
            return new NodeLeaf(k, v);
        }
        throw new Error(`error: value found for key ${key} is not of type Node`);
    }
    async put(k, n) {
        const kBytes = new Uint8Array([...this._prefix, ...k]);
        const key = bytes2Hex(kBytes);
        await set(key, n, this._store);
    }
    async getRoot() {
        if (!__classPrivateFieldGet(this, _IndexedDBStorage_currentRoot, "f").equals(ZERO_HASH)) {
            return __classPrivateFieldGet(this, _IndexedDBStorage_currentRoot, "f");
        }
        const root = await get(this._prefixHash, this._store);
        if (!root) {
            __classPrivateFieldSet(this, _IndexedDBStorage_currentRoot, ZERO_HASH, "f");
        }
        else {
            __classPrivateFieldSet(this, _IndexedDBStorage_currentRoot, new Hash(root.bytes), "f");
        }
        return __classPrivateFieldGet(this, _IndexedDBStorage_currentRoot, "f");
    }
    async setRoot(r) {
        await set(this._prefixHash, r, this._store);
        __classPrivateFieldSet(this, _IndexedDBStorage_currentRoot, r, "f");
    }
}
_IndexedDBStorage_currentRoot = new WeakMap();
IndexedDBStorage.storageName = 'merkle-tree';