@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/storage/UnifiedSwapStorage.d.ts

@@ -0,0 +1,82 @@
+import { ChainType } from "@atomiqlabs/base";
+import { IUnifiedStorage, QueryParams } from "./IUnifiedStorage";
+import { ISwap } from "../swaps/ISwap";
+declare const indexes: readonly [{
+    readonly key: "id";
+    readonly type: "string";
+    readonly unique: true;
+    readonly nullable: false;
+}, {
+    readonly key: "escrowHash";
+    readonly type: "string";
+    readonly unique: true;
+    readonly nullable: true;
+}, {
+    readonly key: "type";
+    readonly type: "number";
+    readonly unique: false;
+    readonly nullable: false;
+}, {
+    readonly key: "initiator";
+    readonly type: "string";
+    readonly unique: false;
+    readonly nullable: false;
+}, {
+    readonly key: "state";
+    readonly type: "number";
+    readonly unique: false;
+    readonly nullable: false;
+}, {
+    readonly key: "paymentHash";
+    readonly type: "string";
+    readonly unique: false;
+    readonly nullable: true;
+}];
+/**
+ * Index types for swap storage
+ * @category Storage
+ */
+export type UnifiedSwapStorageIndexes = typeof indexes;
+declare const compositeIndexes: readonly [{
+    readonly keys: readonly ["initiator", "id"];
+    readonly unique: false;
+}, {
+    readonly keys: readonly ["type", "state"];
+    readonly unique: false;
+}, {
+    readonly keys: readonly ["type", "paymentHash"];
+    readonly unique: false;
+}, {
+    readonly keys: readonly ["type", "initiator", "state"];
+    readonly unique: false;
+}];
+/**
+ * Composite index types for swap storage
+ * @category Storage
+ */
+export type UnifiedSwapStorageCompositeIndexes = typeof compositeIndexes;
+/**
+ * Unified swap persistence layer with caching
+ * @category Storage
+ */
+export declare class UnifiedSwapStorage<T extends ChainType> {
+    readonly storage: IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>;
+    readonly weakRefCache: Map<string, WeakRef<ISwap<T>>>;
+    readonly noWeakRefMap?: boolean;
+    constructor(storage: IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedSwapStorageCompositeIndexes>, noWeakRefMap?: boolean);
+    init(): Promise<void>;
+    /**
+     * Params are specified in the following way:
+     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
+     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
+     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
+     * @param params
+     * @param reviver
+     */
+    query<S extends ISwap<T>>(params: Array<Array<QueryParams>>, reviver: (obj: any) => S | null | undefined): Promise<Array<S>>;
+    save<S extends ISwap<T>>(value: S): Promise<void>;
+    saveAll<S extends ISwap<T>>(values: S[]): Promise<void>;
+    remove<S extends ISwap<T>>(value: S): Promise<void>;
+    removeAll<S extends ISwap<T>>(values: S[]): Promise<void>;
+}
+export {};

