@arkade-os/sdk 0.0.16

package/dist/cjs/wallet/serviceWorker/db/vtxo/idb.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBVtxoRepository = void 0;
+class IndexedDBVtxoRepository {
+    constructor() {
+        this.db = null;
+    }
+    static delete() {
+        return new Promise((resolve, reject) => {
+            try {
+                const request = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
+                request.onblocked = () => {
+                    // If blocked, wait a bit and try again
+                    setTimeout(() => {
+                        const retryRequest = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
+                        retryRequest.onsuccess = () => resolve();
+                        retryRequest.onerror = () => reject(retryRequest.error ||
+                            new Error("Failed to delete database"));
+                    }, 100);
+                };
+                request.onsuccess = () => {
+                    resolve();
+                };
+                request.onerror = () => {
+                    reject(request.error || new Error("Failed to delete database"));
+                };
+            }
+            catch (error) {
+                reject(error instanceof Error
+                    ? error
+                    : new Error("Failed to delete database"));
+            }
+        });
+    }
+    async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    async open() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(IndexedDBVtxoRepository.DB_NAME, IndexedDBVtxoRepository.DB_VERSION);
+            request.onerror = () => {
+                reject(request.error);
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(IndexedDBVtxoRepository.STORE_NAME)) {
+                    const store = db.createObjectStore(IndexedDBVtxoRepository.STORE_NAME, {
+                        keyPath: ["txid", "vout"],
+                    });
+                    store.createIndex("state", "virtualStatus.state", {
+                        unique: false,
+                    });
+                    store.createIndex("spentBy", "spentBy", {
+                        unique: false,
+                    });
+                }
+            };
+        });
+    }
+    async addOrUpdate(vtxos) {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const requests = vtxos.map((vtxo) => {
+                return new Promise((resolveRequest, rejectRequest) => {
+                    const request = store.put(vtxo);
+                    request.onsuccess = () => resolveRequest();
+                    request.onerror = () => rejectRequest(request.error);
+                });
+            });
+            Promise.all(requests)
+                .then(() => resolve())
+                .catch(reject);
+        });
+    }
+    async deleteAll() {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async getSpendableVtxos() {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const spentByIndex = store.index("spentBy");
+            // Get vtxos where spentBy is empty string
+            const request = spentByIndex.getAll(IDBKeyRange.only(""));
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async getAllVtxos() {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const spentByIndex = store.index("spentBy");
+            // Get vtxos where spentBy is empty string
+            const spendableRequest = spentByIndex.getAll(IDBKeyRange.only(""));
+            // Get all vtxos where spentBy is populated
+            const spentRequest = spentByIndex.getAll(IDBKeyRange.lowerBound("", true));
+            Promise.all([
+                new Promise((resolveSpendable, rejectSpendable) => {
+                    spendableRequest.onsuccess = () => {
+                        resolveSpendable(spendableRequest.result);
+                    };
+                    spendableRequest.onerror = () => rejectSpendable(spendableRequest.error);
+                }),
+                new Promise((resolveSpent, rejectSpent) => {
+                    spentRequest.onsuccess = () => {
+                        resolveSpent(spentRequest.result);
+                    };
+                    spentRequest.onerror = () => rejectSpent(spentRequest.error);
+                }),
+            ])
+                .then(([spendableVtxos, spentVtxos]) => {
+                resolve({
+                    spendable: spendableVtxos,
+                    spent: spentVtxos,
+                });
+            })
+                .catch(reject);
+        });
+    }
+}
+exports.IndexedDBVtxoRepository = IndexedDBVtxoRepository;
+IndexedDBVtxoRepository.DB_NAME = "wallet-db";
+IndexedDBVtxoRepository.STORE_NAME = "vtxos";
+IndexedDBVtxoRepository.DB_VERSION = 1;

