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

package/dist/types/wallet/serviceWorker/wallet-message-handler.d.ts

@@ -0,0 +1,366 @@
+import { SettlementEvent } from "../../providers/ark";
+import type { Contract, ContractEvent, ContractWithVtxos, GetContractsFilter, PathSelection } from "../../contracts";
+import type { CreateContractParams, GetAllSpendingPathsOptions, GetSpendablePathsOptions } from "../../contracts/contractManager";
+import { ArkTransaction, AssetDetails, BurnParams, ExtendedCoin, GetVtxosFilter, IssuanceParams, IssuanceResult, IWallet, Recipient, ReissuanceParams, SendBitcoinParams, SettleParams, WalletBalance } from "../index";
+import { MessageHandler, RequestEnvelope, ResponseEnvelope } from "../../worker/messageBus";
+import { Transaction } from "../../utils/transaction";
+export declare const DEFAULT_MESSAGE_TAG = "WALLET_UPDATER";
+export type RequestInitWallet = RequestEnvelope & {
+    type: "INIT_WALLET";
+    payload: {
+        key: {
+            privateKey: string;
+        } | {
+            publicKey: string;
+        };
+        arkServerUrl: string;
+        arkServerPublicKey?: string;
+    };
+};
+export type ResponseInitWallet = ResponseEnvelope & {
+    type: "WALLET_INITIALIZED";
+};
+export type RequestSettle = RequestEnvelope & {
+    type: "SETTLE";
+    payload: {
+        params?: SettleParams;
+    };
+};
+export type ResponseSettle = ResponseEnvelope & {
+    type: "SETTLE_SUCCESS";
+    payload: {
+        txid: string;
+    };
+};
+export type RequestSendBitcoin = RequestEnvelope & {
+    type: "SEND_BITCOIN";
+    payload: SendBitcoinParams;
+};
+export type ResponseSendBitcoin = ResponseEnvelope & {
+    type: "SEND_BITCOIN_SUCCESS";
+    payload: {
+        txid: string;
+    };
+};
+export type RequestGetAddress = RequestEnvelope & {
+    type: "GET_ADDRESS";
+};
+export type ResponseGetAddress = ResponseEnvelope & {
+    type: "ADDRESS";
+    payload: {
+        address: string;
+    };
+};
+export type RequestGetBoardingAddress = RequestEnvelope & {
+    type: "GET_BOARDING_ADDRESS";
+};
+export type ResponseGetBoardingAddress = ResponseEnvelope & {
+    type: "BOARDING_ADDRESS";
+    payload: {
+        address: string;
+    };
+};
+export type RequestGetBalance = RequestEnvelope & {
+    type: "GET_BALANCE";
+};
+export type ResponseGetBalance = ResponseEnvelope & {
+    type: "BALANCE";
+    payload: WalletBalance;
+};
+export type RequestGetVtxos = RequestEnvelope & {
+    type: "GET_VTXOS";
+    payload: {
+        filter?: GetVtxosFilter;
+    };
+};
+export type ResponseGetVtxos = ResponseEnvelope & {
+    type: "VTXOS";
+    payload: {
+        vtxos: Awaited<ReturnType<IWallet["getVtxos"]>>;
+    };
+};
+export type RequestGetBoardingUtxos = RequestEnvelope & {
+    type: "GET_BOARDING_UTXOS";
+};
+export type ResponseGetBoardingUtxos = ResponseEnvelope & {
+    type: "BOARDING_UTXOS";
+    payload: {
+        utxos: ExtendedCoin[];
+    };
+};
+export type RequestGetTransactionHistory = RequestEnvelope & {
+    type: "GET_TRANSACTION_HISTORY";
+};
+export type ResponseGetTransactionHistory = ResponseEnvelope & {
+    type: "TRANSACTION_HISTORY";
+    payload: {
+        transactions: ArkTransaction[];
+    };
+};
+export type RequestGetStatus = RequestEnvelope & {
+    type: "GET_STATUS";
+};
+export type ResponseGetStatus = ResponseEnvelope & {
+    type: "WALLET_STATUS";
+    payload: {
+        walletInitialized: boolean;
+        xOnlyPublicKey: Uint8Array | undefined;
+    };
+};
+export type RequestClear = RequestEnvelope & {
+    type: "CLEAR";
+};
+export type ResponseClear = ResponseEnvelope & {
+    type: "CLEAR_SUCCESS";
+    payload: {
+        cleared: boolean;
+    };
+};
+export type RequestSignTransaction = RequestEnvelope & {
+    type: "SIGN_TRANSACTION";
+    payload: {
+        tx: Transaction;
+        inputIndexes?: number[];
+    };
+};
+export type ResponseSignTransaction = ResponseEnvelope & {
+    type: "SIGN_TRANSACTION";
+    payload: {
+        tx: Transaction;
+    };
+};
+export type RequestReloadWallet = RequestEnvelope & {
+    type: "RELOAD_WALLET";
+};
+export type ResponseReloadWallet = ResponseEnvelope & {
+    type: "RELOAD_SUCCESS";
+    payload: {
+        reloaded: boolean;
+    };
+};
+export type RequestCreateContract = RequestEnvelope & {
+    type: "CREATE_CONTRACT";
+    payload: CreateContractParams;
+};
+export type ResponseCreateContract = ResponseEnvelope & {
+    type: "CONTRACT_CREATED";
+    payload: {
+        contract: Contract;
+    };
+};
+export type RequestGetContracts = RequestEnvelope & {
+    type: "GET_CONTRACTS";
+    payload: {
+        filter?: GetContractsFilter;
+    };
+};
+export type ResponseGetContracts = ResponseEnvelope & {
+    type: "CONTRACTS";
+    payload: {
+        contracts: Contract[];
+    };
+};
+export type RequestGetContractsWithVtxos = RequestEnvelope & {
+    type: "GET_CONTRACTS_WITH_VTXOS";
+    payload: {
+        filter?: GetContractsFilter;
+    };
+};
+export type ResponseGetContractsWithVtxos = ResponseEnvelope & {
+    type: "CONTRACTS_WITH_VTXOS";
+    payload: {
+        contracts: ContractWithVtxos[];
+    };
+};
+export type RequestUpdateContract = RequestEnvelope & {
+    type: "UPDATE_CONTRACT";
+    payload: {
+        script: string;
+        updates: Partial<Omit<Contract, "id" | "createdAt">>;
+    };
+};
+export type ResponseUpdateContract = ResponseEnvelope & {
+    type: "CONTRACT_UPDATED";
+    payload: {
+        contract: Contract;
+    };
+};
+export type RequestDeleteContract = RequestEnvelope & {
+    type: "DELETE_CONTRACT";
+    payload: {
+        script: string;
+    };
+};
+export type ResponseDeleteContract = ResponseEnvelope & {
+    type: "CONTRACT_DELETED";
+    payload: {
+        deleted: boolean;
+    };
+};
+export type RequestGetSpendablePaths = RequestEnvelope & {
+    type: "GET_SPENDABLE_PATHS";
+    payload: {
+        options: GetSpendablePathsOptions;
+    };
+};
+export type ResponseGetSpendablePaths = ResponseEnvelope & {
+    type: "SPENDABLE_PATHS";
+    payload: {
+        paths: PathSelection[];
+    };
+};
+export type RequestIsContractManagerWatching = RequestEnvelope & {
+    type: "IS_CONTRACT_MANAGER_WATCHING";
+};
+export type ResponseIsContractManagerWatching = ResponseEnvelope & {
+    type: "CONTRACT_WATCHING";
+    payload: {
+        isWatching: boolean;
+    };
+};
+export type RequestGetAllSpendingPaths = RequestEnvelope & {
+    type: "GET_ALL_SPENDING_PATHS";
+    payload: {
+        options: GetAllSpendingPathsOptions;
+    };
+};
+export type ResponseGetAllSpendingPaths = ResponseEnvelope & {
+    type: "ALL_SPENDING_PATHS";
+    payload: {
+        paths: PathSelection[];
+    };
+};
+export type ResponseSettleEvent = ResponseEnvelope & {
+    broadcast: true;
+    type: "SETTLE_EVENT";
+    payload: SettlementEvent;
+};
+export type ResponseUtxoUpdate = ResponseEnvelope & {
+    broadcast: true;
+    type: "UTXO_UPDATE";
+    payload: {
+        coins: ExtendedCoin[];
+    };
+};
+export type ResponseVtxoUpdate = ResponseEnvelope & {
+    broadcast: true;
+    type: "VTXO_UPDATE";
+    payload: {
+        newVtxos: ExtendedCoin[];
+        spentVtxos: ExtendedCoin[];
+    };
+};
+export type ResponseContractEvent = ResponseEnvelope & {
+    tag: string;
+    broadcast: true;
+    type: "CONTRACT_EVENT";
+    payload: {
+        event: ContractEvent;
+    };
+};
+export type RequestSend = RequestEnvelope & {
+    type: "SEND";
+    payload: {
+        recipients: Recipient[];
+    };
+};
+export type ResponseSend = ResponseEnvelope & {
+    type: "SEND_SUCCESS";
+    payload: {
+        txid: string;
+    };
+};
+export type RequestGetAssetDetails = RequestEnvelope & {
+    type: "GET_ASSET_DETAILS";
+    payload: {
+        assetId: string;
+    };
+};
+export type ResponseGetAssetDetails = ResponseEnvelope & {
+    type: "ASSET_DETAILS";
+    payload: {
+        assetDetails: AssetDetails;
+    };
+};
+export type RequestIssue = RequestEnvelope & {
+    type: "ISSUE";
+    payload: {
+        params: IssuanceParams;
+    };
+};
+export type ResponseIssue = ResponseEnvelope & {
+    type: "ISSUE_SUCCESS";
+    payload: {
+        result: IssuanceResult;
+    };
+};
+export type RequestReissue = RequestEnvelope & {
+    type: "REISSUE";
+    payload: {
+        params: ReissuanceParams;
+    };
+};
+export type ResponseReissue = ResponseEnvelope & {
+    type: "REISSUE_SUCCESS";
+    payload: {
+        txid: string;
+    };
+};
+export type RequestBurn = RequestEnvelope & {
+    type: "BURN";
+    payload: {
+        params: BurnParams;
+    };
+};
+export type ResponseBurn = ResponseEnvelope & {
+    type: "BURN_SUCCESS";
+    payload: {
+        txid: string;
+    };
+};
+export type WalletUpdaterRequest = RequestInitWallet | RequestSettle | RequestSendBitcoin | RequestGetAddress | RequestGetBoardingAddress | RequestGetBalance | RequestGetVtxos | RequestGetBoardingUtxos | RequestGetTransactionHistory | RequestGetStatus | RequestClear | RequestReloadWallet | RequestSignTransaction | RequestCreateContract | RequestGetContracts | RequestGetContractsWithVtxos | RequestUpdateContract | RequestDeleteContract | RequestGetSpendablePaths | RequestGetAllSpendingPaths | RequestIsContractManagerWatching | RequestSend | RequestGetAssetDetails | RequestIssue | RequestReissue | RequestBurn;
+export type WalletUpdaterResponse = ResponseEnvelope & (ResponseInitWallet | ResponseSettle | ResponseSettleEvent | ResponseSendBitcoin | ResponseGetAddress | ResponseGetBoardingAddress | ResponseGetBalance | ResponseGetVtxos | ResponseGetBoardingUtxos | ResponseGetTransactionHistory | ResponseGetStatus | ResponseClear | ResponseReloadWallet | ResponseUtxoUpdate | ResponseVtxoUpdate | ResponseSignTransaction | ResponseCreateContract | ResponseGetContracts | ResponseGetContractsWithVtxos | ResponseUpdateContract | ResponseDeleteContract | ResponseGetSpendablePaths | ResponseGetAllSpendingPaths | ResponseIsContractManagerWatching | ResponseContractEvent | ResponseSend | ResponseGetAssetDetails | ResponseIssue | ResponseReissue | ResponseBurn);
+export declare class WalletMessageHandler implements MessageHandler<WalletUpdaterRequest, WalletUpdaterResponse> {
+    readonly messageTag: string;
+    private wallet;
+    private readonlyWallet;
+    private arkProvider;
+    private indexerProvider;
+    private walletRepository;
+    private incomingFundsSubscription;
+    private contractEventsSubscription;
+    private onNextTick;
+    /**
+     * 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?: {
+        messageTag?: string;
+    });
+    start(...params: Parameters<MessageHandler["start"]>): Promise<void>;
+    stop(): Promise<void>;
+    tick(_now: number): Promise<WalletUpdaterResponse[]>;
+    private scheduleForNextTick;
+    private requireWallet;
+    private tagged;
+    handleMessage(message: WalletUpdaterRequest): Promise<WalletUpdaterResponse>;
+    private handleInitWallet;
+    private handleGetBalance;
+    private getAllBoardingUtxos;
+    /**
+     * Get spendable vtxos for the current wallet address
+     */
+    private getSpendableVtxos;
+    /**
+     * Get swept vtxos for the current wallet address
+     */
+    private getSweptVtxos;
+    private onWalletInitialized;
+    private handleSettle;
+    private handleSendBitcoin;
+    private handleSignTransaction;
+    private handleGetVtxos;
+    private clear;
+    private ensureContractEventBroadcasting;
+}