package/dist/storage/UnifiedSwapStorage.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedSwapStorage = void 0;
+const Logger_1 = require("../utils/Logger");
+const logger = (0, Logger_1.getLogger)("UnifiedSwapStorage: ");
+const indexes = [
+    { key: "id", type: "string", unique: true, nullable: false },
+    { key: "escrowHash", type: "string", unique: true, nullable: true },
+    { key: "type", type: "number", unique: false, nullable: false },
+    { key: "initiator", type: "string", unique: false, nullable: false },
+    { key: "state", type: "number", unique: false, nullable: false },
+    { key: "paymentHash", type: "string", unique: false, nullable: true },
+];
+const compositeIndexes = [
+    { keys: ["initiator", "id"], unique: false },
+    { keys: ["type", "state"], unique: false },
+    { keys: ["type", "paymentHash"], unique: false },
+    { keys: ["type", "initiator", "state"], unique: false }
+];
+/**
+ * Unified swap persistence layer with caching
+ * @category Storage
+ */
+class UnifiedSwapStorage {
+    constructor(storage, noWeakRefMap) {
+        this.weakRefCache = new Map();
+        this.storage = storage;
+        this.noWeakRefMap = noWeakRefMap;
+    }
+    init() {
+        return this.storage.init(indexes, compositeIndexes);
+    }
+    /**
+     * Params are specified in the following way:
+     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
+     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
+     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
+     * @param params
+     * @param reviver
+     */
+    async query(params, reviver) {
+        const rawSwaps = await this.storage.query(params);
+        const result = [];
+        rawSwaps.forEach(rawObj => {
+            if (!this.noWeakRefMap) {
+                const savedRef = this.weakRefCache.get(rawObj.id)?.deref();
+                if (savedRef != null) {
+                    result.push(savedRef);
+                    return;
+                }
+                logger.debug("query(): Reviving new swap instance: " + rawObj.id);
+            }
+            const value = reviver(rawObj);
+            if (value == null)
+                return;
+            if (!this.noWeakRefMap)
+                this.weakRefCache.set(rawObj.id, new WeakRef(value));
+            result.push(value);
+        });
+        return result;
+    }
+    save(value) {
+        if (!this.noWeakRefMap)
+            this.weakRefCache.set(value.getId(), new WeakRef(value));
+        return this.storage.save(value.serialize());
+    }
+    saveAll(values) {
+        if (!this.noWeakRefMap)
+            values.forEach(value => this.weakRefCache.set(value.getId(), new WeakRef(value)));
+        return this.storage.saveAll(values.map(obj => obj.serialize()));
+    }
+    remove(value) {
+        if (!this.noWeakRefMap)
+            this.weakRefCache.delete(value.getId());
+        return this.storage.remove(value.serialize());
+    }
+    removeAll(values) {
+        if (!this.noWeakRefMap)
+            values.forEach(value => this.weakRefCache.delete(value.getId()));
+        return this.storage.removeAll(values.map(obj => obj.serialize()));
+    }
+}
+exports.UnifiedSwapStorage = UnifiedSwapStorage;

package/dist/storage-browser/IndexedDBUnifiedStorage.d.ts

@@ -0,0 +1,39 @@
+import { IUnifiedStorage, QueryParams, UnifiedStorageCompositeIndexes, UnifiedStoredObject } from "../storage/IUnifiedStorage";
+import { ISwap } from "../swaps/ISwap";
+import { SwapType } from "../enums/SwapType";
+import { UnifiedSwapStorageIndexes } from "../storage/UnifiedSwapStorage";
+import { LoggerType } from "../utils/Logger";
+export type QuerySetCondition = {
+    key: string;
+    values: Set<any>;
+};
+/**
+ * Browser IndexedDB storage implementation
+ * @category Storage
+ */
+export declare class IndexedDBUnifiedStorage implements IUnifiedStorage<UnifiedSwapStorageIndexes, UnifiedStorageCompositeIndexes> {
+    protected readonly logger: LoggerType;
+    storageKey: string;
+    db?: IDBDatabase;
+    constructor(storageKey: string);
+    private tryMigrateLocalStorage;
+    private tryMigrateOldIndexedDB;
+    tryMigrate(storageKeys: [string, SwapType][], reviver: (obj: any) => ISwap): Promise<boolean>;
+    private executeTransaction;
+    private executeTransactionArr;
+    private executeTransactionWithCursor;
+    init(): Promise<void>;
+    /**
+     * Params are specified in the following way:
+     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
+     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
+     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
+     * @param params
+     */
+    query(params: Array<Array<QueryParams>>): Promise<Array<UnifiedStoredObject>>;
+    querySingle(params: Array<QueryParams>): Promise<Array<UnifiedStoredObject>>;
+    remove(object: UnifiedStoredObject): Promise<void>;
+    removeAll(arr: UnifiedStoredObject[]): Promise<void>;
+    save(object: UnifiedStoredObject): Promise<void>;
+    saveAll(arr: UnifiedStoredObject[]): Promise<void>;
+}

