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

package/dist/types/repositories/migrations/fromStorageAdapter.d.ts

@@ -0,0 +1,19 @@
+import { StorageAdapter } from "../../storage";
+import { WalletRepository } from "../walletRepository";
+export declare const MIGRATION_KEY: (repoType: "wallet" | "contract") => string;
+export type MigrationStatus = "pending" | "in-progress" | "done" | "not-needed";
+export declare function getMigrationStatus(repoType: "wallet" | "contract", storageAdapter: StorageAdapter): Promise<MigrationStatus>;
+export declare function requiresMigration(repoType: "wallet" | "contract", storageAdapter: StorageAdapter): Promise<boolean>;
+export declare function rollbackMigration(repoType: "wallet" | "contract", storageAdapter: StorageAdapter): Promise<void>;
+/**
+ * Migrate wallet data from the legacy storage adapter to the new one.
+ * It accepts both onchain and offchain addresses, make sure to pass both.
+ *
+ * @param storageAdapter
+ * @param fresh
+ * @param addresses
+ */
+export declare function migrateWalletRepository(storageAdapter: StorageAdapter, fresh: WalletRepository, addresses: {
+    onchain: string[];
+    offchain: string[];
+}): Promise<void>;

package/dist/types/repositories/migrations/walletRepositoryImpl.d.ts