package/dist/types/wallet/serviceWorker/wallet.d.ts

@@ -1,10 +1,10 @@
-import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, ArkTransaction, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter, IReadonlyWallet } from "..";
-import { Request } from "./request";
-import { Response } from "./response";
+import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, ArkTransaction, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter, StorageConfig, IReadonlyWallet, IReadonlyAssetManager, IAssetManager, Recipient } from "..";
 import { SettlementEvent } from "../../providers/ark";
 import { Identity, ReadonlyIdentity } from "../../identity";
 import { WalletRepository } from "../../repositories/walletRepository";
 import { ContractRepository } from "../../repositories/contractRepository";
+import { ResponseGetStatus, WalletUpdaterRequest, WalletUpdaterResponse } from "./wallet-message-handler";
+import type { IContractManager } from "../../contracts/contractManager";
 type PrivateKeyIdentity = Identity & {
     toHex(): string;
 };
@@ -27,10 +27,10 @@ type PrivateKeyIdentity = Identity & {
  * });
  *
  * // ADVANCED: Manual setup with service worker control
- * const serviceWorker = await setupServiceWorker("/service-worker.js");
+ * const worker = await setupServiceWorker("/service-worker.js");
  * const identity = SingleKey.fromHex('your_private_key_hex');
  * const wallet = await ServiceWorkerWallet.create({
- *   serviceWorker,
+ *   worker,
  *   identity,
  *   arkServerUrl: 'https://mutinynet.arkade.sh'
  * });