package/dist/cjs/wallet/serviceWorker/db/vtxo/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/wallet/serviceWorker/request.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+var Request;
+(function (Request) {
+    function isBase(message) {
+        return (typeof message === "object" && message !== null && "type" in message);
+    }
+    Request.isBase = isBase;
+    function isInitWallet(message) {
+        return (message.type === "INIT_WALLET" &&
+            "privateKey" in message &&
+            typeof message.privateKey === "string" &&
+            "arkServerUrl" in message &&
+            typeof message.arkServerUrl === "string" &&
+            "network" in message &&
+            typeof message.network === "string" &&
+            ("arkServerPublicKey" in message
+                ? typeof message.arkServerPublicKey === "string" ||
+                    message.arkServerPublicKey === undefined
+                : true));
+    }
+    Request.isInitWallet = isInitWallet;
+    function isSettle(message) {
+        return message.type === "SETTLE";
+    }
+    Request.isSettle = isSettle;
+    function isGetAddress(message) {
+        return message.type === "GET_ADDRESS";
+    }
+    Request.isGetAddress = isGetAddress;
+    function isGetAddressInfo(message) {
+        return message.type === "GET_ADDRESS_INFO";
+    }
+    Request.isGetAddressInfo = isGetAddressInfo;
+    function isGetBalance(message) {
+        return message.type === "GET_BALANCE";
+    }
+    Request.isGetBalance = isGetBalance;
+    function isGetCoins(message) {
+        return message.type === "GET_COINS";
+    }
+    Request.isGetCoins = isGetCoins;
+    function isGetVtxos(message) {
+        return message.type === "GET_VTXOS";
+    }
+    Request.isGetVtxos = isGetVtxos;
+    function isGetVirtualCoins(message) {
+        return message.type === "GET_VIRTUAL_COINS";
+    }
+    Request.isGetVirtualCoins = isGetVirtualCoins;
+    function isGetBoardingUtxos(message) {
+        return message.type === "GET_BOARDING_UTXOS";
+    }
+    Request.isGetBoardingUtxos = isGetBoardingUtxos;
+    function isSendBitcoin(message) {
+        return (message.type === "SEND_BITCOIN" &&
+            "params" in message &&
+            message.params !== null &&
+            typeof message.params === "object" &&
+            "address" in message.params &&
+            typeof message.params.address === "string" &&
+            "amount" in message.params &&
+            typeof message.params.amount === "number");
+    }
+    Request.isSendBitcoin = isSendBitcoin;
+    function isGetTransactionHistory(message) {
+        return message.type === "GET_TRANSACTION_HISTORY";
+    }
+    Request.isGetTransactionHistory = isGetTransactionHistory;
+    function isGetStatus(message) {
+        return message.type === "GET_STATUS";
+    }
+    Request.isGetStatus = isGetStatus;
+})(Request || (exports.Request = Request = {}));

