@aztec/kv-store 0.0.1-commit.9ef841308 → 0.0.1-commit.a5db02d

package/dest/sqlite-opfs/store.js

@@ -0,0 +1,281 @@
+import { SerialQueue } from '@aztec/foundation/queue';
+import { SQLiteOPFSAztecArray } from './array.js';
+import { SqliteEncryptionError } from './errors.js';
+import { SQLiteOPFSAztecMap } from './map.js';
+import { SQLiteOPFSAztecMultiMap } from './multi_map.js';
+import { SQLiteOPFSAztecSet } from './set.js';
+import { SQLiteOPFSAztecSingleton } from './singleton.js';
+/**
+ * Main-thread handle for a SQLite database persisted to OPFS via the `opfs-sahpool`
+ * VFS. Owns a dedicated Web Worker (the SAH Pool VFS requires Worker context) and
+ * routes every SQL op through it via typed postMessage RPC.
+ *
+ * Transaction ordering is guaranteed by a `SerialQueue` on the main thread combined
+ * with an `#inTx` flag: outside a `transactionAsync` block, each op acquires the
+ * queue for its own auto-commit; inside a block, the outer call holds the queue and
+ * nested ops bypass it to avoid deadlock.
+ */ export class AztecSQLiteOPFSStore {
+    isEphemeral;
+    #worker;
+    #pending;
+    #txQueue;
+    #name;
+    #log;
+    #nextId;
+    #inTx;
+    #closed;
+    constructor(worker, name, log, isEphemeral){
+        this.isEphemeral = isEphemeral;
+        this.#pending = new Map();
+        this.#txQueue = new SerialQueue();
+        this.#nextId = 0;
+        this.#inTx = false;
+        this.#closed = false;
+        this.#worker = worker;
+        this.#name = name;
+        this.#log = log;
+        this.#worker.onmessage = (ev)=>{
+            const { id } = ev.data;
+            const handler = this.#pending.get(id);
+            if (!handler) {
+                this.#log.warn(`SQLite worker: no pending handler for id ${id}`);
+                return;
+            }
+            this.#pending.delete(id);
+            handler.resolve(ev.data);
+        };
+        this.#worker.onerror = (ev)=>{
+            this.#log.error(`SQLite worker crashed: ${ev.message}`);
+            this.#rejectPending(`SQLite worker crashed: ${ev.message}`);
+        };
+        this.#txQueue.start();
+    }
+    /**
+   * Opens (or creates) a SQLite database stored in the OPFS SAH Pool. When `ephemeral`
+   * is true the database lives only in memory and is lost when the worker terminates.
+   * Pass `poolDirectory` to place the SAH Pool in a non-default OPFS subdirectory —
+   * required when multiple stores coexist in the same tab, because the SAH Pool holds
+   * an exclusive lock on its directory.
+   *
+   * Pass `encryptionKey` (exactly 32 bytes) to enable at-rest encryption via sqlite3mc's
+   * ChaCha20 page cipher. The key buffer is **transferred** to the worker — its
+   * ArrayBuffer detaches on the caller side after `postMessage`. This is intentional:
+   * the API encodes a one-key-one-owner invariant. A caller that wants to use the same
+   * key for multiple stores must explicitly clone it per call (e.g.
+   * `new Uint8Array(savedKey)`), making the duplication a visible, deliberate decision
+   * rather than a silent structured-clone operation. The default path (one `.open()`,
+   * one consumption of the key) leaves zero key bytes on the main thread after the call.
+   */ static async open(log, name, ephemeral = false, poolDirectory, encryptionKey) {
+        if (encryptionKey !== undefined && encryptionKey.length !== 32) {
+            throw new SqliteEncryptionError('invalid_key_length', `encryptionKey must be 32 bytes (got ${encryptionKey.length})`);
+        }
+        if (encryptionKey !== undefined && ephemeral) {
+            throw new SqliteEncryptionError('encryption_not_supported_for_ephemeral', 'encryptionKey is not supported for ephemeral (:memory:) stores');
+        }
+        const dbName = name && !ephemeral ? name : `tmp-${globalThis.crypto.getRandomValues(new Uint8Array(8)).join('')}`;
+        log.debug(`Opening SQLite-OPFS ${ephemeral ? 'ephemeral ' : ''}${encryptionKey ? 'encrypted ' : ''}database ${dbName}`);
+        const worker = new Worker(new URL('./worker.js', import.meta.url), {
+            type: 'module'
+        });
+        const store = new AztecSQLiteOPFSStore(worker, dbName, log, ephemeral);
+        // Transfer (not clone) the key buffer to the worker so we don't leave a
+        // second copy on the main thread. Caveat: this detaches the caller's
+        // encryptionKey.buffer — subsequent reads from the same Uint8Array are empty.
+        const transfer = encryptionKey ? [
+            encryptionKey.buffer
+        ] : undefined;
+        try {
+            await store.#sendRequest({
+                type: 'init',
+                id: store.#allocId(),
+                dbName,
+                ephemeral,
+                poolDirectory,
+                encryptionKey
+            }, transfer);
+        } catch (err) {
+            worker.terminate();
+            throw err;
+        }
+        return store;
+    }
+    openMap(name) {
+        return new SQLiteOPFSAztecMap(this, name);
+    }
+    openSet(name) {
+        return new SQLiteOPFSAztecSet(this, name);
+    }
+    openMultiMap(name) {
+        return new SQLiteOPFSAztecMultiMap(this, name);
+    }
+    openCounter(_name) {
+        throw new Error('Method not implemented.');
+    }
+    openArray(name) {
+        return new SQLiteOPFSAztecArray(this, name);
+    }
+    openSingleton(name) {
+        return new SQLiteOPFSAztecSingleton(this, name);
+    }
+    transactionAsync(callback) {
+        // Nested calls join the outer transaction — SQLite does not support nested BEGIN,
+        // and re-acquiring the SerialQueue while the outer call holds it would deadlock.
+        // Errors in the nested callback propagate to the outer catch, which rolls back the
+        // whole thing (the standard "nested tx = savepoint-free join" semantic).
+        if (this.#inTx) {
+            return callback();
+        }
+        return this.#txQueue.put(async ()=>{
+            this.#inTx = true;
+            await this.#sendRequest({
+                type: 'begin',
+                id: this.#allocId()
+            });
+            try {
+                const result = await callback();
+                await this.#sendRequest({
+                    type: 'commit',
+                    id: this.#allocId()
+                });
+                return result;
+            } catch (err) {
+                await this.#sendRequest({
+                    type: 'rollback',
+                    id: this.#allocId()
+                }).catch((rollbackErr)=>this.#log.warn(`SQLite ROLLBACK failed: ${rollbackErr instanceof Error ? rollbackErr.message : rollbackErr}`));
+                throw err;
+            } finally{
+                this.#inTx = false;
+            }
+        });
+    }
+    async clear() {
+        await this.runAsync('DELETE FROM data');
+    }
+    async delete() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        await this.#txQueue.end();
+        await this.#sendRequest({
+            type: 'deleteDb',
+            id: this.#allocId(),
+            dbName: this.#name
+        }).catch((err)=>this.#log.warn(`SQLite deleteDb failed: ${err instanceof Error ? err.message : err}`));
+        this.#worker.terminate();
+        this.#rejectPending('SQLite store deleted');
+    }
+    /**
+   * Placeholder — returns zeros to mirror the IndexedDB backend. SQLite exposes real
+   * numbers cheaply via `PRAGMA page_count` / `page_size` / `freelist_count` and
+   * `SELECT COUNT(*) FROM data`, which would populate `physicalFileSize`, `actualSize`,
+   * and `numItems` meaningfully (`mappingSize` stays 0 — it's an LMDB mmap concept).
+   * Upgrade when any caller actually consumes these values; all current consumers
+   * tolerate zeros.
+   */ estimateSize() {
+        return Promise.resolve({
+            mappingSize: 0,
+            physicalFileSize: 0,
+            actualSize: 0,
+            numItems: 0
+        });
+    }
+    async close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        await this.#txQueue.end();
+        await this.#sendRequest({
+            type: 'close',
+            id: this.#allocId()
+        }).catch(()=>{});
+        this.#worker.terminate();
+        this.#rejectPending('SQLite store closed');
+    }
+    backupTo(_dstPath, _compact) {
+        throw new Error('Method not implemented.');
+    }
+    /**
+   * Returns a raw SQLite image (bytes suitable for writing as a `.sqlite` file and
+   * opening in any SQLite tool). Works only for non-ephemeral DBs because the OPFS
+   * SAH Pool has to be initialized. Useful for inspection/debugging.
+   */ async exportDb() {
+        const resp = await this.#sendRequest({
+            type: 'export',
+            id: this.#allocId()
+        });
+        if (!('bytes' in resp) || !resp.bytes) {
+            throw new Error('exportDb: worker returned no bytes');
+        }
+        return resp.bytes;
+    }
+    /**
+   * Runs a write statement (INSERT/UPDATE/DELETE/DDL). If called inside a
+   * `transactionAsync` block, bypasses the queue; otherwise acquires it so the
+   * op runs in its own auto-commit.
+   */ runAsync(sql, bind) {
+        const send = ()=>this.#sendRequest({
+                type: 'run',
+                id: this.#allocId(),
+                sql,
+                bind
+            }).then((r)=>({
+                    changes: 'changes' in r ? r.changes ?? 0 : 0
+                }));
+        return this.#inTx ? send() : this.#txQueue.put(send);
+    }
+    /** Runs a SELECT statement and returns rows in array row-mode. */ allAsync(sql, bind) {
+        const send = ()=>this.#sendRequest({
+                type: 'all',
+                id: this.#allocId(),
+                sql,
+                bind
+            }).then((r)=>'rows' in r ? r.rows ?? [] : []);
+        return this.#inTx ? send() : this.#txQueue.put(send);
+    }
+    #allocId() {
+        return ++this.#nextId;
+    }
+    /**
+   * Reject any in-flight requests with `reason`, so callers awaiting a response to a
+   * request sent to a now-terminated worker don't hang forever. Called from
+   * close()/delete() and from the worker.onerror handler.
+   */ #rejectPending(reason) {
+        if (this.#pending.size === 0) {
+            return;
+        }
+        const err = new Error(reason);
+        for (const { reject } of this.#pending.values()){
+            reject(err);
+        }
+        this.#pending.clear();
+    }
+    #sendRequest(req, transfer) {
+        return new Promise((resolve, reject)=>{
+            this.#pending.set(req.id, {
+                resolve: (resp)=>{
+                    if (resp.type === 'err') {
+                        // Re-hydrate encryption-shaped errors as the typed class so consumers
+                        // can pattern-match on `instanceof SqliteEncryptionError`. Plain
+                        // errors stay plain — the wire protocol only tags encryption paths.
+                        if (resp.encryptionCode !== undefined) {
+                            reject(new SqliteEncryptionError(resp.encryptionCode, resp.message));
+                        } else {
+                            reject(new Error(resp.message));
+                        }
+                    } else {
+                        resolve(resp);
+                    }
+                },
+                reject
+            });
+            if (transfer && transfer.length > 0) {
+                this.#worker.postMessage(req, transfer);
+            } else {
+                this.#worker.postMessage(req);
+            }
+        });
+    }
+}