@@ -44,9 +44,11 @@ interface ServiceWorkerWalletOptions {
     arkServerPublicKey?: string;
     arkServerUrl: string;
     esploraUrl?: string;
-    dbName?: string;
-    dbVersion?: number;
+    storage?: StorageConfig;
     identity: ReadonlyIdentity | Identity;
+    delegatorUrl?: string;
+    walletUpdaterTag?: string;
+    messageBusTimeoutMs?: number;
 }
 export type ServiceWorkerWalletCreateOptions = ServiceWorkerWalletOptions & {
     serviceWorker: ServiceWorker;
@@ -56,10 +58,13 @@ export type ServiceWorkerWalletSetupOptions = ServiceWorkerWalletOptions & {
 };
 export declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
     readonly serviceWorker: ServiceWorker;
+    protected readonly messageTag: string;
     readonly walletRepository: WalletRepository;
     readonly contractRepository: ContractRepository;
     readonly identity: ReadonlyIdentity;
-    protected constructor(serviceWorker: ServiceWorker, identity: ReadonlyIdentity, walletRepository: WalletRepository, contractRepository: ContractRepository);
+    private readonly _readonlyAssetManager;
+    get assetManager(): IReadonlyAssetManager;
+    protected constructor(serviceWorker: ServiceWorker, identity: ReadonlyIdentity, walletRepository: WalletRepository, contractRepository: ContractRepository, messageTag: string);
     static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerReadonlyWallet>;
     /**
      * Simplified setup method that handles service worker registration,
@@ -83,23 +88,26 @@ export declare class ServiceWorkerReadonlyWallet implements IReadonlyWallet {
      * ```
      */
     static setup(options: ServiceWorkerWalletSetupOptions): Promise<ServiceWorkerReadonlyWallet>;
-    protected sendMessage<T extends Request.Base>(message: T): Promise<Response.Base>;
+    protected sendMessage(request: WalletUpdaterRequest): Promise<WalletUpdaterResponse>;
     clear(): Promise<void>;
     getAddress(): Promise<string>;
     getBoardingAddress(): Promise<string>;
     getBalance(): Promise<WalletBalance>;
     getBoardingUtxos(): Promise<ExtendedCoin[]>;
-    getStatus(): Promise<Response.WalletStatus["status"]>;
+    getStatus(): Promise<ResponseGetStatus["payload"]>;
     getTransactionHistory(): Promise<ArkTransaction[]>;
     getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
     reload(): Promise<boolean>;
+    getContractManager(): Promise<IContractManager>;
 }
 export declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet implements IWallet {
     readonly serviceWorker: ServiceWorker;
     readonly walletRepository: WalletRepository;
     readonly contractRepository: ContractRepository;
     readonly identity: Identity;
-    protected constructor(serviceWorker: ServiceWorker, identity: PrivateKeyIdentity, walletRepository: WalletRepository, contractRepository: ContractRepository);
+    private readonly _assetManager;
+    protected constructor(serviceWorker: ServiceWorker, identity: PrivateKeyIdentity, walletRepository: WalletRepository, contractRepository: ContractRepository, messageTag: string);
+    get assetManager(): IAssetManager;
     static create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerWallet>;
     /**
      * Simplified setup method that handles service worker registration,
@@ -125,5 +133,6 @@ export declare class ServiceWorkerWallet extends ServiceWorkerReadonlyWallet imp
     static setup(options: ServiceWorkerWalletSetupOptions): Promise<ServiceWorkerWallet>;
     sendBitcoin(params: SendBitcoinParams): Promise<string>;
     settle(params?: SettleParams, callback?: (event: SettlementEvent) => void): Promise<string>;
+    send(...recipients: Recipient[]): Promise<string>;
 }
 export {};

package/dist/types/wallet/utils.d.ts

@@ -1,5 +1,8 @@
-import type { Coin, ExtendedCoin, ExtendedVirtualCoin, VirtualCoin } from "..";
+import { Recipient } from ".";
+import { type Coin, type ExtendedCoin, type ExtendedVirtualCoin, type VirtualCoin } from "..";
+import type { Contract } from "../contracts/types";
 import { ReadonlyWallet } from "./wallet";
+import { Bytes } from "@scure/btc-signer/utils";
 export declare const DUST_AMOUNT = 546;
 export declare function extendVirtualCoin(wallet: {
     offchainTapscript: ReadonlyWallet["offchainTapscript"];
@@ -7,3 +10,11 @@ export declare function extendVirtualCoin(wallet: {
 export declare function extendCoin(wallet: {
     boardingTapscript: ReadonlyWallet["boardingTapscript"];
 }, utxo: Coin): ExtendedCoin;
+export declare function extendVtxoFromContract(vtxo: VirtualCoin, contract: Contract): ExtendedVirtualCoin;
+export declare function getRandomId(): string;
+export declare function isValidArkAddress(address: string): boolean;
+type ValidatedRecipient = Required<Recipient> & {
+    script: Bytes;
+};
+export declare function validateRecipients(recipients: Recipient[], dustAmount: number): ValidatedRecipient[];
+export {};

package/dist/types/wallet/validation.d.ts

@@ -0,0 +1,24 @@
+import { Recipient } from ".";
+import { Transaction } from "../utils/transaction";
+import type { Network } from "../networks";
+export declare const ErrOffchainOutputNotFound: (address: string) => Error;
+export declare const ErrInvalidAssetOutputAmount: (got: bigint, want: bigint, assetId: string) => Error;
+export declare const ErrAssetGroupNotFound: (assetId: string) => Error;
+export declare const ErrAssetOutputNotFound: (assetId: string, outputIndex: number) => Error;
+export declare const ErrInvalidOnchainOutputAmount: (address: string) => Error;
+export declare const ErrInvalidOnchainOutputAssets: (address: string) => Error;
+export declare const ErrOnchainOutputNotFound: (address: string) => Error;
+export declare const ErrInvalidOffchainOutputAmount: (address: string) => Error;
+/**
+ * Validates both offchain and onchain recipients.
+ * Offchain recipients are checked against vtxo tree leaves for correct amounts and assets.
+ * Onchain recipients are validated against the round transaction outputs (amounts and scripts)
+ * via validateOnchainRecipient.
+ *
+ * @param commitmentTx - The commitment transaction to validate against
+ * @param vtxoTreeLeaves - The vtxo tree leaves to validate against
+ * @param recipients - The expected recipients to validate (both offchain and onchain)
+ * @param network - Network for decoding onchain addresses (e.g. mainnet, testnet)
+ * @throws {Error} if a recipient is not present or invalid in the vtxo tree or commitment tx
+ */
+export declare function validateBatchRecipients(commitmentTx: Transaction, vtxoTreeLeaves: Transaction[], recipients: Recipient[], network: Network): void;