@@ -0,0 +1,27 @@
+import { WalletRepository, WalletState } from "../walletRepository";
+import { StorageAdapter } from "../../storage";
+import { ArkTransaction, ExtendedCoin, ExtendedVirtualCoin } from "../../wallet";
+/**
+ * @deprecated This is only to be used in migration from storage V1
+ */
+export declare class WalletRepositoryImpl implements WalletRepository {
+    readonly version: 1;
+    private storage;
+    constructor(storage: StorageAdapter);
+    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
+    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
+    clearVtxos(address: string): Promise<void>;
+    deleteVtxos(address: string): Promise<void>;
+    getUtxos(address: string): Promise<ExtendedCoin[]>;
+    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
+    clearUtxos(address: string): Promise<void>;
+    deleteUtxos(address: string): Promise<void>;
+    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
+    saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
+    clearTransactions(address: string): Promise<void>;
+    deleteTransactions(address: string): Promise<void>;
+    getWalletState(): Promise<WalletState | null>;
+    saveWalletState(state: WalletState): Promise<void>;
+    clear(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}

package/dist/types/repositories/walletRepository.d.ts

@@ -1,38 +1,27 @@
-import { StorageAdapter } from "../storage";
 import { ArkTransaction, ExtendedCoin, ExtendedVirtualCoin } from "../wallet";
 export interface WalletState {
     lastSyncTime?: number;
     settings?: Record<string, any>;
 }
-export interface WalletRepository {
+export type CommitmentTxRecord = {
+    txid: string;
+    createdAt: number;
+};
+export interface WalletRepository extends AsyncDisposable {
+    readonly version: 1;
+    /**
+     * Clear all data from storage.
+     */
+    clear(): Promise<void>;
     getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
     saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    removeVtxo(address: string, vtxoId: string): Promise<void>;
-    clearVtxos(address: string): Promise<void>;
+    deleteVtxos(address: string): Promise<void>;
     getUtxos(address: string): Promise<ExtendedCoin[]>;
     saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
-    removeUtxo(address: string, utxoId: string): Promise<void>;
-    clearUtxos(address: string): Promise<void>;
+    deleteUtxos(address: string): Promise<void>;
     getTransactionHistory(address: string): Promise<ArkTransaction[]>;
     saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
-    clearTransactions(address: string): Promise<void>;
-    getWalletState(): Promise<WalletState | null>;
-    saveWalletState(state: WalletState): Promise<void>;
-}
-export declare class WalletRepositoryImpl implements WalletRepository {
-    private storage;
-    constructor(storage: StorageAdapter);
-    getVtxos(address: string): Promise<ExtendedVirtualCoin[]>;
-    saveVtxos(address: string, vtxos: ExtendedVirtualCoin[]): Promise<void>;
-    removeVtxo(address: string, vtxoId: string): Promise<void>;
-    clearVtxos(address: string): Promise<void>;
-    getUtxos(address: string): Promise<ExtendedCoin[]>;
-    saveUtxos(address: string, utxos: ExtendedCoin[]): Promise<void>;
-    removeUtxo(address: string, utxoId: string): Promise<void>;
-    clearUtxos(address: string): Promise<void>;
-    getTransactionHistory(address: string): Promise<ArkTransaction[]>;
-    saveTransactions(address: string, txs: ArkTransaction[]): Promise<void>;
-    clearTransactions(address: string): Promise<void>;
+    deleteTransactions(address: string): Promise<void>;
     getWalletState(): Promise<WalletState | null>;
     saveWalletState(state: WalletState): Promise<void>;
 }

package/dist/types/script/base.d.ts

@@ -37,3 +37,4 @@ export declare class VtxoScript {
 export type EncodedVtxoScript = {
     tapTree: Bytes;
 };
+export declare function getSequence(tapLeafScript: TapLeafScript): number | undefined;

package/dist/types/script/delegate.d.ts

@@ -0,0 +1,36 @@
+import { Bytes } from "@scure/btc-signer/utils";
+import { DefaultVtxo } from "./default";
+import { TapLeafScript, VtxoScript } from "./base";
+/**
+ * DelegateVtxo extends DefaultVtxo with an extra delegator path
+ */
+export declare namespace DelegateVtxo {
+    /**
+     * Options extends DefaultVtxo.Options and adds a delegatePubKey
+     */
+    interface Options extends DefaultVtxo.Options {
+        delegatePubKey: Bytes;
+    }
+    /**
+     * DelegateVtxo.Script extends DefaultVtxo.Script and adds a delegate path.
+     * @example
+     * ```typescript
+     * const vtxoScript = new DelegateVtxo.Script({
+     *     pubKey: new Uint8Array(32),
+     *     serverPubKey: new Uint8Array(32),
+     *     delegatePubKey: new Uint8Array(32),
+     * });
+     *
+     * console.log("script pub key:", vtxoScript.pkScript)
+     * ```
+     */
+    class Script extends VtxoScript {
+        readonly options: Options;
+        readonly defaultVtxo: DefaultVtxo.Script;
+        readonly delegateScript: string;
+        constructor(options: Options);
+        forfeit(): TapLeafScript;
+        exit(): TapLeafScript;
+        delegate(): TapLeafScript;
+    }
+}

package/dist/types/storage/asyncStorage.d.ts

@@ -1,4 +1,8 @@
 import type { StorageAdapter } from "./index";
+/**
+ * @deprecated Use repositories instead
+ * Note: This requires @react-native-async-storage/async-storage to be installed
+ */
 export declare class AsyncStorageAdapter implements StorageAdapter {
     private AsyncStorage;
     constructor();

package/dist/types/storage/fileSystem.d.ts

@@ -1,4 +1,7 @@
 import type { StorageAdapter } from "./index";
+/**
+ * @deprecated Use repositories instead
+ */
 export declare class FileSystemStorageAdapter implements StorageAdapter {
     private readonly basePath;
     constructor(dirPath: string);

package/dist/types/storage/inMemory.d.ts

@@ -1,4 +1,7 @@
 import type { StorageAdapter } from "./index";
+/**
+ * @deprecated Use repositories instead
+ */
 export declare class InMemoryStorageAdapter implements StorageAdapter {
     private store;
     getItem(key: string): Promise<string | null>;

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

@@ -1,3 +1,6 @@
+/**
+ * @deprecated Use StorageConfig instead
+ */
 export interface StorageAdapter {
     getItem(key: string): Promise<string | null>;
     setItem(key: string, value: string): Promise<void>;

package/dist/types/storage/indexedDB.d.ts

@@ -1,4 +1,7 @@
 import type { StorageAdapter } from "./index";
+/**
+ * @deprecated Use repositories instead
+ */
 export declare class IndexedDBStorageAdapter implements StorageAdapter {
     private dbName;
     private version;

package/dist/types/storage/localStorage.d.ts

@@ -1,4 +1,7 @@
 import type { StorageAdapter } from "./index";
+/**
+ * @deprecated Use repositories instead
+ */
 export declare class LocalStorageAdapter implements StorageAdapter {
     private getSafeLocalStorage;
     getItem(key: string): Promise<string | null>;

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

@@ -41,3 +41,9 @@ export declare function verifyTapscriptSignatures(tx: Transaction, inputIndex: n
  * @param originalTx original transaction
  */
 export declare function combineTapscriptSigs(signedTx: Transaction, originalTx: Transaction): Transaction;
+/**
+ * Validates if a given string is a valid Ark address by attempting to decode it.
+ * @param address The Ark address to validate.
+ * @returns True if the address is valid, false otherwise.
+ */
+export declare function isValidArkAddress(address: string): boolean;

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

@@ -1,3 +1,4 @@
+import { Network } from "../networks";
 export type VSize = {
     value: bigint;
     fee(feeRate: bigint): bigint;
@@ -7,7 +8,7 @@ export declare class TxWeightEstimator {
     static readonly INPUT_SIZE: number;
     static readonly BASE_CONTROL_BLOCK_SIZE: number;
     static readonly OUTPUT_SIZE: number;
-    static readonly P2WKH_OUTPUT_SIZE: number;
+    static readonly P2WPKH_OUTPUT_SIZE: number;
     static readonly BASE_TX_SIZE: number;
     static readonly WITNESS_HEADER_SIZE = 2;
     static readonly WITNESS_SCALE_FACTOR = 4;
@@ -24,7 +25,16 @@ export declare class TxWeightEstimator {
     addKeySpendInput(isDefault?: boolean): TxWeightEstimator;
     addP2PKHInput(): TxWeightEstimator;
     addTapscriptInput(leafWitnessSize: number, leafScriptSize: number, leafControlBlockSize: number): TxWeightEstimator;
-    addP2WKHOutput(): TxWeightEstimator;
+    addP2WPKHOutput(): TxWeightEstimator;
     addP2TROutput(): TxWeightEstimator;
+    /**
+     * Adds an output given a raw script.
+     * Cost = 8 bytes (amount) + varint(scriptLen) + scriptLen
+     */
+    addOutputScript(script: Uint8Array): TxWeightEstimator;
+    /**
+     * Adds an output by decoding the address to get the exact script size.
+     */
+    addOutputAddress(address: string, network: Network): TxWeightEstimator;
     vsize(): VSize;
 }

package/dist/types/wallet/asset-manager.d.ts

@@ -0,0 +1,78 @@
+import { AssetDetails, BurnParams, IAssetManager, IReadonlyAssetManager, IssuanceParams, IssuanceResult, ReissuanceParams } from ".";
+import { IndexerProvider } from "../providers/indexer";
+import { Wallet } from "./wallet";
+export declare class ReadonlyAssetManager implements IReadonlyAssetManager {
+    readonly indexer: IndexerProvider;
+    constructor(indexer: IndexerProvider);
+    getAssetDetails(assetId: string): Promise<AssetDetails>;
+}
+export declare class AssetManager extends ReadonlyAssetManager implements IAssetManager {
+    readonly wallet: Wallet;
+    constructor(wallet: Wallet);
+    /**
+     * Issue a new asset.
+     * @param params - Parameters for asset issuance
+     * @param params.amount - Amount of asset units to issue
+     * @param params.controlAsset - Optional control asset (for reissuable assets)
+     * @param params.metadata - Optional metadata to attach to the asset
+     * @returns Promise resolving to the ark transaction ID and asset ID
+     *
+     * @example
+     * ```typescript
+     * // Issue a simple non-reissuable asset
+     * const result = await wallet.issueAsset({ amount: 1000 });
+     * console.log('Asset ID:', result.assetId);
+     *
+     * // Issue a reissuable asset with a new control asset
+     * const result = await wallet.issueAsset({
+     *   amount: 1000,
+     *   controlAsset: 1 // creates new control asset with amount 1
+     * });
+     * console.log('Control Asset ID:', result.controlAssetId);
+     * console.log('Asset ID:', result.assetId);
+     *
+     * // Issue a reissuable asset with an existing control asset
+     * const result = await wallet.issueAsset({
+     *   amount: 1000,
+     *   controlAsset: 'controlAssetId'
+     * });
+     * console.log('Control Asset ID:', result.controlAssetId);
+     * console.log('Asset ID:', result.assetId);
+     * ```
+     */
+    issue(params: IssuanceParams): Promise<IssuanceResult>;
+    /**
+     * Reissue more units of an existing asset.
+     * Requires ownership of the control asset.
+     *
+     * @param params - Parameters for asset reissuance
+     * @param params.assetId - The asset ID to reissue (control asset ID is resolved via getAssetDetails)
+     * @param params.amount - Amount of additional units to issue
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.assetManager.reissue({
+     *   assetId: 'def456...',
+     *   amount: 500
+     * });
+     * ```
+     */
+    reissue(params: ReissuanceParams): Promise<string>;
+    /**
+     * Burn assets.
+     * @param params - Parameters for burning
+     * @param params.assetId - The asset ID to burn
+     * @param params.amount - Amount of units to burn
+     * @returns Promise resolving to the ark transaction ID
+     *
+     * @example
+     * ```typescript
+     * const txid = await wallet.assetManager.burn({
+     *   assetId: 'abc123...',
+     *   amount: 100
+     * });
+     * ```
+     */
+    burn(params: BurnParams): Promise<string>;
+}

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

@@ -0,0 +1,21 @@
+import { Packet } from "../asset";
+import { Asset, Recipient, VirtualCoin } from "./index";
+/**
+ * Creates an asset packet from asset inputs and receivers.
+ * Groups inputs and outputs by asset ID and creates the Packet object
+ * @param assetInputs - map input index -> assets
+ * @param receivers - array of recipients with their asset allocations
+ * @param changeReceiver - (optional) change receiver containing remaining assets
+ * @returns packet containing all asset groups
+ */
+export declare function createAssetPacket(assetInputs: Map<number, Asset[]>, receivers: Recipient[], changeReceiver?: Recipient): Packet;
+/**
+ * Selects coins that contain a specific asset.
+ * Returns coins sorted by amount (smallest first for better coin selection).
+ */
+export declare function selectCoinsWithAsset(coins: VirtualCoin[], assetId: string, requiredAmount: bigint): {
+    selected: VirtualCoin[];
+    totalAssetAmount: bigint;
+};
+export declare function computeAssetChange(inputAssets: Map<string, bigint>, outputAssets: Map<string, bigint>): Map<string, bigint>;
+export declare function selectedCoinsToAssetInputs(selectedCoins: VirtualCoin[]): Map<number, Asset[]>;

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

@@ -7,7 +7,7 @@ import { TxTree } from "../tree/txTree";
  * @example
  * ```typescript
  * // use wallet handler or create a custom one
- * const handler = wallet.createBatchHandler(intentId, inputs, musig2session);
+ * const handler = wallet.createBatchHandler(intentId, inputs, expectedRecipients, musig2session);
  *
  * const abortController = new AbortController();
  * // Get event stream from Ark provider

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

@@ -0,0 +1,24 @@
+import { ArkProvider, ExtendedVirtualCoin, Identity, Outpoint } from "..";
+import { DelegatorProvider } from "../providers/delegator";
+export interface DelegatorManager {
+    delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
+        delegated: Outpoint[];
+        failed: {
+            outpoints: Outpoint[];
+            error: unknown;
+        }[];
+    }>;
+}
+export declare class DelegatorManagerImpl implements DelegatorManager {
+    readonly delegatorProvider: DelegatorProvider;
+    readonly arkInfoProvider: Pick<ArkProvider, "getInfo">;
+    readonly identity: Identity;
+    constructor(delegatorProvider: DelegatorProvider, arkInfoProvider: Pick<ArkProvider, "getInfo">, identity: Identity);
+    delegate(vtxos: ExtendedVirtualCoin[], destination: string, delegateAt?: Date): Promise<{
+        delegated: Outpoint[];
+        failed: {
+            outpoints: Outpoint[];
+            error: unknown;
+        }[];
+    }>;
+}

package/dist/types/wallet/expo/background.d.ts

@@ -0,0 +1,66 @@
+import type { WalletRepository } from "../../repositories/walletRepository";
+import type { ContractRepository } from "../../repositories/contractRepository";
+import type { AsyncStorageTaskQueue } from "../../worker/expo/asyncStorageTaskQueue";
+import type { TaskProcessor } from "../../worker/expo/taskRunner";
+/**
+ * Wallet parameters persisted by {@link ExpoWallet.setup} and read
+ * by the background handler to reconstruct providers and `extendVtxo`
+ * without a network call.
+ */
+export interface PersistedBackgroundConfig {
+    arkServerUrl: string;
+    pubkeyHex: string;
+    serverPubKeyHex: string;
+    exitTimelockValue: string;
+    exitTimelockType: "blocks" | "seconds";
+}
+/**
+ * Options for {@link defineExpoBackgroundTask}.
+ */
+export interface DefineBackgroundTaskOptions {
+    /** AsyncStorage-backed queue (must match the one passed to ExpoWallet.setup). */
+    taskQueue: AsyncStorageTaskQueue;
+    /** Wallet repository (fresh instance is fine — connects to the same DB). */
+    walletRepository: WalletRepository;
+    /** Contract repository (fresh instance is fine — connects to the same DB). */
+    contractRepository: ContractRepository;
+    /** Processors to run. Defaults to `[contractPollProcessor]`. */
+    processors?: TaskProcessor[];
+}
+/**
+ * Define the Expo background task handler.
+ *
+ * **Must be called at module/global scope** (before React mounts).
+ * Internally calls `TaskManager.defineTask()`.
+ *
+ * @example
+ * ```ts
+ * // At the top of your app entry file
+ * import { defineExpoBackgroundTask } from "@arkade-os/sdk/wallet/expo";
+ * import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
+ * import AsyncStorage from "@react-native-async-storage/async-storage";
+ *
+ * const taskQueue = new AsyncStorageTaskQueue(AsyncStorage);
+ * defineExpoBackgroundTask("ark-background-poll", {
+ *     taskQueue,
+ *     walletRepository: new IndexedDBWalletRepository(),
+ *     contractRepository: new IndexedDBContractRepository(),
+ * });
+ * ```
+ */
+export declare function defineExpoBackgroundTask(taskName: string, options: DefineBackgroundTaskOptions): void;
+/**
+ * Activate the OS-level background task scheduler.
+ *
+ * Call this after {@link defineExpoBackgroundTask} (typically inside
+ * {@link ExpoWallet.setup} or in a React component after wallet init).
+ *
+ * @param minimumInterval - Minimum interval in minutes (default 15).
+ */
+export declare function registerExpoBackgroundTask(taskName: string, options?: {
+    minimumInterval?: number;
+}): Promise<void>;
+/**
+ * Unregister the background task from the OS scheduler.
+ */
+export declare function unregisterExpoBackgroundTask(taskName: string): Promise<void>;

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

@@ -0,0 +1,4 @@
+export { ExpoWallet } from "./wallet";
+export type { ExpoWalletConfig, ExpoBackgroundConfig } from "./wallet";
+export { defineExpoBackgroundTask, registerExpoBackgroundTask, unregisterExpoBackgroundTask, } from "./background";
+export type { DefineBackgroundTaskOptions, PersistedBackgroundConfig, } from "./background";

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

@@ -0,0 +1,97 @@
+import { Wallet } from "../wallet";
+import type { IWallet, IAssetManager, WalletBalance, WalletConfig, SendBitcoinParams, SettleParams, GetVtxosFilter, ArkTransaction, ExtendedCoin, ExtendedVirtualCoin, Recipient } from "..";
+import type { SettlementEvent } from "../../providers/ark";
+import type { Identity } from "../../identity";
+import type { IContractManager } from "../../contracts/contractManager";
+import type { TaskQueue } from "../../worker/expo/taskQueue";
+import type { TaskProcessor } from "../../worker/expo/taskRunner";
+/**
+ * Background processing configuration for {@link ExpoWallet}.
+ */
+export interface ExpoBackgroundConfig {
+    /** Identifier registered with expo-background-task. */
+    taskName: string;
+    /** Persistence layer for foreground ↔ background handoff. */
+    taskQueue: TaskQueue;
+    /** Processors to run on each tick. Defaults to `[contractPollProcessor]`. */
+    processors?: TaskProcessor[];
+    /** If set, automatically polls at this interval (ms) while the app is in the foreground. */
+    foregroundIntervalMs?: number;
+    /** If set, registers the background task with the OS at this interval (minutes, min 15). */
+    minimumBackgroundInterval?: number;
+}
+/**
+ * Configuration for {@link ExpoWallet.setup}.
+ */
+export interface ExpoWalletConfig extends WalletConfig {
+    background: ExpoBackgroundConfig;
+}
+/**
+ * Expo/React Native wallet with built-in background task processing.
+ *
+ * Wraps a standard {@link Wallet} and adds a lightweight task queue
+ * for keeping contract/VTXO state fresh while the app is active and
+ * across Expo BackgroundTask wakes.
+ *
+ * @example
+ * ```ts
+ * import { ExpoWallet } from "@arkade-os/sdk/wallet/expo";
+ * import { AsyncStorageTaskQueue } from "@arkade-os/sdk/worker/expo";
+ *
+ * const wallet = await ExpoWallet.setup({
+ *     identity: SingleKey.fromHex(privateKey),
+ *     arkServerUrl,
+ *     esploraUrl,
+ *     storage: { walletRepository, contractRepository },
+ *     background: {
+ *         taskName: "ark-background-poll",
+ *         taskQueue: new AsyncStorageTaskQueue(AsyncStorage),
+ *         foregroundIntervalMs: 20_000,
+ *         minimumBackgroundInterval: 15,
+ *     },
+ * });
+ *
+ * const balance = await wallet.getBalance();
+ * ```
+ */
+export declare class ExpoWallet implements IWallet {
+    private readonly wallet;
+    private readonly taskQueue;
+    private readonly processors;
+    private readonly deps;
+    readonly identity: Identity;
+    readonly arkProvider: Wallet["arkProvider"];
+    readonly indexerProvider: Wallet["indexerProvider"];
+    private foregroundIntervalId?;
+    private readonly taskName;
+    private constructor();
+    /**
+     * Create an ExpoWallet with background task support.
+     *
+     * 1. Creates the inner {@link Wallet} via `Wallet.create()`.
+     * 2. Wires up processors (defaults to {@link contractPollProcessor}).
+     * 3. Persists background config for the background handler (if the queue supports it).
+     * 4. Seeds the task queue with a `contract-poll` task.
+     * 5. Registers the background task with the OS scheduler (if `minimumBackgroundInterval` is set).
+     * 6. Starts foreground polling if `foregroundIntervalMs` is set.
+     */
+    static setup(config: ExpoWalletConfig): Promise<ExpoWallet>;
+    private startForegroundPolling;
+    private runForegroundPoll;
+    private seedContractPollTask;
+    /**
+     * Stop foreground polling and unregister the background task.
+     */
+    dispose(): Promise<void>;
+    getAddress(): Promise<string>;
+    getBoardingAddress(): Promise<string>;
+    getBalance(): Promise<WalletBalance>;
+    getVtxos(filter?: GetVtxosFilter): Promise<ExtendedVirtualCoin[]>;
+    getBoardingUtxos(): Promise<ExtendedCoin[]>;
+    getTransactionHistory(): Promise<ArkTransaction[]>;
+    getContractManager(): Promise<IContractManager>;
+    sendBitcoin(params: SendBitcoinParams): Promise<string>;
+    settle(params?: SettleParams, eventCallback?: (event: SettlementEvent) => void): Promise<string>;
+    send(...recipients: Recipient[]): Promise<string>;
+    get assetManager(): IAssetManager;
+}