@arkade-os/sdk 0.3.13 → 0.4.0-next.1

package/dist/esm/wallet/serviceWorker/wallet-message-handler.js

@@ -0,0 +1,564 @@
+import { RestIndexerProvider } from '../../providers/indexer.js';
+import { isExpired, isRecoverable, isSpendable, isSubdust, } from '../index.js';
+import { extendCoin, extendVirtualCoin } from '../utils.js';
+export const DEFAULT_MESSAGE_TAG = "WALLET_UPDATER";
+export class WalletMessageHandler {
+    /**
+     * Instantiate a new WalletUpdater.
+     * Can override the default `messageTag` allowing more than one updater to run in parallel.
+     * Note that the default ServiceWorkerWallet sends messages to the default WalletUpdater tag.
+     */
+    constructor(options) {
+        this.onNextTick = [];
+        this.messageTag = options?.messageTag ?? DEFAULT_MESSAGE_TAG;
+    }
+    // lifecycle methods
+    async start(...params) {
+        const [services, repositories] = params;
+        this.readonlyWallet = services.readonlyWallet;
+        this.wallet = services.wallet;
+        this.arkProvider = services.arkProvider;
+        this.walletRepository = repositories.walletRepository;
+    }
+    async stop() {
+        // optional cleanup and persistence
+    }
+    async tick(_now) {
+        const results = await Promise.allSettled(this.onNextTick.map((fn) => fn()));
+        this.onNextTick = [];
+        return results
+            .map((result) => {
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+            else {
+                console.error(`[${this.messageTag}] tick failed`, result.reason);
+                // TODO: how to deliver errors down the stream? a broadcast?
+                return null;
+            }
+        })
+            .filter((response) => response !== null);
+    }
+    scheduleForNextTick(callback) {
+        this.onNextTick.push(callback);
+    }
+    requireWallet() {
+        if (!this.wallet) {
+            throw new Error("Read-only wallet: operation requires signing");
+        }
+        return this.wallet;
+    }
+    tagged(res) {
+        return {
+            ...res,
+            tag: this.messageTag,
+        };
+    }
+    async handleMessage(message) {
+        const id = message.id;
+        if (message.type === "INIT_WALLET") {
+            await this.handleInitWallet(message);
+            return this.tagged({
+                id,
+                type: "WALLET_INITIALIZED",
+            });
+        }
+        if (!this.readonlyWallet) {
+            return this.tagged({
+                id,
+                error: new Error("Wallet handler not initialized"),
+            });
+        }
+        try {
+            switch (message.type) {
+                case "SETTLE": {
+                    const response = await this.handleSettle(message);
+                    return this.tagged({
+                        id,
+                        ...response,
+                    });
+                }
+                case "SEND_BITCOIN": {
+                    const response = await this.handleSendBitcoin(message);
+                    return this.tagged({
+                        id,
+                        ...response,
+                    });
+                }
+                case "GET_ADDRESS": {
+                    const address = await this.readonlyWallet.getAddress();
+                    return this.tagged({
+                        id,
+                        type: "ADDRESS",
+                        payload: { address },
+                    });
+                }
+                case "GET_BOARDING_ADDRESS": {
+                    const address = await this.readonlyWallet.getBoardingAddress();
+                    return this.tagged({
+                        id,
+                        type: "BOARDING_ADDRESS",
+                        payload: { address },
+                    });
+                }
+                case "GET_BALANCE": {
+                    const balance = await this.handleGetBalance();
+                    return this.tagged({
+                        id,
+                        type: "BALANCE",
+                        payload: balance,
+                    });
+                }
+                case "GET_VTXOS": {
+                    const vtxos = await this.handleGetVtxos(message);
+                    return {
+                        tag: this.messageTag,
+                        id,
+                        type: "VTXOS",
+                        payload: { vtxos },
+                    };
+                }
+                case "GET_BOARDING_UTXOS": {
+                    const utxos = await this.getAllBoardingUtxos();
+                    return this.tagged({
+                        id,
+                        type: "BOARDING_UTXOS",
+                        payload: { utxos },
+                    });
+                }
+                case "GET_TRANSACTION_HISTORY": {
+                    const transactions = await this.readonlyWallet.getTransactionHistory();
+                    return this.tagged({
+                        id,
+                        type: "TRANSACTION_HISTORY",
+                        payload: { transactions },
+                    });
+                }
+                case "GET_STATUS": {
+                    const pubKey = await this.readonlyWallet.identity.xOnlyPublicKey();
+                    return this.tagged({
+                        id,
+                        type: "WALLET_STATUS",
+                        payload: {
+                            walletInitialized: true,
+                            xOnlyPublicKey: pubKey,
+                        },
+                    });
+                }
+                case "CLEAR": {
+                    await this.clear();
+                    return this.tagged({
+                        id,
+                        type: "CLEAR_SUCCESS",
+                        payload: { cleared: true },
+                    });
+                }
+                case "RELOAD_WALLET": {
+                    await this.onWalletInitialized();
+                    return this.tagged({
+                        id,
+                        type: "RELOAD_SUCCESS",
+                        payload: { reloaded: true },
+                    });
+                }
+                case "SIGN_TRANSACTION": {
+                    const response = await this.handleSignTransaction(message);
+                    return this.tagged({
+                        id,
+                        ...response,
+                    });
+                }
+                case "CREATE_CONTRACT": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const contract = await manager.createContract(message.payload);
+                    return this.tagged({
+                        id,
+                        type: "CONTRACT_CREATED",
+                        payload: { contract },
+                    });
+                }
+                case "GET_CONTRACTS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const contracts = await manager.getContracts(message.payload.filter);
+                    return this.tagged({
+                        id,
+                        type: "CONTRACTS",
+                        payload: { contracts },
+                    });
+                }
+                case "GET_CONTRACTS_WITH_VTXOS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const contracts = await manager.getContractsWithVtxos(message.payload.filter);
+                    return this.tagged({
+                        id,
+                        type: "CONTRACTS_WITH_VTXOS",
+                        payload: { contracts },
+                    });
+                }
+                case "UPDATE_CONTRACT": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const contract = await manager.updateContract(message.payload.script, message.payload.updates);
+                    return this.tagged({
+                        id,
+                        type: "CONTRACT_UPDATED",
+                        payload: { contract },
+                    });
+                }
+                case "DELETE_CONTRACT": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    await manager.deleteContract(message.payload.script);
+                    return this.tagged({
+                        id,
+                        type: "CONTRACT_DELETED",
+                        payload: { deleted: true },
+                    });
+                }
+                case "GET_SPENDABLE_PATHS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const paths = await manager.getSpendablePaths(message.payload.options);
+                    return this.tagged({
+                        id,
+                        type: "SPENDABLE_PATHS",
+                        payload: { paths },
+                    });
+                }
+                case "GET_ALL_SPENDING_PATHS": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const paths = await manager.getAllSpendingPaths(message.payload.options);
+                    return this.tagged({
+                        id,
+                        type: "ALL_SPENDING_PATHS",
+                        payload: { paths },
+                    });
+                }
+                case "IS_CONTRACT_MANAGER_WATCHING": {
+                    const manager = await this.readonlyWallet.getContractManager();
+                    const isWatching = await manager.isWatching();
+                    return this.tagged({
+                        id,
+                        type: "CONTRACT_WATCHING",
+                        payload: { isWatching },
+                    });
+                }
+                case "SEND": {
+                    const { recipients } = message.payload;
+                    const txid = await this.wallet.send(...recipients);
+                    return this.tagged({
+                        id,
+                        type: "SEND_SUCCESS",
+                        payload: { txid },
+                    });
+                }
+                case "GET_ASSET_DETAILS": {
+                    const { assetId } = message
+                        .payload;
+                    const assetDetails = await this.readonlyWallet.assetManager.getAssetDetails(assetId);
+                    return this.tagged({
+                        id,
+                        type: "ASSET_DETAILS",
+                        payload: { assetDetails },
+                    });
+                }
+                case "ISSUE": {
+                    const { params } = message.payload;
+                    const result = await this.wallet.assetManager.issue(params);
+                    return this.tagged({
+                        id,
+                        type: "ISSUE_SUCCESS",
+                        payload: { result },
+                    });
+                }
+                case "REISSUE": {
+                    const { params } = message.payload;
+                    const txid = await this.wallet.assetManager.reissue(params);
+                    return this.tagged({
+                        id,
+                        type: "REISSUE_SUCCESS",
+                        payload: { txid },
+                    });
+                }
+                case "BURN": {
+                    const { params } = message.payload;
+                    const txid = await this.wallet.assetManager.burn(params);
+                    return this.tagged({
+                        id,
+                        type: "BURN_SUCCESS",
+                        payload: { txid },
+                    });
+                }
+                default:
+                    console.error("Unknown message type", message);
+                    throw new Error("Unknown message");
+            }
+        }
+        catch (error) {
+            return this.tagged({ id, error: error });
+        }
+    }
+    // Wallet methods
+    async handleInitWallet({ payload }) {
+        const { arkServerUrl } = payload;
+        this.indexerProvider = new RestIndexerProvider(arkServerUrl);
+        await this.onWalletInitialized();
+    }
+    async handleGetBalance() {
+        const [boardingUtxos, spendableVtxos, sweptVtxos] = await Promise.all([
+            this.getAllBoardingUtxos(),
+            this.getSpendableVtxos(),
+            this.getSweptVtxos(),
+        ]);
+        // boarding
+        let confirmed = 0;
+        let unconfirmed = 0;
+        for (const utxo of boardingUtxos) {
+            if (utxo.status.confirmed) {
+                confirmed += utxo.value;
+            }
+            else {
+                unconfirmed += utxo.value;
+            }
+        }
+        // offchain
+        let settled = 0;
+        let preconfirmed = 0;
+        let recoverable = 0;
+        for (const vtxo of spendableVtxos) {
+            if (vtxo.virtualStatus.state === "settled") {
+                settled += vtxo.value;
+            }
+            else if (vtxo.virtualStatus.state === "preconfirmed") {
+                preconfirmed += vtxo.value;
+            }
+        }
+        for (const vtxo of sweptVtxos) {
+            if (isSpendable(vtxo)) {
+                recoverable += vtxo.value;
+            }
+        }
+        const totalBoarding = confirmed + unconfirmed;
+        const totalOffchain = settled + preconfirmed + recoverable;
+        // aggregate asset balances from spendable vtxos
+        const assetBalances = new Map();
+        for (const vtxo of spendableVtxos) {
+            if (vtxo.assets) {
+                for (const a of vtxo.assets) {
+                    const current = assetBalances.get(a.assetId) ?? 0;
+                    assetBalances.set(a.assetId, current + a.amount);
+                }
+            }
+        }
+        const assets = Array.from(assetBalances.entries()).map(([assetId, amount]) => ({ assetId, amount }));
+        return {
+            boarding: {
+                confirmed,
+                unconfirmed,
+                total: totalBoarding,
+            },
+            settled,
+            preconfirmed,
+            available: settled + preconfirmed,
+            recoverable,
+            total: totalBoarding + totalOffchain,
+            assets,
+        };
+    }
+    async getAllBoardingUtxos() {
+        if (!this.readonlyWallet)
+            return [];
+        return this.readonlyWallet.getBoardingUtxos();
+    }
+    /**
+     * Get spendable vtxos for the current wallet address
+     */
+    async getSpendableVtxos() {
+        if (!this.readonlyWallet)
+            return [];
+        const vtxos = await this.readonlyWallet.getVtxos();
+        return vtxos.filter(isSpendable);
+    }
+    /**
+     * Get swept vtxos for the current wallet address
+     */
+    async getSweptVtxos() {
+        if (!this.readonlyWallet)
+            return [];
+        const vtxos = await this.readonlyWallet.getVtxos();
+        return vtxos.filter((vtxo) => vtxo.virtualStatus.state === "swept");
+    }
+    async onWalletInitialized() {
+        if (!this.readonlyWallet ||
+            !this.arkProvider ||
+            !this.indexerProvider ||
+            !this.walletRepository) {
+            return;
+        }
+        // Get all wallet scripts (current + historical delegate/non-delegate)
+        const scripts = await this.readonlyWallet.getWalletScripts();
+        const response = await this.indexerProvider.getVtxos({ scripts });
+        const vtxos = response.vtxos.map((vtxo) => extendVirtualCoin(this.readonlyWallet, vtxo));
+        if (this.wallet) {
+            try {
+                // recover pending transactions if possible
+                const { pending, finalized } = await this.wallet.finalizePendingTxs(vtxos.filter((vtxo) => vtxo.virtualStatus.state !== "swept" &&
+                    vtxo.virtualStatus.state !== "settled"));
+                console.info(`Recovered ${finalized.length}/${pending.length} pending transactions: ${finalized.join(", ")}`);
+            }
+            catch (error) {
+                console.error("Error recovering pending transactions:", error);
+            }
+        }
+        // Get wallet address and save vtxos using unified repository
+        const address = await this.readonlyWallet.getAddress();
+        await this.walletRepository.saveVtxos(address, vtxos);
+        // Fetch boarding utxos and save using unified repository
+        const boardingAddress = await this.readonlyWallet.getBoardingAddress();
+        const coins = await this.readonlyWallet.onchainProvider.getCoins(boardingAddress);
+        await this.walletRepository.saveUtxos(boardingAddress, coins.map((utxo) => extendCoin(this.readonlyWallet, utxo)));
+        // Get transaction history to cache boarding txs
+        const txs = await this.readonlyWallet.getTransactionHistory();
+        if (txs)
+            await this.walletRepository.saveTransactions(address, txs);
+        // unsubscribe previous subscription if any
+        if (this.incomingFundsSubscription)
+            this.incomingFundsSubscription();
+        // subscribe for incoming funds and notify all clients when new funds arrive
+        this.incomingFundsSubscription =
+            await this.readonlyWallet.notifyIncomingFunds(async (funds) => {
+                if (funds.type === "vtxo") {
+                    const newVtxos = funds.newVtxos.length > 0
+                        ? funds.newVtxos.map((vtxo) => extendVirtualCoin(this.readonlyWallet, vtxo))
+                        : [];
+                    const spentVtxos = funds.spentVtxos.length > 0
+                        ? funds.spentVtxos.map((vtxo) => extendVirtualCoin(this.readonlyWallet, vtxo))
+                        : [];
+                    if ([...newVtxos, ...spentVtxos].length === 0)
+                        return;
+                    // save vtxos using unified repository
+                    await this.walletRepository?.saveVtxos(address, [
+                        ...newVtxos,
+                        ...spentVtxos,
+                    ]);
+                    // notify all clients about the vtxo update
+                    this.scheduleForNextTick(() => this.tagged({
+                        type: "VTXO_UPDATE",
+                        broadcast: true,
+                        payload: { newVtxos, spentVtxos },
+                    }));
+                }
+                if (funds.type === "utxo") {
+                    const utxos = funds.coins.map((utxo) => extendCoin(this.readonlyWallet, utxo));
+                    const boardingAddress = await this.readonlyWallet.getBoardingAddress();
+                    // save utxos using unified repository
+                    // TODO: remove UTXOS by address
+                    //  await this.walletRepository.clearUtxos(boardingAddress);
+                    await this.walletRepository?.saveUtxos(boardingAddress, utxos);
+                    // notify all clients about the utxo update
+                    this.scheduleForNextTick(() => this.tagged({
+                        type: "UTXO_UPDATE",
+                        broadcast: true,
+                        payload: { coins: utxos },
+                    }));
+                }
+            });
+        await this.ensureContractEventBroadcasting();
+    }
+    async handleSettle(message) {
+        const wallet = this.requireWallet();
+        const txid = await wallet.settle(message.payload.params, (e) => {
+            this.scheduleForNextTick(() => this.tagged({
+                id: message.id,
+                type: "SETTLE_EVENT",
+                payload: e,
+            }));
+        });
+        if (!txid) {
+            throw new Error("Settlement failed");
+        }
+        return { type: "SETTLE_SUCCESS", payload: { txid } };
+    }
+    async handleSendBitcoin(message) {
+        const wallet = this.requireWallet();
+        const txid = await wallet.sendBitcoin(message.payload);
+        if (!txid) {
+            throw new Error("Send bitcoin failed");
+        }
+        return {
+            type: "SEND_BITCOIN_SUCCESS",
+            payload: { txid },
+        };
+    }
+    async handleSignTransaction(message) {
+        const wallet = this.requireWallet();
+        const { tx, inputIndexes } = message.payload;
+        const signature = await wallet.identity.sign(tx, inputIndexes);
+        if (!signature) {
+            throw new Error("Sign transaction failed");
+        }
+        return {
+            type: "SIGN_TRANSACTION",
+            payload: { tx: signature },
+        };
+    }
+    async handleGetVtxos(message) {
+        if (!this.readonlyWallet) {
+            throw new Error("Wallet handler not initialized");
+        }
+        const vtxos = await this.getSpendableVtxos();
+        const dustAmount = this.readonlyWallet.dustAmount;
+        const includeRecoverable = message.payload.filter?.withRecoverable ?? false;
+        const filteredVtxos = includeRecoverable
+            ? vtxos
+            : vtxos.filter((v) => {
+                if (dustAmount != null && isSubdust(v, dustAmount)) {
+                    return false;
+                }
+                if (isRecoverable(v)) {
+                    return false;
+                }
+                if (isExpired(v)) {
+                    return false;
+                }
+                return true;
+            });
+        return filteredVtxos;
+    }
+    async clear() {
+        if (!this.readonlyWallet)
+            return;
+        if (this.incomingFundsSubscription)
+            this.incomingFundsSubscription();
+        if (this.contractEventsSubscription) {
+            this.contractEventsSubscription();
+            this.contractEventsSubscription = undefined;
+        }
+        try {
+            await this.walletRepository?.clear();
+        }
+        catch (_) {
+            console.warn("Failed to clear vtxos from wallet repository");
+        }
+        this.wallet = undefined;
+        this.readonlyWallet = undefined;
+        this.arkProvider = undefined;
+        this.indexerProvider = undefined;
+    }
+    async ensureContractEventBroadcasting() {
+        if (!this.readonlyWallet)
+            return;
+        if (this.contractEventsSubscription)
+            return;
+        try {
+            const manager = await this.readonlyWallet.getContractManager();
+            this.contractEventsSubscription = manager.onContractEvent((event) => {
+                this.scheduleForNextTick(() => this.tagged({
+                    type: "CONTRACT_EVENT",
+                    broadcast: true,
+                    payload: { event },
+                }));
+            });
+        }
+        catch (error) {
+            console.error("Error subscribing to contract events:", error);
+        }
+    }
+}