@arklabs/wallet-sdk
Version:
Bitcoin wallet SDK with Taproot and Ark integration
404 lines (403 loc) • 16.3 kB
JavaScript
/// <reference lib="webworker" />
import { InMemoryKey } from '../../identity/inMemoryKey.js';
import { Wallet } from '../wallet.js';
import { Request } from './request.js';
import { Response } from './response.js';
import { RestArkProvider } from '../../providers/ark.js';
import { DefaultVtxo } from '../../script/default.js';
import { IndexedDBVtxoRepository } from './db/vtxo/idb.js';
import { vtxosToTxs } from '../../utils/transactionHistory.js';
// Worker is a class letting to interact with ServiceWorkerWallet from the client
// it aims to be run in a service worker context
export class Worker {
constructor(vtxoRepository = new IndexedDBVtxoRepository()) {
this.vtxoRepository = vtxoRepository;
}
async start() {
self.addEventListener("message", async (event) => {
await this.handleMessage(event);
});
}
clear() {
if (this.vtxoSubscription) {
this.vtxoSubscription.abort();
}
this.wallet = undefined;
this.arkProvider = undefined;
this.vtxoSubscription = undefined;
}
async onWalletInitialized() {
if (!this.wallet || !this.arkProvider) {
return;
}
// set the initial vtxos state
const vtxos = await this.wallet.getVtxos();
await this.vtxoRepository.addOrUpdate(vtxos);
// subscribe to address updates
const address = await this.wallet.getAddress();
if (!address.offchain) {
return;
}
this.processVtxoSubscription(address.offchain);
}
async processVtxoSubscription({ address, scripts, }) {
try {
const addressScripts = [...scripts.exit, ...scripts.forfeit];
const vtxoScript = DefaultVtxo.Script.decode(addressScripts);
const tapLeafScript = vtxoScript.findLeaf(scripts.forfeit[0]);
const abortController = new AbortController();
const subscription = this.arkProvider.subscribeForAddress(address, abortController.signal);
this.vtxoSubscription = abortController;
for await (const update of subscription) {
const vtxos = [...update.newVtxos, ...update.spentVtxos];
if (vtxos.length === 0) {
continue;
}
const extendedVtxos = vtxos.map((vtxo) => ({
...vtxo,
tapLeafScript,
scripts: addressScripts,
}));
await this.vtxoRepository.addOrUpdate(extendedVtxos);
}
}
catch (error) {
console.error("Error processing address updates:", error);
}
}
async handleClear(event) {
this.clear();
event.source?.postMessage(Response.clearResponse(true));
}
async handleInitWallet(event) {
const message = event.data;
if (!Request.isInitWallet(message)) {
console.error("Invalid INIT_WALLET message format", message);
event.source?.postMessage(Response.error("Invalid INIT_WALLET message format"));
return;
}
try {
this.arkProvider = new RestArkProvider(message.arkServerUrl);
this.wallet = await Wallet.create({
network: message.network,
identity: InMemoryKey.fromHex(message.privateKey),
arkServerUrl: message.arkServerUrl,
arkServerPublicKey: message.arkServerPublicKey,
});
event.source?.postMessage(Response.walletInitialized);
await this.onWalletInitialized();
}
catch (error) {
console.error("Error initializing wallet:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleSettle(event) {
const message = event.data;
if (!Request.isSettle(message)) {
console.error("Invalid SETTLE message format", message);
event.source?.postMessage(Response.error("Invalid SETTLE message format"));
return;
}
try {
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
const txid = await this.wallet.settle(message.params, (e) => {
event.source?.postMessage(Response.settleEvent(e));
});
event.source?.postMessage(Response.settleSuccess(txid));
}
catch (error) {
console.error("Error settling:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleSendBitcoin(event) {
const message = event.data;
if (!Request.isSendBitcoin(message)) {
console.error("Invalid SEND_BITCOIN message format", message);
event.source?.postMessage(Response.error("Invalid SEND_BITCOIN message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const txid = await this.wallet.sendBitcoin(message.params, message.zeroFee);
event.source?.postMessage(Response.sendBitcoinSuccess(txid));
}
catch (error) {
console.error("Error sending bitcoin:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetAddress(event) {
const message = event.data;
if (!Request.isGetAddress(message)) {
console.error("Invalid GET_ADDRESS message format", message);
event.source?.postMessage(Response.error("Invalid GET_ADDRESS message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const address = await this.wallet.getAddress();
event.source?.postMessage(Response.address(address));
}
catch (error) {
console.error("Error getting address:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetBalance(event) {
const message = event.data;
if (!Request.isGetBalance(message)) {
console.error("Invalid GET_BALANCE message format", message);
event.source?.postMessage(Response.error("Invalid GET_BALANCE message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const coins = await this.wallet.getCoins();
const onchainConfirmed = coins
.filter((coin) => coin.status.confirmed)
.reduce((sum, coin) => sum + coin.value, 0);
const onchainUnconfirmed = coins
.filter((coin) => !coin.status.confirmed)
.reduce((sum, coin) => sum + coin.value, 0);
const onchainTotal = onchainConfirmed + onchainUnconfirmed;
const spendableVtxos = await this.vtxoRepository.getSpendableVtxos();
const offchainSettledBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "settled"
? sum + vtxo.value
: sum, 0);
const offchainPendingBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "pending"
? sum + vtxo.value
: sum, 0);
const offchainSweptBalance = spendableVtxos.reduce((sum, vtxo) => vtxo.virtualStatus.state === "swept"
? sum + vtxo.value
: sum, 0);
const offchainTotal = offchainSettledBalance +
offchainPendingBalance +
offchainSweptBalance;
event.source?.postMessage(Response.balance({
onchain: {
confirmed: onchainConfirmed,
unconfirmed: onchainUnconfirmed,
total: onchainTotal,
},
offchain: {
swept: offchainSweptBalance,
settled: offchainSettledBalance,
pending: offchainPendingBalance,
total: offchainTotal,
},
total: onchainTotal + offchainTotal,
}));
}
catch (error) {
console.error("Error getting balance:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetCoins(event) {
const message = event.data;
if (!Request.isGetCoins(message)) {
console.error("Invalid GET_COINS message format", message);
event.source?.postMessage(Response.error("Invalid GET_COINS message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const coins = await this.wallet.getCoins();
event.source?.postMessage(Response.coins(coins));
}
catch (error) {
console.error("Error getting coins:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetVtxos(event) {
const message = event.data;
if (!Request.isGetVtxos(message)) {
console.error("Invalid GET_VTXOS message format", message);
event.source?.postMessage(Response.error("Invalid GET_VTXOS message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const vtxos = await this.vtxoRepository.getSpendableVtxos();
event.source?.postMessage(Response.vtxos(vtxos));
}
catch (error) {
console.error("Error getting vtxos:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetBoardingUtxos(event) {
const message = event.data;
if (!Request.isGetBoardingUtxos(message)) {
console.error("Invalid GET_BOARDING_UTXOS message format", message);
event.source?.postMessage(Response.error("Invalid GET_BOARDING_UTXOS message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const boardingUtxos = await this.wallet.getBoardingUtxos();
event.source?.postMessage(Response.boardingUtxos(boardingUtxos));
}
catch (error) {
console.error("Error getting boarding utxos:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetTransactionHistory(event) {
const message = event.data;
if (!Request.isGetTransactionHistory(message)) {
console.error("Invalid GET_TRANSACTION_HISTORY message format", message);
event.source?.postMessage(Response.error("Invalid GET_TRANSACTION_HISTORY message format"));
return;
}
if (!this.wallet) {
console.error("Wallet not initialized");
event.source?.postMessage(Response.error("Wallet not initialized"));
return;
}
try {
const { boardingTxs, roundsToIgnore } = await this.wallet.getBoardingTxs();
const { spendable, spent } = await this.vtxoRepository.getAllVtxos();
// convert VTXOs to offchain transactions
const offchainTxs = vtxosToTxs(spendable, spent, roundsToIgnore);
const txs = [...boardingTxs, ...offchainTxs];
// sort transactions by creation time in descending order (newest first)
txs.sort(
// place createdAt = 0 (unconfirmed txs) first, then descending
(a, b) => {
if (a.createdAt === 0)
return -1;
if (b.createdAt === 0)
return 1;
return b.createdAt - a.createdAt;
});
event.source?.postMessage(Response.transactionHistory(txs));
}
catch (error) {
console.error("Error getting transaction history:", error);
const errorMessage = error instanceof Error
? error.message
: "Unknown error occurred";
event.source?.postMessage(Response.error(errorMessage));
}
}
async handleGetStatus(event) {
const message = event.data;
if (!Request.isGetStatus(message)) {
console.error("Invalid GET_STATUS message format", message);
event.source?.postMessage(Response.error("Invalid GET_STATUS message format"));
return;
}
event.source?.postMessage(Response.walletStatus(this.wallet !== undefined));
}
async handleMessage(event) {
const message = event.data;
if (!Request.isBase(message)) {
event.source?.postMessage(Response.error("Invalid message format"));
return;
}
switch (message.type) {
case "INIT_WALLET": {
await this.handleInitWallet(event);
break;
}
case "SETTLE": {
await this.handleSettle(event);
break;
}
case "SEND_BITCOIN": {
await this.handleSendBitcoin(event);
break;
}
case "GET_ADDRESS": {
await this.handleGetAddress(event);
break;
}
case "GET_BALANCE": {
await this.handleGetBalance(event);
break;
}
case "GET_COINS": {
await this.handleGetCoins(event);
break;
}
case "GET_VTXOS": {
await this.handleGetVtxos(event);
break;
}
case "GET_BOARDING_UTXOS": {
await this.handleGetBoardingUtxos(event);
break;
}
case "GET_TRANSACTION_HISTORY": {
await this.handleGetTransactionHistory(event);
break;
}
case "GET_STATUS": {
await this.handleGetStatus(event);
break;
}
case "CLEAR": {
await this.handleClear(event);
break;
}
default:
event.source?.postMessage(Response.error("Unknown message type"));
}
}
}