@arkade-os/sdk 0.3.12 → 0.4.0-next.0

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

@@ -3,10 +3,13 @@ import { ArkProvider, Output, SettlementEvent } from "../providers/ark";
 import { Identity, ReadonlyIdentity } from "../identity";
 import { RelativeTimelock } from "../script/tapscript";
 import { EncodedVtxoScript, TapLeafScript } from "../script/base";
-import { StorageAdapter } from "../storage";
 import { RenewalConfig } from "./vtxo-manager";
 import { IndexerProvider } from "../providers/indexer";
 import { OnchainProvider } from "../providers/onchain";
+import { ContractWatcherConfig } from "../contracts/contractWatcher";
+import { ContractRepository, WalletRepository } from "../repositories";
+import { IContractManager } from "../contracts/contractManager";
+import { DelegatorProvider } from "../providers/delegator";
 /**
  * Base configuration options shared by all wallet types.
  *
@@ -28,10 +31,11 @@ export interface BaseWalletConfig {
     arkServerPublicKey?: string;
     boardingTimelock?: RelativeTimelock;
     exitTimelock?: RelativeTimelock;
-    storage?: StorageAdapter;
+    storage?: StorageConfig;
     arkProvider?: ArkProvider;
     indexerProvider?: IndexerProvider;
     onchainProvider?: OnchainProvider;
+    delegatorProvider?: DelegatorProvider;
 }
 /**
  * Configuration options for readonly wallet initialization.
@@ -62,6 +66,11 @@ export interface BaseWalletConfig {
  */
 export interface ReadonlyWalletConfig extends BaseWalletConfig {
     identity: ReadonlyIdentity;
+    /**
+     * Configuration for the ContractManager's watcher.
+     * Controls reconnection behavior and failsafe polling.
+     */
+    watcherConfig?: Partial<Omit<ContractWatcherConfig, "indexerProvider">>;
 }
 /**
  * Configuration options for full wallet initialization.
@@ -101,6 +110,10 @@ export interface WalletConfig extends ReadonlyWalletConfig {
     identity: Identity;
     renewalConfig?: RenewalConfig;
 }
+export type StorageConfig = {
+    walletRepository: WalletRepository;
+    contractRepository: ContractRepository;
+};
 /**
  * Provider class constructor interface for dependency injection.
  * Ensures provider classes follow the consistent constructor pattern.
@@ -119,6 +132,7 @@ export interface WalletBalance {
     available: number;
     recoverable: number;
     total: number;
+    assets: Asset[];
 }
 export interface SendBitcoinParams {
     address: string;
@@ -127,8 +141,43 @@ export interface SendBitcoinParams {
     memo?: string;
     selectedVtxos?: VirtualCoin[];
 }
+export interface Asset {
+    assetId: string;
+    amount: number;
+}
 export interface Recipient {
     address: string;
+    amount?: number;
+    assets?: Asset[];
+}
+export type KnownMetadata = Partial<{
+    name: string;
+    ticker: string;
+    decimals: number;
+    icon: string;
+}>;
+export type AssetMetadata = KnownMetadata & Record<string, unknown>;
+export type AssetDetails = {
+    assetId: string;
+    supply: number;
+    metadata?: AssetMetadata;
+    controlAssetId?: string;
+};
+export interface IssuanceParams {
+    amount: number;
+    controlAssetId?: string;
+    metadata?: AssetMetadata;
+}
+export interface IssuanceResult {
+    arkTxId: string;
+    assetId: string;
+}
+export interface ReissuanceParams {
+    assetId: string;
+    amount: number;
+}
+export interface BurnParams {
+    assetId: string;
     amount: number;
 }
 export interface SettleParams {
@@ -163,6 +212,7 @@ export interface VirtualCoin extends Coin {
     createdAt: Date;
     isUnrolled: boolean;
     isSpent?: boolean;
+    assets?: Asset[];
 }
 export declare enum TxType {
     TxSent = "SENT",
@@ -179,6 +229,7 @@ export interface ArkTransaction {
     amount: number;
     settled: boolean;
     createdAt: number;
+    assets?: Asset[];
 }
 export type TapLeaves = {
     forfeitTapLeafScript: TapLeafScript;
@@ -198,6 +249,20 @@ export type GetVtxosFilter = {
     withRecoverable?: boolean;
     withUnrolled?: boolean;
 };
+/**
+ * Readonly asset manager interface for asset operations that do not require wallet identity.
+ */
+export interface IReadonlyAssetManager {
+    getAssetDetails(assetId: string): Promise<AssetDetails>;
+}
+/**
+ * Asset manager interface for asset operations that require wallet identity.
+ */
+export interface IAssetManager extends IReadonlyAssetManager {
+    issue(params: IssuanceParams): Promise<IssuanceResult>;
+    reissue(params: ReissuanceParams): Promise<string>;
+    burn(params: BurnParams): Promise<string>;
+}
 /**
  * Core wallet interface for Bitcoin transactions with Ark protocol support.
  *
@@ -209,6 +274,8 @@ export interface IWallet extends IReadonlyWallet {
     identity: Identity;
     sendBitcoin(params: SendBitcoinParams): Promise<string>;
     settle(params?: SettleParams, eventCallback?: (event: SettlementEvent) => void): Promise<string>;
+    send(...recipients: Recipient[]): Promise<string>;
+    assetManager: IAssetManager;
 }
 /**
  * Readonly wallet interface for Bitcoin transactions with Ark protocol support.
@@ -225,4 +292,10 @@ export interface IReadonlyWallet {
     getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
     getBoardingUtxos(): Promise<ExtendedCoin[]>;
     getTransactionHistory(): Promise<ArkTransaction[]>;
+    /**
+     * Returns the contract manager associated with this wallet.
+     * This is useful for querying contract state and watching for contract events.
+     */
+    getContractManager(): Promise<IContractManager>;
+    assetManager: IReadonlyAssetManager;
 }

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

