@arkade-os/sdk 0.1.3 → 0.2.0

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

@@ -1,29 +1,34 @@
 import { Output, SettlementEvent } from "../providers/ark";
 import { Identity } from "../identity";
-import { NetworkName } from "../networks";
 import { RelativeTimelock } from "../script/tapscript";
 import { EncodedVtxoScript, TapLeafScript } from "../script/base";
+import { Bytes } from "@scure/btc-signer/utils";
+/**
+ * Configuration options for wallet initialization.
+ *
+ * Defines the parameters required to create and configure a wallet instance,
+ * including identity, server URLs, and optional timelock settings.
+ * If optional parameters are not provided, the wallet will fetch them from the
+ * Ark server.
+ */
 export interface WalletConfig {
-    network: NetworkName;
     identity: Identity;
+    arkServerUrl: string;
     esploraUrl?: string;
-    arkServerUrl?: string;
     arkServerPublicKey?: string;
     boardingTimelock?: RelativeTimelock;
     exitTimelock?: RelativeTimelock;
 }
 export interface WalletBalance {
-    onchain: {
+    boarding: {
         confirmed: number;
         unconfirmed: number;
         total: number;
     };
-    offchain: {
-        swept: number;
-        settled: number;
-        pending: number;
-        total: number;
-    };
+    settled: number;
+    preconfirmed: number;
+    available: number;
+    recoverable: number;
     total: number;
 }
 export interface SendBitcoinParams {
@@ -37,32 +42,9 @@ export interface Recipient {
     amount: number;
 }
 export interface SettleParams {
-    inputs: (string | ({
-        tapLeafScript: TapLeafScript;
-    } & Outpoint & EncodedVtxoScript))[];
+    inputs: ExtendedCoin[];
     outputs: Output[];
 }
-export interface VtxoTaprootAddress {
-    address: string;
-    scripts: {
-        exit: string[];
-        forfeit: string[];
-    };
-}
-export interface AddressInfo {
-    offchain: VtxoTaprootAddress;
-    boarding: VtxoTaprootAddress;
-}
-export interface Addresses {
-    onchain: string;
-    offchain?: string;
-    boarding?: string;
-    bip21: string;
-}
-export interface TapscriptInfo {
-    offchain?: string[];
-    boarding?: string[];
-}
 export interface Status {
     confirmed: boolean;
     block_height?: number;
@@ -70,8 +52,8 @@ export interface Status {
     block_time?: number;
 }
 export interface VirtualStatus {
-    state: "pending" | "settled" | "swept" | "spent";
-    batchTxID?: string;
+    state: "preconfirmed" | "settled" | "swept" | "spent";
+    commitmentTxIds?: string[];
     batchExpiry?: number;
 }
 export interface Outpoint {
@@ -85,7 +67,10 @@ export interface Coin extends Outpoint {
 export interface VirtualCoin extends Coin {
     virtualStatus: VirtualStatus;
     spentBy?: string;
+    settledBy?: string;
+    arkTxId?: string;
     createdAt: Date;
+    isUnrolled: boolean;
 }
 export declare enum TxType {
     TxSent = "SENT",
@@ -93,8 +78,8 @@ export declare enum TxType {
 }
 export interface TxKey {
     boardingTxid: string;
-    roundTxid: string;
-    redeemTxid: string;
+    commitmentTxid: string;
+    arkTxid: string;
 }
 export interface ArkTransaction {
     key: TxKey;
@@ -103,21 +88,37 @@ export interface ArkTransaction {
     settled: boolean;
     createdAt: number;
 }
-export type ExtendedCoin = {
-    tapLeafScript: TapLeafScript;
-} & EncodedVtxoScript & Coin;
-export type ExtendedVirtualCoin = {
-    tapLeafScript: TapLeafScript;
-} & EncodedVtxoScript & VirtualCoin;
+export type TapLeaves = {
+    forfeitTapLeafScript: TapLeafScript;
+    intentTapLeafScript: TapLeafScript;
+};
+export type ExtendedCoin = TapLeaves & EncodedVtxoScript & Coin & {
+    extraWitness?: Bytes[];
+};
+export type ExtendedVirtualCoin = TapLeaves & EncodedVtxoScript & VirtualCoin & {
+    extraWitness?: Bytes[];
+};
+export declare function isSpendable(vtxo: VirtualCoin): boolean;
+export declare function isRecoverable(vtxo: VirtualCoin): boolean;
+export declare function isSubdust(vtxo: VirtualCoin, dust: bigint): boolean;
+export type GetVtxosFilter = {
+    withRecoverable?: boolean;
+    withUnrolled?: boolean;
+};
+/**
+ * Core wallet interface for Bitcoin transactions with Ark protocol support.
+ *
+ * This interface defines the contract that all wallet implementations must follow.
+ * It provides methods for address management, balance checking, virtual UTXO
+ * operations, and transaction management including sending, settling, and unrolling.
+ */
 export interface IWallet {
-    getAddress(): Promise<Addresses>;
-    getAddressInfo(): Promise<AddressInfo>;
+    getAddress(): Promise<string>;
+    getBoardingAddress(): Promise<string>;
     getBalance(): Promise<WalletBalance>;
-    getCoins(): Promise<Coin[]>;
-    getVtxos(): Promise<ExtendedVirtualCoin[]>;
+    getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
     getBoardingUtxos(): Promise<ExtendedCoin[]>;
     getTransactionHistory(): Promise<ArkTransaction[]>;
-    sendBitcoin(params: SendBitcoinParams, zeroFee?: boolean): Promise<string>;
+    sendBitcoin(params: SendBitcoinParams): Promise<string>;
     settle(params?: SettleParams, eventCallback?: (event: SettlementEvent) => void): Promise<string>;
-    exit(outpoints?: Outpoint[]): Promise<void>;
 }

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

@@ -0,0 +1,49 @@
+import { P2TR } from "@scure/btc-signer/payment";
+import { Coin, SendBitcoinParams } from ".";
+import { Identity } from "../identity";
+import { Network, NetworkName } from "../networks";
+import { OnchainProvider } from "../providers/onchain";
+import { Transaction } from "@scure/btc-signer";
+import { AnchorBumper } from "../utils/anchor";
+/**
+ * Onchain Bitcoin wallet implementation for traditional Bitcoin transactions.
+ *
+ * This wallet handles regular Bitcoin transactions on the blockchain without
+ * using the Ark protocol. It supports P2TR (Pay-to-Taproot) addresses and
+ * provides basic Bitcoin wallet functionality.
+ *
+ * @example
+ * ```typescript
+ * const wallet = new OnchainWallet(identity, 'mainnet');
+ * const balance = await wallet.getBalance();
+ * const txid = await wallet.send({
+ *   address: 'bc1...',
+ *   amount: 50000
+ * });
+ * ```
+ */
+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;
+    constructor(identity: Identity, network: NetworkName, provider?: OnchainProvider);
+    get address(): string;
+    getCoins(): Promise<Coin[]>;
+    getBalance(): Promise<number>;
+    send(params: SendBitcoinParams): Promise<string>;
+    bumpP2A(parent: Transaction): Promise<[string, string]>;
+}
+/**
+ * Select coins to reach a target amount, prioritizing those closer to expiry
+ * @param coins List of coins to select from
+ * @param targetAmount Target amount to reach in satoshis
+ * @param forceChange If true, ensure the coin selection will require a change output
+ * @returns Selected coins and change amount, or null if insufficient funds
+ */
+export declare function selectCoins(coins: Coin[], targetAmount: number, forceChange?: boolean): {
+    inputs: Coin[];
+    changeAmount: bigint;
+};

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

@@ -0,0 +1,32 @@
+import { ExtendedCoin, IWallet } from ".";
+import { SettlementEvent } from "../providers/ark";
+/**
+ * Ramps is a class wrapping IWallet.settle method to provide a more convenient interface for onboarding and offboarding operations.
+ *
+ * @example
+ * ```typescript
+ * const ramps = new Ramps(wallet);
+ * await ramps.onboard(); // onboard all boarding utxos
+ * await ramps.offboard(myOnchainAddress); // collaborative exit all vtxos to onchain address
+ * ```
+ */
+export declare class Ramps {
+    readonly wallet: IWallet;
+    constructor(wallet: IWallet);
+    /**
+     * Onboard boarding utxos.
+     *
+     * @param boardingUtxos - The boarding utxos to onboard. If not provided, all boarding utxos will be used.
+     * @param amount - The amount to onboard. If not provided, the total amount of boarding utxos will be onboarded.
+     * @param eventCallback - The callback to receive settlement events. optional.
+     */
+    onboard(boardingUtxos?: ExtendedCoin[], amount?: bigint, eventCallback?: (event: SettlementEvent) => void): ReturnType<IWallet["settle"]>;
+    /**
+     * Offboard vtxos, or "collaborative exit" vtxos to onchain address.
+     *
+     * @param destinationAddress - The destination address to offboard to.
+     * @param amount - The amount to offboard. If not provided, the total amount of vtxos will be offboarded.
+     * @param eventCallback - The callback to receive settlement events. optional.
+     */
+    offboard(destinationAddress: string, amount?: bigint, eventCallback?: (event: SettlementEvent) => void): ReturnType<IWallet["settle"]>;
+}

package/dist/types/wallet/serviceWorker/db/vtxo/idb.d.ts

@@ -11,6 +11,8 @@ export declare class IndexedDBVtxoRepository implements VtxoRepository {
     addOrUpdate(vtxos: ExtendedVirtualCoin[]): Promise<void>;
     deleteAll(): Promise<void>;
     getSpendableVtxos(): Promise<ExtendedVirtualCoin[]>;
+    getSweptVtxos(): Promise<ExtendedVirtualCoin[]>;
+    getSpentVtxos(): Promise<ExtendedVirtualCoin[]>;
     getAllVtxos(): Promise<{
         spendable: ExtendedVirtualCoin[];
         spent: ExtendedVirtualCoin[];

package/dist/types/wallet/serviceWorker/db/vtxo/index.d.ts

@@ -3,6 +3,8 @@ export interface VtxoRepository {
     addOrUpdate(vtxos: ExtendedVirtualCoin[]): Promise<void>;
     deleteAll(): Promise<void>;
     getSpendableVtxos(): Promise<ExtendedVirtualCoin[]>;
+    getSweptVtxos(): Promise<ExtendedVirtualCoin[]>;
+    getSpentVtxos(): Promise<ExtendedVirtualCoin[]>;
     getAllVtxos(): Promise<{
         spendable: ExtendedVirtualCoin[];
         spent: ExtendedVirtualCoin[];

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

@@ -1,7 +1,9 @@
-import { NetworkName } from "../../networks";
-import { SettleParams, SendBitcoinParams, Outpoint } from "..";
+import { SettleParams, SendBitcoinParams, GetVtxosFilter } from "..";
+/**
+ * Request is the namespace that contains the request types for the service worker.
+ */
 export declare namespace Request {
-    type Type = "INIT_WALLET" | "SETTLE" | "GET_ADDRESS" | "GET_ADDRESS_INFO" | "GET_BALANCE" | "GET_COINS" | "GET_VTXOS" | "GET_VIRTUAL_COINS" | "GET_BOARDING_UTXOS" | "SEND_BITCOIN" | "GET_TRANSACTION_HISTORY" | "GET_STATUS" | "CLEAR" | "EXIT";
+    type Type = "INIT_WALLET" | "SETTLE" | "GET_ADDRESS" | "GET_BOARDING_ADDRESS" | "GET_BALANCE" | "GET_VTXOS" | "GET_VIRTUAL_COINS" | "GET_BOARDING_UTXOS" | "SEND_BITCOIN" | "GET_TRANSACTION_HISTORY" | "GET_STATUS" | "CLEAR" | "SIGN";
     interface Base {
         type: Type;
         id: string;
@@ -11,7 +13,6 @@ export declare namespace Request {
         type: "INIT_WALLET";
         privateKey: string;
         arkServerUrl: string;
-        network: NetworkName;
         arkServerPublicKey?: string;
     }
     function isInitWallet(message: Base): message is InitWallet;
@@ -24,20 +25,17 @@ export declare namespace Request {
         type: "GET_ADDRESS";
     }
     function isGetAddress(message: Base): message is GetAddress;
-    interface GetAddressInfo extends Base {
-        type: "GET_ADDRESS_INFO";
+    interface GetBoardingAddress extends Base {
+        type: "GET_BOARDING_ADDRESS";
     }
-    function isGetAddressInfo(message: Base): message is GetAddressInfo;
+    function isGetBoardingAddress(message: Base): message is GetBoardingAddress;
     interface GetBalance extends Base {
         type: "GET_BALANCE";
     }
     function isGetBalance(message: Base): message is GetBalance;
-    interface GetCoins extends Base {
-        type: "GET_COINS";
-    }
-    function isGetCoins(message: Base): message is GetCoins;
     interface GetVtxos extends Base {
         type: "GET_VTXOS";
+        filter?: GetVtxosFilter;
     }
     function isGetVtxos(message: Base): message is GetVtxos;
     interface GetVirtualCoins extends Base {
@@ -51,7 +49,6 @@ export declare namespace Request {
     interface SendBitcoin extends Base {
         type: "SEND_BITCOIN";
         params: SendBitcoinParams;
-        zeroFee?: boolean;
     }
     function isSendBitcoin(message: Base): message is SendBitcoin;
     interface GetTransactionHistory extends Base {
@@ -65,9 +62,10 @@ export declare namespace Request {
     interface Clear extends Base {
         type: "CLEAR";
     }
-    interface Exit extends Base {
-        type: "EXIT";
-        outpoints?: Outpoint[];
+    interface Sign extends Base {
+        type: "SIGN";
+        tx: string;
+        inputIndexes?: number[];
     }
-    function isExit(message: Base): message is Exit;
+    function isSign(message: Base): message is Sign;
 }

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

@@ -1,7 +1,10 @@
-import { WalletBalance, Coin, VirtualCoin, ArkTransaction, AddressInfo as WalletAddressInfo, IWallet, Addresses } from "..";
+import { WalletBalance, VirtualCoin, ArkTransaction, IWallet } from "..";
 import { SettlementEvent } from "../../providers/ark";
+/**
+ * Response is the namespace that contains the response types for the service worker.
+ */
 export declare namespace Response {
-    type Type = "WALLET_INITIALIZED" | "SETTLE_EVENT" | "SETTLE_SUCCESS" | "ADDRESS" | "ADDRESS_INFO" | "BALANCE" | "COINS" | "VTXOS" | "VIRTUAL_COINS" | "BOARDING_UTXOS" | "SEND_BITCOIN_SUCCESS" | "TRANSACTION_HISTORY" | "WALLET_STATUS" | "ERROR" | "CLEAR_RESPONSE" | "EXIT_SUCCESS";
+    type Type = "WALLET_INITIALIZED" | "SETTLE_EVENT" | "SETTLE_SUCCESS" | "ADDRESS" | "BOARDING_ADDRESS" | "BALANCE" | "VTXOS" | "VIRTUAL_COINS" | "BOARDING_UTXOS" | "SEND_BITCOIN_SUCCESS" | "TRANSACTION_HISTORY" | "WALLET_STATUS" | "ERROR" | "CLEAR_RESPONSE" | "SIGN_SUCCESS";
     interface Base {
         type: Type;
         success: boolean;
@@ -30,17 +33,17 @@ export declare namespace Response {
     interface Address extends Base {
         type: "ADDRESS";
         success: true;
-        addresses: Addresses;
+        address: string;
     }
     function isAddress(response: Base): response is Address;
-    function addresses(id: string, addresses: Addresses): Address;
-    interface AddressInfo extends Base {
-        type: "ADDRESS_INFO";
+    function isBoardingAddress(response: Base): response is BoardingAddress;
+    function address(id: string, address: string): Address;
+    interface BoardingAddress extends Base {
+        type: "BOARDING_ADDRESS";
         success: true;
-        addressInfo: WalletAddressInfo;
+        address: string;
     }
-    function isAddressInfo(response: Base): response is AddressInfo;
-    function addressInfo(id: string, addressInfo: WalletAddressInfo): AddressInfo;
+    function boardingAddress(id: string, address: string): BoardingAddress;
     interface Balance extends Base {
         type: "BALANCE";
         success: true;
@@ -48,13 +51,6 @@ export declare namespace Response {
     }
     function isBalance(response: Base): response is Balance;
     function balance(id: string, balance: WalletBalance): Balance;
-    interface Coins extends Base {
-        type: "COINS";
-        success: true;
-        coins: Coin[];
-    }
-    function isCoins(response: Base): response is Coins;
-    function coins(id: string, coins: Coin[]): Coins;
     interface Vtxos extends Base {
         type: "VTXOS";
         success: true;
@@ -104,9 +100,11 @@ export declare namespace Response {
     }
     function isClearResponse(response: Base): response is ClearResponse;
     function clearResponse(id: string, success: boolean): ClearResponse;
-    interface ExitSuccess extends Base {
-        type: "EXIT_SUCCESS";
+    interface SignSuccess extends Base {
+        type: "SIGN_SUCCESS";
         success: true;
+        tx: string;
     }
-    function exitSuccess(id: string): ExitSuccess;
+    function signSuccess(id: string, tx: string): SignSuccess;
+    function isSignSuccess(response: Base): response is SignSuccess;
 }

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

@@ -1 +1,9 @@
+/**
+ * setupServiceWorker sets up the service worker.
+ * @param path - the path to the service worker script
+ * @example
+ * ```typescript
+ * const serviceWorker = await setupServiceWorker("/service-worker.js");
+ * ```
+ */
 export declare function setupServiceWorker(path: string): Promise<ServiceWorker>;

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

@@ -1,8 +1,35 @@
-import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, AddressInfo, Coin, ArkTransaction, WalletConfig, ExtendedCoin, ExtendedVirtualCoin, Addresses, Outpoint } from "..";
+import { IWallet, WalletBalance, SendBitcoinParams, SettleParams, ArkTransaction, WalletConfig, ExtendedCoin, ExtendedVirtualCoin, GetVtxosFilter } from "..";
 import { Response } from "./response";
 import { SettlementEvent } from "../../providers/ark";
-export declare class ServiceWorkerWallet implements IWallet {
+import { Identity } from "../../identity";
+import { SignerSession } from "../../tree/signingSession";
+import { Transaction } from "@scure/btc-signer";
+/**
+ * Service Worker-based wallet implementation for browser environments.
+ *
+ * This wallet uses a service worker as a backend to handle wallet logic,
+ * providing secure key storage and transaction signing in web applications.
+ * The service worker runs in a separate thread and can persist data between
+ * browser sessions.
+ *
+ * @example
+ * ```typescript
+ * // Create and initialize the service worker wallet
+ * const serviceWorker = await setupServiceWorker("/service-worker.js");
+ * const wallet = new ServiceWorkerWallet(serviceWorker);
+ * await wallet.init({
+ *   privateKey: 'your_private_key_hex',
+ *   arkServerUrl: 'https://ark.example.com'
+ * });
+ *
+ * // Use like any other wallet
+ * const address = await wallet.getAddress();
+ * const balance = await wallet.getBalance();
+ * ```
+ */
+export declare class ServiceWorkerWallet implements IWallet, Identity {
     readonly serviceWorker: ServiceWorker;
+    private cachedXOnlyPublicKey;
     constructor(serviceWorker: ServiceWorker);
     getStatus(): Promise<Response.WalletStatus["status"]>;
     init(config: Omit<WalletConfig, "identity"> & {
@@ -10,14 +37,15 @@ export declare class ServiceWorkerWallet implements IWallet {
     }, failIfInitialized?: boolean): Promise<void>;
     clear(): Promise<void>;
     private sendMessage;
-    getAddress(): Promise<Addresses>;
-    getAddressInfo(): Promise<AddressInfo>;
+    getAddress(): Promise<string>;
+    getBoardingAddress(): Promise<string>;
     getBalance(): Promise<WalletBalance>;
-    getCoins(): Promise<Coin[]>;
-    getVtxos(): Promise<ExtendedVirtualCoin[]>;
+    getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
     getBoardingUtxos(): Promise<ExtendedCoin[]>;
-    sendBitcoin(params: SendBitcoinParams, zeroFee?: boolean): Promise<string>;
+    sendBitcoin(params: SendBitcoinParams): Promise<string>;
     settle(params?: SettleParams, callback?: (event: SettlementEvent) => void): Promise<string>;
     getTransactionHistory(): Promise<ArkTransaction[]>;
-    exit(outpoints?: Outpoint[]): Promise<void>;
+    xOnlyPublicKey(): Uint8Array;
+    signerSession(): SignerSession;
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
 }

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

@@ -1,9 +1,14 @@
 import { VtxoRepository } from "./db/vtxo";
+/**
+ * Worker is a class letting to interact with ServiceWorkerWallet from the client
+ * it aims to be run in a service worker context
+ */
 export declare class Worker {
     private readonly vtxoRepository;
     private readonly messageCallback;
     private wallet;
     private arkProvider;
+    private indexerProvider;
     private vtxoSubscription;
     constructor(vtxoRepository?: VtxoRepository, messageCallback?: (message: ExtendableMessageEvent) => void);
     start(withServiceWorkerUpdate?: boolean): Promise<void>;
@@ -15,13 +20,12 @@ export declare class Worker {
     private handleSettle;
     private handleSendBitcoin;
     private handleGetAddress;
-    private handleGetAddressInfo;
+    private handleGetBoardingAddress;
     private handleGetBalance;
-    private handleGetCoins;
     private handleGetVtxos;
     private handleGetBoardingUtxos;
     private handleGetTransactionHistory;
     private handleGetStatus;
-    private handleExit;
+    private handleSign;
     private handleMessage;
 }

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

@@ -0,0 +1,102 @@
+import { Transaction } from "@scure/btc-signer";
+import { ChainTx, IndexerProvider } from "../providers/indexer";
+import { AnchorBumper } from "../utils/anchor";
+import { OnchainProvider } from "../providers/onchain";
+import { Outpoint } from ".";
+import { Wallet } from "./wallet";
+export declare namespace Unroll {
+    enum StepType {
+        UNROLL = 0,
+        WAIT = 1,
+        DONE = 2
+    }
+    /**
+     * Unroll step where the transaction has to be broadcasted in a 1C1P package
+     */
+    type UnrollStep = {
+        tx: Transaction;
+    };
+    /**
+     * Wait step where the transaction has to be confirmed onchain
+     */
+    type WaitStep = {
+        txid: string;
+    };
+    /**
+     * Done step where the unrolling process is complete
+     */
+    type DoneStep = {
+        vtxoTxid: string;
+    };
+    type Step = ({
+        type: StepType.DONE;
+    } & DoneStep) | ({
+        type: StepType.UNROLL;
+    } & UnrollStep) | ({
+        type: StepType.WAIT;
+    } & WaitStep);
+    /**
+     * Manages the unrolling process of a VTXO back to the Bitcoin blockchain.
+     *
+     * The Session class implements an async iterator that processes the unrolling steps:
+     * 1. **WAIT**: Waits for a transaction to be confirmed onchain (if it's in mempool)
+     * 2. **UNROLL**: Broadcasts the next transaction in the chain to the blockchain
+     * 3. **DONE**: Indicates the unrolling process is complete
+     *
+     * The unrolling process works by traversing the transaction chain from the root (most recent)
+     * to the leaf (oldest), broadcasting each transaction that isn't already onchain.
+     *
+     * @example
+     * ```typescript
+     * const session = await Unroll.Session.create(vtxoOutpoint, bumper, explorer, indexer);
+     *
+     * // iterate over the steps
+     * for await (const doneStep of session) {
+     *   switch (doneStep.type) {
+     *     case Unroll.StepType.WAIT:
+     *       console.log(`Transaction ${doneStep.txid} confirmed`);
+     *       break;
+     *     case Unroll.StepType.UNROLL:
+     *       console.log(`Broadcasting transaction ${doneStep.tx.id}`);
+     *       break;
+     *     case Unroll.StepType.DONE:
+     *       console.log(`Unrolling complete for VTXO ${doneStep.vtxoTxid}`);
+     *       break;
+     *   }
+     * }
+     * ```
+     **/
+    class Session implements AsyncIterable<Step> {
+        readonly toUnroll: Outpoint & {
+            chain: ChainTx[];
+        };
+        readonly bumper: AnchorBumper;
+        readonly explorer: OnchainProvider;
+        readonly indexer: IndexerProvider;
+        constructor(toUnroll: Outpoint & {
+            chain: ChainTx[];
+        }, bumper: AnchorBumper, explorer: OnchainProvider, indexer: IndexerProvider);
+        static create(toUnroll: Outpoint, bumper: AnchorBumper, explorer: OnchainProvider, indexer: IndexerProvider): Promise<Session>;
+        /**
+         * Get the next step to be executed
+         * @returns The next step to be executed + the function to execute it
+         */
+        next(): Promise<Step & {
+            do: () => Promise<void>;
+        }>;
+        /**
+         * Iterate over the steps to be executed and execute them
+         * @returns An async iterator over the executed steps
+         */
+        [Symbol.asyncIterator](): AsyncIterator<Step>;
+    }
+    /**
+     * Complete the unroll of a VTXO by broadcasting the transaction that spends the CSV path.
+     * @param wallet the wallet owning the VTXO(s)
+     * @param vtxoTxids the txids of the VTXO(s) to complete unroll
+     * @param outputAddress the address to send the unrolled funds to
+     * @throws if the VTXO(s) are not fully unrolled, if the txids are not found, if the tx is not confirmed, if no exit path is found or not available
+     * @returns the txid of the transaction spending the unrolled funds
+     */
+    function completeUnroll(wallet: Wallet, vtxoTxids: string[], outputAddress: string): Promise<string>;
+}