package/dist/cjs/wallet/serviceWorker/response.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+var Response;
+(function (Response) {
+    Response.walletInitialized = (id) => ({
+        type: "WALLET_INITIALIZED",
+        success: true,
+        id,
+    });
+    function error(id, message) {
+        return {
+            type: "ERROR",
+            success: false,
+            message,
+            id,
+        };
+    }
+    Response.error = error;
+    function settleEvent(id, event) {
+        return {
+            type: "SETTLE_EVENT",
+            success: true,
+            event,
+            id,
+        };
+    }
+    Response.settleEvent = settleEvent;
+    function settleSuccess(id, txid) {
+        return {
+            type: "SETTLE_SUCCESS",
+            success: true,
+            txid,
+            id,
+        };
+    }
+    Response.settleSuccess = settleSuccess;
+    function isSettleSuccess(response) {
+        return response.type === "SETTLE_SUCCESS" && response.success;
+    }
+    Response.isSettleSuccess = isSettleSuccess;
+    function isAddress(response) {
+        return response.type === "ADDRESS" && response.success === true;
+    }
+    Response.isAddress = isAddress;
+    function addresses(id, addresses) {
+        return {
+            type: "ADDRESS",
+            success: true,
+            addresses,
+            id,
+        };
+    }
+    Response.addresses = addresses;
+    function isAddressInfo(response) {
+        return response.type === "ADDRESS_INFO" && response.success === true;
+    }
+    Response.isAddressInfo = isAddressInfo;
+    function addressInfo(id, addressInfo) {
+        return {
+            type: "ADDRESS_INFO",
+            success: true,
+            addressInfo,
+            id,
+        };
+    }
+    Response.addressInfo = addressInfo;
+    function isBalance(response) {
+        return response.type === "BALANCE" && response.success === true;
+    }
+    Response.isBalance = isBalance;
+    function balance(id, balance) {
+        return {
+            type: "BALANCE",
+            success: true,
+            balance,
+            id,
+        };
+    }
+    Response.balance = balance;
+    function isCoins(response) {
+        return response.type === "COINS" && response.success === true;
+    }
+    Response.isCoins = isCoins;
+    function coins(id, coins) {
+        return {
+            type: "COINS",
+            success: true,
+            coins,
+            id,
+        };
+    }
+    Response.coins = coins;
+    function isVtxos(response) {
+        return response.type === "VTXOS" && response.success === true;
+    }
+    Response.isVtxos = isVtxos;
+    function vtxos(id, vtxos) {
+        return {
+            type: "VTXOS",
+            success: true,
+            vtxos,
+            id,
+        };
+    }
+    Response.vtxos = vtxos;
+    function isVirtualCoins(response) {
+        return response.type === "VIRTUAL_COINS" && response.success === true;
+    }
+    Response.isVirtualCoins = isVirtualCoins;
+    function virtualCoins(id, virtualCoins) {
+        return {
+            type: "VIRTUAL_COINS",
+            success: true,
+            virtualCoins,
+            id,
+        };
+    }
+    Response.virtualCoins = virtualCoins;
+    function isBoardingUtxos(response) {
+        return response.type === "BOARDING_UTXOS" && response.success === true;
+    }
+    Response.isBoardingUtxos = isBoardingUtxos;
+    function boardingUtxos(id, boardingUtxos) {
+        return {
+            type: "BOARDING_UTXOS",
+            success: true,
+            boardingUtxos,
+            id,
+        };
+    }
+    Response.boardingUtxos = boardingUtxos;
+    function isSendBitcoinSuccess(response) {
+        return (response.type === "SEND_BITCOIN_SUCCESS" &&
+            response.success === true);
+    }
+    Response.isSendBitcoinSuccess = isSendBitcoinSuccess;
+    function sendBitcoinSuccess(id, txid) {
+        return {
+            type: "SEND_BITCOIN_SUCCESS",
+            success: true,
+            txid,
+            id,
+        };
+    }
+    Response.sendBitcoinSuccess = sendBitcoinSuccess;
+    function isTransactionHistory(response) {
+        return (response.type === "TRANSACTION_HISTORY" && response.success === true);
+    }
+    Response.isTransactionHistory = isTransactionHistory;
+    function transactionHistory(id, transactions) {
+        return {
+            type: "TRANSACTION_HISTORY",
+            success: true,
+            transactions,
+            id,
+        };
+    }
+    Response.transactionHistory = transactionHistory;
+    function isWalletStatus(response) {
+        return response.type === "WALLET_STATUS" && response.success === true;
+    }
+    Response.isWalletStatus = isWalletStatus;
+    function walletStatus(id, walletInitialized) {
+        return {
+            type: "WALLET_STATUS",
+            success: true,
+            status: {
+                walletInitialized,
+            },
+            id,
+        };
+    }
+    Response.walletStatus = walletStatus;
+    function isClearResponse(response) {
+        return response.type === "CLEAR_RESPONSE";
+    }
+    Response.isClearResponse = isClearResponse;
+    function clearResponse(id, success) {
+        return {
+            type: "CLEAR_RESPONSE",
+            success,
+            id,
+        };
+    }
+    Response.clearResponse = clearResponse;
+})(Response || (exports.Response = Response = {}));