@@ -25,7 +25,6 @@ import { Transaction } from "../utils/transaction";
 export declare class OnchainWallet implements AnchorBumper {
     private identity;
     static MIN_FEE_RATE: number;
-    static DUST_AMOUNT: number;
     readonly onchainP2TR: P2TR;
     readonly provider: OnchainProvider;
     readonly network: Network;
@@ -34,6 +33,28 @@ export declare class OnchainWallet implements AnchorBumper {
     get address(): string;
     getCoins(): Promise<Coin[]>;
     getBalance(): Promise<number>;
+    /**
+     * Iteratively selects coins and estimates transaction fees until convergence.
+     *
+     * This method handles the circular dependency between coin selection and fee
+     * estimation: the fee depends on transaction size, which depends on the number
+     * of inputs (selected coins) and whether a change output is needed.
+     *
+     * The algorithm iterates up to 10 times, refining the fee estimate based on
+     * the actual transaction structure. It resolves dust oscillation loops that
+     * occur when the change amount hovers near the dust threshold—adding/removing
+     * the change output causes the fee to fluctuate, preventing convergence.
+     * When a lower fee is computed (indicating the change output was dropped),
+     * the function accepts this state to guarantee termination.
+     *
+     * @param coins - Available coins to select from
+     * @param amount - Target send amount in satoshis
+     * @param feeRate - Fee rate in sat/vbyte
+     * @param recipientAddress - Destination address for size estimation
+     * @returns Selected inputs, change amount, and calculated fee
+     * @throws Error if fee estimation fails to converge within max iterations
+     */
+    private estimateFeesAndSelectCoins;
     send(params: SendBitcoinParams): Promise<string>;
     bumpP2A(parent: Transaction): Promise<[string, string]>;
 }

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,8 +1,20 @@
-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"];
 }, vtxo: VirtualCoin): ExtendedVirtualCoin;
 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 {};