package/dist/storage-browser/IndexedDBUnifiedStorage.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBUnifiedStorage = void 0;
+const Logger_1 = require("../utils/Logger");
+function toCompositeIndex(values) {
+    if (values.length === 0)
+        return [];
+    if (values.length === 1) {
+        return values[0];
+    }
+    else {
+        const compositeArray = [];
+        const firstValues = values.shift();
+        const restValues = toCompositeIndex(values);
+        for (let value of firstValues) {
+            for (let restValue of restValues) {
+                compositeArray.push([value].concat(restValue));
+            }
+        }
+        return compositeArray;
+    }
+}
+function matches(conditions, obj) {
+    for (let condition of conditions) {
+        let value = obj[condition.key];
+        if (!condition.values.has(value))
+            return false;
+    }
+    return true;
+}
+function toSetConditions(input) {
+    return input.map(val => {
+        return {
+            key: val.key,
+            values: Array.isArray(val.value) ? new Set(val.value) : new Set([val.value])
+        };
+    });
+}
+const indexes = {
+    "escrowHash": { key: "escrowHash", unique: true },
+    "type": { key: "type", unique: false },
+    "initiator": { key: "initiator", unique: false },
+    "initiator, id": { key: ["initiator", "id"], unique: false },
+    "type, state": { key: ["type", "state"], unique: false },
+    "type, paymentHash": { key: ["type", "paymentHash"], unique: false },
+    "type, initiator, state": { key: ["type", "initiator", "state"], unique: false }
+};
+/**
+ * Browser IndexedDB storage implementation
+ * @category Storage
+ */
+class IndexedDBUnifiedStorage {
+    constructor(storageKey) {
+        this.storageKey = storageKey;
+        this.logger = (0, Logger_1.getLogger)("IndexedDBUnifiedStorage(" + this.storageKey + "): ");
+    }
+    //Reviver also needs to update the swap to the latest version
+    async tryMigrateLocalStorage(storageKey, swapType, reviver) {
+        const txt = window.localStorage.getItem(storageKey);
+        if (txt == null)
+            return false;
+        let data;
+        try {
+            data = JSON.parse(txt);
+        }
+        catch (e) {
+            this.logger.warn("tryMigrate(" + storageKey + "): Tried to migrate the database, but cannot parse old local storage!");
+            return false;
+        }
+        let swaps = Object.keys(data).map(id => {
+            let swapData = data[id];
+            swapData.type = swapType;
+            return reviver(swapData);
+        });
+        await this.saveAll(swaps.map(swap => swap.serialize()));
+        window.localStorage.removeItem(storageKey);
+        this.logger.info("tryMigrate(" + storageKey + "): Database successfully migrated from localStorage to unifiedIndexedDB!");
+        return true;
+    }
+    //Reviver also needs to update the swap to the latest version
+    async tryMigrateOldIndexedDB(storageKey, swapType, reviver) {
+        const databases = await window.indexedDB.databases();
+        if (databases.find(val => val.name === storageKey) == null) {
+            this.logger.info("tryMigrateOldIndexedDB(" + storageKey + "): Old database not found!");
+            return false;
+        }
+        this.logger.debug("tryMigrateOldIndexedDB(" + storageKey + "): Old database found!");
+        let db;
+        try {
+            db = await new Promise((resolve, reject) => {
+                const request = window.indexedDB.open(storageKey, 1);
+                request.onerror = (e) => reject(e);
+                request.onsuccess = (e) => resolve(e.target.result);
+            });
+        }
+        catch (e) {
+            this.logger.warn("tryMigrateOldIndexedDB(" + storageKey + "): Error opening old IndexedDB!", e);
+            return false;
+        }
+        this.logger.debug("tryMigrateOldIndexedDB(" + storageKey + "): Connection opened!");
+        try {
+            const data = await new Promise((resolve, reject) => {
+                const tx = db.transaction("swaps", "readonly", { durability: "strict" });
+                const store = tx.objectStore("swaps");
+                const req = store.getAll();
+                req.onsuccess = (event) => resolve(event.target.result);
+                req.onerror = (event) => reject(event);
+            });
+            this.logger.debug("tryMigrateOldIndexedDB(" + storageKey + "): Data retrieved!");
+            let swaps = data.map(({ id, data }) => {
+                data.type = swapType;
+                return reviver(data);
+            });
+            this.logger.debug("tryMigrateOldIndexedDB(" + storageKey + "): Data revived!");
+            await this.saveAll(swaps.map(swap => swap.serialize()));
+            this.logger.debug("tryMigrateOldIndexedDB(" + storageKey + "): Data saved!");
+            //Remove the old database
+            db.close();
+            this.logger.debug("tryMigrateOldIndexedDB(" + storageKey + "): DB connection closed!");
+            await new Promise((resolve, reject) => {
+                const res = window.indexedDB.deleteDatabase(storageKey);
+                res.onsuccess = () => resolve();
+                res.onerror = (e) => reject(e);
+            });
+            this.logger.info("tryMigrateOldIndexedDB(" + storageKey + "): Database successfully migrated from oldIndexedDB to unifiedIndexedDB!");
+            return true;
+        }
+        catch (e) {
+            this.logger.warn("tryMigrateOldIndexedDB(" + storageKey + "): Tried to migrate the database, but cannot parse oldIndexedDB!", e);
+            return false;
+        }
+    }
+    //NOTE: Reviver also needs to update the swap to the latest version
+    async tryMigrate(storageKeys, reviver) {
+        let someMigrated = false;
+        for (let storageKey of storageKeys) {
+            this.logger.info("tryMigrate(): Trying to migrate...", storageKey);
+            if (await this.tryMigrateLocalStorage(storageKey[0], storageKey[1], reviver))
+                someMigrated = true;
+            if (await this.tryMigrateOldIndexedDB(storageKey[0], storageKey[1], reviver))
+                someMigrated = true;
+        }
+        return someMigrated;
+    }
+    executeTransaction(cbk, readonly) {
+        return new Promise((resolve, reject) => {
+            if (this.db == null) {
+                reject(new Error("Not initiated, call init() first!"));
+                return;
+            }
+            const tx = this.db.transaction("swaps", readonly ? "readonly" : "readwrite", { durability: "strict" });
+            const req = cbk(tx.objectStore("swaps"));
+            req.onsuccess = (event) => resolve(event.target.result);
+            req.onerror = (event) => reject(event);
+        });
+    }
+    executeTransactionArr(cbk, readonly) {
+        if (this.db == null)
+            throw new Error("Not initiated, call init() first!");
+        const tx = this.db.transaction("swaps", readonly ? "readonly" : "readwrite", { durability: "strict" });
+        const reqs = cbk(tx.objectStore("swaps"));
+        return Promise.all(reqs.map(req => new Promise((resolve, reject) => {
+            req.onsuccess = (event) => resolve(event.target.result);
+            req.onerror = (event) => reject(event);
+        })));
+    }
+    async executeTransactionWithCursor(cbk, valueCbk) {
+        if (this.db == null)
+            throw new Error("Not initiated, call init() first!");
+        const tx = this.db.transaction("swaps", "readonly", { durability: "strict" });
+        const cursorRequests = cbk(tx.objectStore("swaps"));
+        const promises = cursorRequests.map(cursorRequest => new Promise((resolve, reject) => {
+            const resultObjects = [];
+            cursorRequest.onsuccess = (event) => {
+                const cursor = event.target.result;
+                if (cursor != null) {
+                    const value = cursor.value;
+                    if (valueCbk(value))
+                        resultObjects.push(value);
+                    cursor.continue();
+                }
+                else {
+                    resolve(resultObjects);
+                }
+            };
+            cursorRequest.onerror = (event) => reject(event);
+        }));
+        const result = await Promise.all(promises);
+        return result.flat();
+    }
+    async init() {
+        if (this.db == null) {
+            this.db = await new Promise((resolve, reject) => {
+                const request = window.indexedDB.open(this.storageKey, 1);
+                request.onupgradeneeded = (event) => {
+                    const db = event.target.result;
+                    const objectStore = db.createObjectStore("swaps", { keyPath: "id" });
+                    Object.keys(indexes).forEach(name => {
+                        const index = indexes[name];
+                        objectStore.createIndex(name, index.key, { unique: index.unique });
+                    });
+                };
+                request.onerror = (e) => reject(e);
+                request.onsuccess = (e) => resolve(e.target.result);
+            });
+        }
+    }
+    /**
+     * Params are specified in the following way:
+     *  - [[condition1, condition2]] - returns all rows where condition1 AND condition2 is met
+     *  - [[condition1], [condition2]] - returns all rows where condition1 OR condition2 is met
+     *  - [[condition1, condition2], [condition3]] - returns all rows where (condition1 AND condition2) OR condition3 is met
+     * @param params
+     */
+    async query(params) {
+        if (params.length === 0)
+            return await this.querySingle([]);
+        const results = await Promise.all(params.map(singleParam => this.querySingle(singleParam)));
+        const resultSet = new Set(results.flat()); //Deduplicate
+        return Array.from(resultSet);
+    }
+    async querySingle(params) {
+        if (params.length === 0) {
+            return await this.executeTransaction((objectStore) => objectStore.getAll(), true);
+        }
+        const queryKeys = params.map(param => param.key);
+        const requiredIndex = queryKeys.join(", ");
+        if (requiredIndex === "id") {
+            //ID is the index
+            const values = Array.isArray(params[0].value) ? params[0].value : [params[0].value];
+            const res = await this.executeTransactionArr((objectStore) => {
+                return values.map(val => objectStore.getAll(val));
+            }, true);
+            return res.flat();
+        }
+        else if (indexes[requiredIndex] != null) {
+            //Index exists
+            const values = params.map(param => Array.isArray(param.value) ? param.value : [param.value]);
+            const compositeIndexQueries = toCompositeIndex(values);
+            const resp = await this.executeTransactionArr(objectStore => {
+                const index = objectStore.index(requiredIndex);
+                return compositeIndexQueries.map(indexQuery => index.getAll(indexQuery));
+            }, true);
+            return resp.flat();
+        }
+        else {
+            //Need to go over all values
+            this.logger.warn("query(): Index cannot be used for query, required index: " + requiredIndex + " query params: ", params);
+            const setConditions = toSetConditions(params);
+            return await this.executeTransactionWithCursor(objectStore => [objectStore.openCursor()], (val) => matches(setConditions, val));
+        }
+    }
+    async remove(object) {
+        await this.executeTransaction(store => store.delete(object.id), false)
+            .catch(() => null);
+    }
+    async removeAll(arr) {
+        if (arr.length === 0)
+            return;
+        await this.executeTransactionArr(store => arr.map(object => {
+            return store.delete(object.id);
+        }), false);
+    }
+    async save(object) {
+        await this.executeTransaction(store => store.put(object), false);
+    }
+    async saveAll(arr) {
+        if (arr.length === 0)
+            return;
+        await this.executeTransactionArr(store => arr.map(object => {
+            return store.put(object);
+        }), false);
+    }
+}
+exports.IndexedDBUnifiedStorage = IndexedDBUnifiedStorage;

package/dist/{storage → storage-browser}/LocalStorageManager.d.ts

@@ -1,6 +1,7 @@
 import { IStorageManager, StorageObject } from "@atomiqlabs/base";
 /**
  * StorageManager using browser's local storage API
+ * @category Storage
  */
 export declare class LocalStorageManager<T extends StorageObject> implements IStorageManager<T> {
     storageKey: string;

package/dist/{storage → storage-browser}/LocalStorageManager.js

@@ -3,10 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStorageManager = void 0;
 /**
  * StorageManager using browser's local storage API
+ * @category Storage
  */
 class LocalStorageManager {
     constructor(storageKey) {
-        this.rawData = null;
+        this.rawData = {};
         this.data = {};
         this.storageKey = storageKey;
     }