package/dest/sqlite-opfs/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsaXRlLW9wZnMvd29ya2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dest/sqlite-opfs/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/sqlite-opfs/worker.ts"],"names":[],"mappings":""}

package/dest/sqlite-opfs/worker.js

@@ -0,0 +1,264 @@
+/// <reference lib="webworker" />
+import sqlite3InitModule from '@aztec/sqlite3mc-wasm';
+import { SqliteEncryptionError, isDecryptFailureMessage } from './errors.js';
+const SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS data (
+    slot TEXT NOT NULL PRIMARY KEY,
+    container TEXT NOT NULL,
+    key BLOB NOT NULL,
+    key_count INTEGER NOT NULL,
+    hash TEXT NOT NULL,
+    value BLOB
+  ) WITHOUT ROWID;
+
+  CREATE INDEX IF NOT EXISTS idx_container_key ON data(container, key);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_container_key_count ON data(container, key, key_count);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_container_key_hash ON data(container, key, hash);
+`;
+const DEFAULT_SAH_POOL_DIRECTORY = '.aztec-kv';
+const SAH_POOL_VFS_NAME = 'aztec-kv-opfs';
+const MC_SAH_POOL_VFS_NAME = `multipleciphers-${SAH_POOL_VFS_NAME}`;
+let sqlite3;
+let pool;
+let db;
+let dbPath;
+async function ensurePool(directory) {
+    const s = sqlite3 ??= await sqlite3InitModule();
+    if (!pool) {
+        pool = await s.installOpfsSAHPoolVfs({
+            name: SAH_POOL_VFS_NAME,
+            directory,
+            initialCapacity: 8
+        });
+        // Register a sqlite3mc-wrapped VFS pointing at our SAH Pool VFS.
+        // Encrypted DBs must be opened through this wrapper so sqlite3mc can
+        // intercept file I/O; plain DBs continue using the SAH Pool VFS directly.
+        // The wrapper name is `multipleciphers-<underlying>`.
+        s.capi.sqlite3mc_vfs_create(SAH_POOL_VFS_NAME, 0);
+    }
+    return pool;
+}
+/**
+ * Applies sqlite3mc's ChaCha20 page cipher using a pre-derived 32-byte key.
+ * The PRAGMAs must run before any schema DDL so sqlite3mc can decrypt existing
+ * pages and encrypt new ones. Zeroes the caller-held key array after the PRAGMA
+ * completes to minimize residency of the raw key bytes outside sqlite3mc's heap.
+ */ function applyEncryptionKey(conn, key) {
+    const hex = Array.from(key, (b)=>b.toString(16).padStart(2, '0')).join('');
+    conn.exec(`PRAGMA cipher = 'chacha20'`);
+    conn.exec(`PRAGMA key = "x'${hex}'"`);
+    key.fill(0);
+}
+async function handleInit(dbName, ephemeral, directory, encryptionKey) {
+    const s = sqlite3 ??= await sqlite3InitModule();
+    if (encryptionKey !== undefined && ephemeral) {
+        throw new SqliteEncryptionError('encryption_not_supported_for_ephemeral', 'encryptionKey is not supported for ephemeral (:memory:) stores');
+    }
+    if (ephemeral) {
+        db = new s.oo1.DB(':memory:', 'c');
+    } else {
+        const activePool = await ensurePool(directory ?? DEFAULT_SAH_POOL_DIRECTORY);
+        dbPath = normalizeDbPath(dbName);
+        if (encryptionKey !== undefined) {
+            const conn = new s.oo1.DB({
+                filename: dbPath,
+                flags: 'c',
+                vfs: MC_SAH_POOL_VFS_NAME
+            });
+            db = conn;
+            applyEncryptionKey(conn, encryptionKey);
+        } else {
+            db = new activePool.OpfsSAHPoolDb(dbPath);
+        }
+    }
+    runSql(SCHEMA_SQL);
+}
+function handleClose() {
+    db?.close();
+    db = undefined;
+    dbPath = undefined;
+    releasePool();
+}
+/**
+ * Releases the SAH pool's OPFS sync access handles before the terminal RPC is acked. Worker
+ * termination releases them only asynchronously, so without this a caller that deletes or reopens
+ * the store directory right after close()/delete() resolves races Chromium's cleanup
+ * (NoModificationAllowedError from removeEntry, or a hang installing a new pool on the directory).
+ * pauseVfs releases the handles without touching file contents; the worker is terminated right
+ * after, so the pool is never resumed.
+ */ function releasePool() {
+    pool?.pauseVfs();
+    pool = undefined;
+}
+async function handleExport() {
+    if (!db || !dbPath) {
+        throw new Error('SQLite worker: no database open to export');
+    }
+    if (!pool) {
+        throw new Error('SQLite worker: no SAH Pool available (ephemeral DBs cannot be exported)');
+    }
+    return await pool.exportFile(dbPath);
+}
+function handleDeleteDb(dbName) {
+    const path = normalizeDbPath(dbName);
+    if (db && dbPath === path) {
+        db.close();
+        db = undefined;
+        dbPath = undefined;
+    }
+    // Ephemeral :memory: DBs never back a file — skip installing a pool just to unlink
+    // nothing. installOpfsSAHPoolVfs acquires an exclusive lock on the OPFS SAH
+    // directory, and under heavy test churn that can contend with workers from
+    // previous tests whose OPFS handles Chromium hasn't yet released, hanging the RPC
+    // and then the whole test run.
+    if (!pool) {
+        return;
+    }
+    try {
+        pool.unlink(path);
+    } catch  {
+    // File may not exist; ignore.
+    }
+    // Guarded because pauseVfs refuses (SQLITE_MISUSE) while any file is open through the VFS.
+    if (!db) {
+        releasePool();
+    }
+}
+function requireDb() {
+    if (!db) {
+        throw new Error('SQLite worker: no database open');
+    }
+    return db;
+}
+function runSql(sql, bind) {
+    const conn = requireDb();
+    conn.exec({
+        sql,
+        bind
+    });
+    return {
+        changes: conn.changes()
+    };
+}
+function selectAll(sql, bind) {
+    const conn = requireDb();
+    const rows = [];
+    conn.exec({
+        sql,
+        bind,
+        rowMode: 'array',
+        resultRows: rows
+    });
+    return rows;
+}
+function normalizeDbPath(dbName) {
+    return dbName.startsWith('/') ? dbName : `/${dbName}`;
+}
+function respond(msg) {
+    self.postMessage(msg);
+}
+self.onmessage = async (ev)=>{
+    const req = ev.data;
+    try {
+        switch(req.type){
+            case 'init':
+                await handleInit(req.dbName, req.ephemeral, req.poolDirectory, req.encryptionKey);
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'close':
+                handleClose();
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'deleteDb':
+                handleDeleteDb(req.dbName);
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'run':
+                {
+                    const { changes } = runSql(req.sql, req.bind);
+                    return respond({
+                        type: 'ok',
+                        id: req.id,
+                        changes
+                    });
+                }
+            case 'all':
+                {
+                    const rows = selectAll(req.sql, req.bind);
+                    return respond({
+                        type: 'ok',
+                        id: req.id,
+                        rows
+                    });
+                }
+            case 'export':
+                {
+                    const bytes = await handleExport();
+                    return respond({
+                        type: 'ok',
+                        id: req.id,
+                        bytes
+                    });
+                }
+            case 'begin':
+                runSql('BEGIN');
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'commit':
+                runSql('COMMIT');
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            case 'rollback':
+                runSql('ROLLBACK');
+                return respond({
+                    type: 'ok',
+                    id: req.id
+                });
+            default:
+                {
+                    const _exhaustive = req;
+                    throw new Error(`Unknown request: ${JSON.stringify(_exhaustive)}`);
+                }
+        }
+    } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        respond({
+            type: 'err',
+            id: req.id,
+            message,
+            encryptionCode: detectEncryptionCode(req, err, message)
+        });
+    }
+};
+/**
+ * Maps a thrown error during request handling to a typed encryption code, so the
+ * main thread can re-hydrate it as a {@link SqliteEncryptionError}. Returns
+ * `undefined` for non-encryption errors (preserves the existing untyped path).
+ *
+ * Two sources:
+ *   - The error was already a `SqliteEncryptionError` (pre-flight throws inside
+ *     this worker — e.g. ephemeral + encryptionKey). Forward its code as-is.
+ *   - The error came from SQLite/sqlite3mc with a known decrypt-failure message
+ *     during an `init` request. Both "wrong key supplied" and "no key supplied
+ *     to an encrypted DB" surface as SQLITE_NOTADB ("file is not a database") —
+ *     we don't constrain on `req.encryptionKey` because the no-key-on-encrypted-DB
+ *     case is exactly when the caller most needs the typed signal.
+ */ function detectEncryptionCode(req, err, message) {
+    if (err instanceof SqliteEncryptionError) {
+        return err.code;
+    }
+    if (req.type === 'init' && isDecryptFailureMessage(message)) {
+        return 'decrypt_failed';
+    }
+    return undefined;
+}

package/dest/stores/l2_tips_store.d.ts

@@ -1,6 +1,5 @@
-import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
-import { type L2BlockTag, L2TipsStoreBase } from '@aztec/stdlib/block';
-import { PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type BlockHash, type CheckpointId, type L2BlockTag, L2TipsStoreBase } from '@aztec/stdlib/block';
 import type { AztecAsyncKVStore } from '../interfaces/store.js';
 /**
  * Persistent implementation of L2 tips store backed by a KV store.
@@ -9,21 +8,16 @@ import type { AztecAsyncKVStore } from '../interfaces/store.js';
 export declare class L2TipsKVStore extends L2TipsStoreBase {
     private store;
     private readonly l2TipsStore;
+    private readonly l2TipCheckpointsStore;
     private readonly l2BlockHashesStore;
-    private readonly l2BlockNumberToCheckpointNumberStore;
-    private readonly l2CheckpointStore;
-    constructor(store: AztecAsyncKVStore, namespace: string);
+    constructor(store: AztecAsyncKVStore, namespace: string, initialBlockHash: BlockHash);
     protected getTip(tag: L2BlockTag): Promise<BlockNumber | undefined>;
     protected setTip(tag: L2BlockTag, blockNumber: BlockNumber): Promise<void>;
+    protected getTipCheckpoint(tag: L2BlockTag): Promise<CheckpointId | undefined>;
+    protected setTipCheckpoint(tag: L2BlockTag, checkpoint: CheckpointId): Promise<void>;
     protected getStoredBlockHash(blockNumber: BlockNumber): Promise<string | undefined>;
     protected setBlockHash(blockNumber: BlockNumber, hash: string): Promise<void>;
     protected deleteBlockHashesBefore(blockNumber: BlockNumber): Promise<void>;
-    protected getCheckpointNumberForBlock(blockNumber: BlockNumber): Promise<CheckpointNumber | undefined>;
-    protected setCheckpointNumberForBlock(blockNumber: BlockNumber, checkpointNumber: CheckpointNumber): Promise<void>;
-    protected deleteBlockToCheckpointBefore(blockNumber: BlockNumber): Promise<void>;
-    protected getCheckpoint(checkpointNumber: CheckpointNumber): Promise<PublishedCheckpoint | undefined>;
-    protected saveCheckpointData(checkpoint: PublishedCheckpoint): Promise<void>;
-    protected deleteCheckpointsBefore(checkpointNumber: CheckpointNumber): Promise<void>;
     protected runInTransaction<T>(fn: () => Promise<T>): Promise<T>;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDJfdGlwc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N0b3Jlcy9sMl90aXBzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQW9CLE1BQU0saUNBQWlDLENBQUM7QUFDaEYsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFFLEtBQUssWUFBWSxFQUFFLEtBQUssVUFBVSxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBRzFHLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFLaEU7OztHQUdHO0FBQ0gscUJBQWEsYUFBYyxTQUFRLGVBQWU7SUFNOUMsT0FBTyxDQUFDLEtBQUs7SUFMZixPQUFPLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBeUM7SUFDckUsT0FBTyxDQUFDLFFBQVEsQ0FBQyxxQkFBcUIsQ0FBZ0Q7SUFDdEYsT0FBTyxDQUFDLFFBQVEsQ0FBQyxrQkFBa0IsQ0FBcUM7SUFFeEUsWUFDVSxLQUFLLEVBQUUsaUJBQWlCLEVBQ2hDLFNBQVMsRUFBRSxNQUFNLEVBQ2pCLGdCQUFnQixFQUFFLFNBQVMsRUFNNUI7SUFFRCxTQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUFDLFdBQVcsR0FBRyxTQUFTLENBQUMsQ0FFbEU7SUFFRCxTQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxVQUFVLEVBQUUsV0FBVyxFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBRXpFO0lBRUQsVUFBZ0IsZ0JBQWdCLENBQUMsR0FBRyxFQUFFLFVBQVUsR0FBRyxPQUFPLENBQUMsWUFBWSxHQUFHLFNBQVMsQ0FBQyxDQU1uRjtJQUVELFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxHQUFHLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUVuRjtJQUVELFNBQVMsQ0FBQyxrQkFBa0IsQ0FBQyxXQUFXLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRWxGO0lBRUQsU0FBUyxDQUFDLFlBQVksQ0FBQyxXQUFXLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUU1RTtJQUVELFVBQWdCLHVCQUF1QixDQUFDLFdBQVcsRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUkvRTtJQUVELFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFLE1BQU0sT0FBTyxDQUFDLENBQUMsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FFOUQ7Q0FDRiJ9

package/dest/stores/l2_tips_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"l2_tips_store.d.ts","sourceRoot":"","sources":["../../src/stores/l2_tips_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,KAAK,UAAU,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;GAGG;AACH,qBAAa,aAAc,SAAQ,eAAe;IAO9C,OAAO,CAAC,KAAK;IANf,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqC;IACxE,OAAO,CAAC,QAAQ,CAAC,oCAAoC,CAA+C;IACpG,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA0C;IAE5E,YACU,KAAK,EAAE,iBAAiB,EAChC,SAAS,EAAE,MAAM,EASlB;IAED,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAElE;IAED,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE;IAED,SAAS,CAAC,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAElF;IAED,SAAS,CAAC,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5E;IAED,UAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAI/E;IAED,SAAS,CAAC,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAErG;IAED,SAAS,CAAC,2BAA2B,CAAC,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjH;IAED,UAAgB,6BAA6B,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAIrF;IAED,UAAgB,aAAa,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAM1G;IAED,SAAS,CAAC,kBAAkB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3E;IAED,UAAgB,uBAAuB,CAAC,gBAAgB,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIzF;IAED,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE9D;CACF"}
+{"version":3,"file":"l2_tips_store.d.ts","sourceRoot":"","sources":["../../src/stores/l2_tips_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAoB,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAG1G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAKhE;;;GAGG;AACH,qBAAa,aAAc,SAAQ,eAAe;IAM9C,OAAO,CAAC,KAAK;IALf,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyC;IACrE,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAgD;IACtF,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqC;IAExE,YACU,KAAK,EAAE,iBAAiB,EAChC,SAAS,EAAE,MAAM,EACjB,gBAAgB,EAAE,SAAS,EAM5B;IAED,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAElE;IAED,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE;IAED,UAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAMnF;IAED,SAAS,CAAC,gBAAgB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAEnF;IAED,SAAS,CAAC,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAElF;IAED,SAAS,CAAC,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5E;IAED,UAAgB,uBAAuB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAI/E;IAED,SAAS,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE9D;CACF"}