lwk_node 0.11.1 → 0.12.1

package/lwk_wasm.d.ts

@@ -16,24 +16,40 @@ export enum Chain {
   Internal = 1,
 }
 /**
- * Wrapper of [`elements::Address`]
+ * An Elements (Liquid) address
  */
 export class Address {
   free(): void;
   /**
    * Creates an `Address`
    *
-   * If you know the network, you can use [`Address::parse()`] to validate that the network is consistent.
+   * If you know the network, you can use `parse()` to validate that the network is consistent.
    */
   constructor(s: string);
   /**
    * Parses an `Address` ensuring is for the right network
    */
   static parse(s: string, network: Network): Address;
+  /**
+   * Return the script pubkey of the address.
+   */
   scriptPubkey(): Script;
+  /**
+   * Return true if the address is blinded, in other words, if it has a blinding key.
+   */
   isBlinded(): boolean;
+  /**
+   * Return true if the address is for mainnet.
+   */
   isMainnet(): boolean;
+  /**
+   * Return the unconfidential address, in other words, the address without the blinding key.
+   */
   toUnconfidential(): Address;
+  /**
+   * Return the string representation of the address.
+   * This representation can be used to recreate the address via `new()`
+   */
   toString(): string;
   /**
    * Returns a string encoding an image in a uri
@@ -51,16 +67,43 @@ export class Address {
   QRCodeText(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::AddressResult`]
+ * Value returned from asking an address to the wallet.
+ * Containing the confidential address and its
+ * derivation index (the last element in the derivation path)
  */
 export class AddressResult {
   private constructor();
   free(): void;
+  /**
+   * Return the address.
+   */
   address(): Address;
+  /**
+   * Return the derivation index of the address.
+   */
   index(): number;
 }
 /**
- * Wrapper of [`lwk_wollet::amp0::Amp0`]
+ * Context for actions related to an AMP0 (sub)account
+ *
+ * <div class="warning">
+ * <b>WARNING:</b>
+ *
+ * AMP0 is based on a legacy system, and some things do not fit precisely the way LWK allows to do
+ * things.
+ *
+ * Callers must be careful with the following:
+ * * <b>Addresses: </b>
+ *   to get addresses use [`Amp0::address()`]. This ensures
+ *   that all addresses used are correctly monitored by the AMP0 server.
+ * * <b>Syncing: </b>
+ *   to sync the AMP0 [`crate::Wollet`], use [`Amp0::last_index()`] and [`crate::clients::blocking::BlockchainBackend::full_scan_to_index()`]. This ensures that all utxos are synced, even if there are gaps between higher than the GAP LIMIT.
+ *
+ * <i>
+ * Failing to do the above might lead to inconsistent states, where funds are not shown or they
+ * cannot be spent!
+ * </i>
+ * </div>
  */
 export class Amp0 {
   private constructor();
@@ -103,7 +146,64 @@ export class Amp0 {
   sign(amp0pset: Amp0Pset): Promise<Transaction>;
 }
 /**
- * Wrapper of [`lwk_wollet::amp0::Amp0Pset`]
+ * Session connecting to AMP0
+ */
+export class Amp0Connected {
+  free(): void;
+  /**
+   * Connect and register to AMP0
+   */
+  constructor(network: Network, signer_data: Amp0SignerData);
+  /**
+   * Obtain a login challenge
+   *
+   * This must be signed with [`amp0_sign_challenge()`].
+   */
+  getChallenge(): Promise<string>;
+  /**
+   * Log in
+   *
+   * `sig` must be obtained from [`amp0_sign_challenge()`] called with the value returned
+   * by [`Amp0Connected::get_challenge()`]
+   */
+  login(sig: string): Promise<Amp0LoggedIn>;
+}
+/**
+ * Session logged in AMP0
+ */
+export class Amp0LoggedIn {
+  private constructor();
+  free(): void;
+  /**
+   * List of AMP IDs.
+   */
+  getAmpIds(): string[];
+  /**
+   * Get the next account for AMP0 account creation
+   *
+   * This must be given to [`amp0_account_xpub()`] to obtain the xpub to pass to
+   * [`Amp0LoggedIn::create_amp0_account()`]
+   */
+  nextAccount(): number;
+  /**
+   * Create a new AMP0 account
+   *
+   * `account_xpub` must be obtained from [`amp0_account_xpub()`] called with the value obtained from
+   * [`Amp0LoggedIn::next_account()`]
+   */
+  createAmp0Account(pointer: number, account_xpub: string): Promise<string>;
+  /**
+   * Create a new Watch-Only entry for this wallet
+   */
+  createWatchOnly(username: string, password: string): Promise<void>;
+}
+/**
+ * A PSET to use with AMP0
+ *
+ * When asking AMP0 to cosign, the caller must pass some extra data that does not belong to the
+ * PSET. This struct holds and manage the necessary data.
+ *
+ * If you're not dealing with AMP0, do not use this struct.
  */
 export class Amp0Pset {
   free(): void;
@@ -120,28 +220,50 @@ export class Amp0Pset {
    */
   blindingNonces(): string[];
 }
+export class Amp0SignerData {
+  private constructor();
+  free(): void;
+}
 /**
- * Wrapper of [`lwk_wollet::amp2::Amp2`]
+ * Context for actions interacting with Asset Management Platform version 2
  */
 export class Amp2 {
   private constructor();
   free(): void;
+  /**
+   * Create a new AMP2 client with the default url and server key for the testnet network.
+   */
   static newTestnet(): Amp2;
+  /**
+   * Get an AMP2 wallet descriptor from the keyorigin xpub string obtained from a signer
+   */
   descriptorFromStr(keyorigin_xpub: string): Amp2Descriptor;
+  /**
+   * Register an AMP2 wallet with the AMP2 server
+   */
   register(desc: Amp2Descriptor): Promise<string>;
+  /**
+   * Ask the AMP2 server to cosign a PSET
+   */
   cosign(pset: Pset): Promise<Pset>;
 }
 /**
- * Wrapper of [`lwk_wollet::amp2::Amp2Descriptor`]
+ * An Asset Management Platform version 2 descriptor
  */
 export class Amp2Descriptor {
   private constructor();
   free(): void;
+  /**
+   * Return the descriptor as a `WolletDescriptor`
+   */
   descriptor(): WolletDescriptor;
+  /**
+   * Return the string representation of the descriptor.
+   */
   toString(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::AssetAmount`]
+ * An asset identifier and an amount in satoshi units
  */
 export class AssetAmount {
   private constructor();
@@ -150,7 +272,7 @@ export class AssetAmount {
   asset(): AssetId;
 }
 /**
- * A valid asset identifier. wrapper of [`elements::AssetId`]
+ * A valid asset identifier.
  *
  * 32 bytes encoded as hex string.
  */
@@ -160,25 +282,69 @@ export class AssetId {
    * Creates an `AssetId`
    */
   constructor(asset_id: string);
+  /**
+   * Return the string representation of the asset identifier (64 hex characters).
+   * This representation can be used to recreate the asset identifier via `new()`
+   */
   toString(): string;
 }
 /**
- * A collection of asset identifiers. wrapper of [`Vec<elements::AssetId>`]
+ * An ordered collection of asset identifiers.
  */
 export class AssetIds {
   private constructor();
   free(): void;
+  /**
+   * Return an empty list of asset identifiers.
+   */
   static empty(): AssetIds;
+  /**
+   * Return the string representation of this list of asset identifiers.
+   */
   toString(): string;
 }
+/**
+ * Data related to an asset in the registry:
+ * - contract: the contract of the asset
+ * - tx: the issuance transaction of the asset
+ */
 export class AssetMeta {
   private constructor();
   free(): void;
+  /**
+   * Return the contract of the asset.
+   */
   contract(): Contract;
+  /**
+   * Return the issuance transaction of the asset.
+   */
   tx(): Transaction;
 }
 /**
- * wrapper over [`lwk_common::Bip`]
+ * A signed balance of assets, to represent a balance with negative values such
+ * as the results of a transaction from the perspective of a wallet.
+ */
+export class Balance {
+  private constructor();
+  free(): void;
+  /**
+   * Convert the balance to a JsValue for serialization
+   *
+   * Note: the amounts are strings since `JSON.stringify` cannot handle `BigInt`s.
+   * Use `entries()` to get the raw data.
+   */
+  toJSON(): any;
+  /**
+   * Returns the balance as an array of [key, value] pairs.
+   */
+  entries(): any;
+  /**
+   * Return the string representation of the balance.
+   */
+  toString(): string;
+}
+/**
+ * The bip variant for a descriptor like specified in the bips (49, 84, 87)
  */
 export class Bip {
   private constructor();
@@ -195,10 +361,13 @@ export class Bip {
    * Creates a bip87 variant
    */
   static bip87(): Bip;
+  /**
+   * Return the string representation of the bip variant, such as "bip49", "bip84" or "bip87"
+   */
   toString(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::Contract`]
+ * A contract defining metadata of an asset such the name and the ticker
  */
 export class Contract {
   free(): void;
@@ -206,43 +375,110 @@ export class Contract {
    * Creates a `Contract`
    */
   constructor(domain: string, issuer_pubkey: string, name: string, precision: number, ticker: string, version: number);
+  /**
+   * Return the string representation of the contract.
+   */
   toString(): string;
+  /**
+   * Return the domain of the issuer of the contract.
+   */
   domain(): string;
+  /**
+   * Make a copy of the contract.
+   *
+   * This is needed to pass it to a function that requires a `Contract` (without borrowing)
+   * but you need the same contract after that call.
+   */
   clone(): Contract;
 }
 /**
- * Wrapper of [`asyncr::EsploraClient`]
+ * A blockchain backend implementation based on the
+ * [esplora HTTP API](https://github.com/blockstream/esplora/blob/master/API.md).
+ * But can also use the [waterfalls](https://github.com/RCasatta/waterfalls)
+ * endpoint to speed up the scan if supported by the server.
  */
 export class EsploraClient {
   free(): void;
   /**
-   * Creates a client, wrapper of [`asyncr::EsploraClient`]
+   * Creates an Esplora client with the given options
    */
   constructor(network: Network, url: string, waterfalls: boolean, concurrency: number, utxo_only: boolean);
+  /**
+   * Scan the blockchain for the scripts generated by a watch-only wallet
+   *
+   * This method scans both external and internal address chains, stopping after finding
+   * 20 consecutive unused addresses (the gap limit) as recommended by
+   * [BIP44](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki#address-gap-limit).
+   *
+   * Returns `Some(Update)` if any changes were found during scanning, or `None` if no changes
+   * were detected.
+   *
+   * To scan beyond the gap limit use `full_scan_to_index()` instead.
+   */
   fullScan(wollet: Wollet): Promise<Update | undefined>;
   /**
    * Scan the blockchain for the scripts generated by a watch-only wallet up to a specified derivation index
+   *
+   * While `full_scan()` stops after finding 20 consecutive unused addresses (the gap limit),
+   * this method will scan at least up to the given derivation index. This is useful to prevent
+   * missing funds in cases where outputs exist beyond the gap limit.
+   *
+   * Will scan both external and internal address chains up to the given index for maximum safety,
+   * even though internal addresses may not need such deep scanning.
+   *
+   * If transactions are found beyond the gap limit during this scan, subsequent calls to
+   * `full_scan()` will automatically scan up to the highest used index, preventing any
+   * previously-found transactions from being missed.
+   *
+   * See `full_scan_to_index()` for a blocking version of this method.
    */
   fullScanToIndex(wollet: Wollet, index: number): Promise<Update | undefined>;
+  /**
+   * Broadcast a transaction to the network so that a miner can include it in a block.
+   */
   broadcastTx(tx: Transaction): Promise<Txid>;
+  /**
+   * Broadcast a PSET by extracting the transaction from the PSET and broadcasting it.
+   */
   broadcast(pset: Pset): Promise<Txid>;
+  /**
+   * Set the waterfalls server recipient key. This is used to encrypt the descriptor when calling the waterfalls endpoint.
+   */
   setWaterfallsServerRecipient(recipient: string): Promise<void>;
 }
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::Issuance`]
+ * The details of an issuance or reissuance.
  */
 export class Issuance {
   private constructor();
   free(): void;
+  /**
+   * Return the asset id or None if it's a null issuance
+   */
   asset(): AssetId | undefined;
+  /**
+   * Return the token id or None if it's a null issuance
+   */
   token(): AssetId | undefined;
+  /**
+   * Return the previous output index or None if it's a null issuance
+   */
   prevVout(): number | undefined;
+  /**
+   * Return the previous transaction id or None if it's a null issuance
+   */
   prevTxid(): Txid | undefined;
+  /**
+   * Return true if this is effectively an issuance
+   */
   isIssuance(): boolean;
+  /**
+   * Return true if this is effectively a reissuance
+   */
   isReissuance(): boolean;
 }
 /**
- * Wrapper of [`asyncr::Jade`]
+ * A Jade hardware wallet usable via Web Serial
  */
 export class Jade {
   free(): void;
@@ -280,7 +516,7 @@ export class Jade {
   registerDescriptor(name: string, desc: WolletDescriptor): Promise<boolean>;
 }
 /**
- * WebSocket-based Wrapper of [`asyncr::Jade`]
+ * WebSocket-based `Jade` useful for testing in the browser with the Jade emulator.
  */
 export class JadeWebSocket {
   free(): void;
@@ -340,7 +576,9 @@ export class LedgerWeb {
   getReceiveAddressSingle(index: number): Promise<string>;
 }
 /**
- * Wrapper of [`bip39::Mnemonic`]
+ * A mnemonic secret code used as a master secret for a bip39 wallet.
+ *
+ * Supported number of words are 12, 15, 18, 21, and 24.
  */
 export class Mnemonic {
   free(): void;
@@ -348,6 +586,12 @@ export class Mnemonic {
    * Creates a Mnemonic
    */
   constructor(s: string);
+  /**
+   * Return the string representation of the Mnemonic.
+   * This representation can be used to recreate the Mnemonic via `new()`
+   *
+   * Note this is secret information, do not log it.
+   */
   toString(): string;
   /**
    * Creates a Mnemonic from entropy, at least 16 bytes are needed.
@@ -359,7 +603,7 @@ export class Mnemonic {
   static fromRandom(word_count: number): Mnemonic;
 }
 /**
- * Wrapper of [`lwk_wollet::ElementsNetwork`]
+ * The network of the elements blockchain such as mainnet, testnet or regtest.
  */
 export class Network {
   private constructor();
@@ -380,13 +624,37 @@ export class Network {
    * Creates the default regtest `Network` with the policy asset `5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225`
    */
   static regtestDefault(): Network;
+  /**
+   * Return the default esplora client for this network
+   */
   defaultEsploraClient(): EsploraClient;
+  /**
+   * Return true if the network is a mainnet network
+   */
   isMainnet(): boolean;
+  /**
+   * Return true if the network is a testnet network
+   */
   isTestnet(): boolean;
+  /**
+   * Return true if the network is a regtest network
+   */
   isRegtest(): boolean;
+  /**
+   * Return a string representation of the network, like "liquid", "liquid-testnet" or "liquid-regtest"
+   */
   toString(): string;
+  /**
+   * Return the policy asset for this network
+   */
   policyAsset(): AssetId;
+  /**
+   * Return the transaction builder for this network
+   */
   txBuilder(): TxBuilder;
+  /**
+   * Return the default explorer URL for this network
+   */
   defaultExplorerUrl(): string;
 }
 /**
@@ -396,10 +664,13 @@ export class Network {
 export class OptionWalletTxOut {
   private constructor();
   free(): void;
+  /**
+   * Return a copy of the WalletTxOut if it exists, otherwise None
+   */
   get(): WalletTxOut | undefined;
 }
 /**
- * Wrapper of [`elements::OutPoint`]
+ * A reference to a transaction output
  */
 export class OutPoint {
   free(): void;
@@ -407,38 +678,78 @@ export class OutPoint {
    * Creates an `OutPoint`
    */
   constructor(s: string);
+  /**
+   * Return the transaction identifier.
+   */
   txid(): Txid;
+  /**
+   * Return the output index.
+   */
   vout(): number;
 }
 /**
- * Wrapper of [`lwk_common::precision::Precision`]
+ * Helper to convert satoshi values of an asset to the value with the given precision and viceversa.
+ *
+ * For example 100 satoshi with precision 2 is "1.00"
  */
 export class Precision {
   free(): void;
   /**
-   * Creates a Precision
+   * Create a new Precision, useful to encode e decode values for assets with precision.
+   * erroring if the given precision is greater than the allowed maximum (8)
    */
   constructor(precision: number);
+  /**
+   * Convert the given satoshi value to the formatted value according to our precision
+   *
+   * For example 100 satoshi with precision 2 is "1.00"
+   */
   satsToString(sats: bigint): string;
+  /**
+   * Convert the given string with precision to satoshi units.
+   *
+   * For example the string "1.00" of an asset with precision 2 is 100 satoshi.
+   */
   stringToSats(sats: string): bigint;
 }
 /**
- * Partially Signed Elements Transaction, wrapper of [`PartiallySignedTransaction`]
+ * Partially Signed Elements Transaction
  */
 export class Pset {
   free(): void;
   /**
-   * Creates a `Pset`
+   * Creates a `Pset` from its base64 string representation.
    */
   constructor(base64: string);
+  /**
+   * Return a base64 string representation of the Pset.
+   * The string can be used to re-create the Pset via `new()`
+   */
   toString(): string;
+  /**
+   * Extract the Transaction from a Pset by filling in
+   * the available signature information in place.
+   */
   extractTx(): Transaction;
+  /**
+   * Attempt to merge with another `Pset`.
+   */
   combine(other: Pset): void;
+  /**
+   * Return a copy of the inputs of this PSET
+   */
   inputs(): PsetInput[];
+  /**
+   * Return a copy of the outputs of this PSET
+   */
   outputs(): PsetOutput[];
 }
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetBalance`]
+ * The details regarding balance and amounts in a PSET:
+ *
+ * - The fee of the transaction in the PSET
+ * - The net balance of the assets in the PSET from the point of view of the wallet
+ * - The outputs going out of the wallet
  */
 export class PsetBalance {
   private constructor();
@@ -447,21 +758,35 @@ export class PsetBalance {
   /**
    * The net balance for every asset with respect of the wallet asking the pset details
    */
-  balances(): any;
+  balances(): Balance;
   recipients(): Recipient[];
 }
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetDetails`]
+ * The details of a Partially Signed Elements Transaction:
+ *
+ * - the net balance from the point of view of the wallet
+ * - the available and missing signatures for each input
+ * - for issuances and reissuances transactions contains the issuance or reissuance details
  */
 export class PsetDetails {
   private constructor();
   free(): void;
+  /**
+   * Return the balance of the PSET from the point of view of the wallet
+   * that generated this via `psetDetails()`
+   */
   balance(): PsetBalance;
   /**
    * For each input existing or missing signatures
    */
   signatures(): PsetSignatures[];
+  /**
+   * Set of fingerprints for which the PSET is missing a signature
+   */
   fingerprintsMissing(): string[];
+  /**
+   * List of fingerprints for which the PSET has a signature
+   */
   fingerprintsHas(): string[];
   /**
    * Return an element for every input that could possibly be a issuance or a reissuance
@@ -500,7 +825,7 @@ export class PsetOutput {
   scriptPubkey(): Script;
 }
 /**
- * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetSignatures`]
+ * The details of the signatures in a PSET, divided in available and missing signatures.
  */
 export class PsetSignatures {
   private constructor();
@@ -522,16 +847,53 @@ export class Recipient {
   address(): Address | undefined;
   vout(): number;
 }
+/**
+ * A Registry, a repository to store and retrieve asset metadata, like the name or the ticker of an asset.
+ */
 export class Registry {
   private constructor();
   free(): void;
+  /**
+   * Create a new registry cache specifying the URL of the registry,
+   * fetch the assets metadata identified by the given asset ids and cache them for later local retrieval.
+   * Use `default_for_network()` to get the default registry for the given network.
+   */
   static new(url: string, asset_ids: AssetIds): Promise<Registry>;
+  /**
+   * Return the default registry for the given network,
+   * fetch the assets metadata identified by the given asset ids and cache them for later local retrieval.
+   * Use `new()` to specify a custom URL
+   */
   static defaultForNetwork(network: Network, asset_ids: AssetIds): Promise<Registry>;
+  /**
+   * Create a new registry cache, using only the hardcoded assets.
+   *
+   * Hardcoded assets are the policy assets (LBTC, tLBTC, rLBTC) and the USDT asset on mainnet.
+   */
   static defaultHardcodedForNetwork(network: Network): Registry;
+  /**
+   * Fetch the contract and the issuance transaction of the given asset id from the registry
+   */
   fetchWithTx(asset_id: AssetId, client: EsploraClient): Promise<AssetMeta>;
+  /**
+   * Post a contract to the registry for registration.
+   */
   post(data: RegistryPost): Promise<void>;
+  /**
+   * Return the asset metadata related to the given asset id if it exists in this registry.
+   */
   get(asset_id: AssetId): RegistryData | undefined;
+  /**
+   * Return the asset metadata related to the given token id,
+   * in other words `token_id` is the reissuance token of the returned asset
+   */
   getAssetOfToken(token_id: AssetId): RegistryData | undefined;
+  /**
+   * Add the contracts information of the assets used in the Pset
+   * if available in this registry.
+   * Without the contract information, the partially signed transaction
+   * is valid but will not show asset information when signed with an hardware wallet.
+   */
   addContracts(pset: Pset): Pset;
 }
 export class RegistryData {
@@ -542,29 +904,62 @@ export class RegistryData {
   name(): string;
   domain(): string;
 }
+/**
+ * The data to post to the registry to publish a contract for an asset id
+ */
 export class RegistryPost {
   free(): void;
+  /**
+   * Create a new registry post object to be used to publish a contract for an asset id in the registry.
+   */
   constructor(contract: Contract, asset_id: AssetId);
+  /**
+   * Return a string representation of the registry post (mostly for debugging).
+   */
   toString(): string;
 }
 /**
- * Wrapper of [`elements::Script`]
+ * An Elements (Liquid) script
  */
 export class Script {
   free(): void;
   /**
-   * Creates a `Script`
+   * Creates a `Script` from its hex string representation.
    */
   constructor(s: string);
+  /**
+   * Return the consensus encoded bytes of the script.
+   */
   bytes(): Uint8Array;
+  /**
+   * Return the string of the script showing op codes and their arguments.
+   *
+   * For example: "OP_DUP OP_HASH160 OP_PUSHBYTES_20 088ac47276d105b91cf9aa27a00112421dd5f23c OP_EQUALVERIFY OP_CHECKSIG"
+   */
   asm(): string;
+  /**
+   * Return the string representation of the script (hex encoding of its consensus encoded bytes).
+   * This representation can be used to recreate the script via `new()`
+   */
   toString(): string;
 }
 /**
- * A Software signer, wrapper of [`lwk_signer::SwSigner`]
+ * A Software signer.
  */
 export class Signer {
   free(): void;
+  /**
+   * AMP0 signer data for login
+   */
+  amp0SignerData(): Amp0SignerData;
+  /**
+   * AMP0 sign login challenge
+   */
+  amp0SignChallenge(challenge: string): string;
+  /**
+   * AMP0 account xpub
+   */
+  amp0AccountXpub(account: number): string;
   /**
    * Creates a `Signer`
    */
@@ -577,9 +972,25 @@ export class Signer {
    * Sign a message with the master key, return the signature as a base64 string
    */
   signMessage(message: string): string;
+  /**
+   * Return the witness public key hash, slip77 descriptor of this signer
+   */
   wpkhSlip77Descriptor(): WolletDescriptor;
+  /**
+   * Return the extended public key of the signer
+   */
   getMasterXpub(): Xpub;
+  /**
+   * Return keyorigin and xpub, like "[73c5da0a/84h/1h/0h]tpub..."
+   */
   keyoriginXpub(bip: Bip): string;
+  /**
+   * Return the signer fingerprint
+   */
+  fingerprint(): string;
+  /**
+   * Return the mnemonic of the signer
+   */
   mnemonic(): Mnemonic;
 }
 export class Singlesig {
@@ -588,7 +999,7 @@ export class Singlesig {
   static from(variant: string): Singlesig;
 }
 /**
- * Wrapper of [`lwk_wollet::Tip`]
+ * Blockchain tip, the highest valid block in the blockchain
  */
 export class Tip {
   private constructor();
@@ -598,9 +1009,9 @@ export class Tip {
   timestamp(): number | undefined;
 }
 /**
- * A Liquid transaction, wrapper of [`elements::Transaction`]
+ * A Liquid transaction
  *
- * See [`crate::WalletTx`] for the transaction as seen from the perspective of the wallet
+ * See `WalletTx` for the transaction as seen from the perspective of the wallet
  * where you can actually see unblinded amounts and tx net-balance.
  */
 export class Transaction {
@@ -609,13 +1020,26 @@ export class Transaction {
    * Creates a `Transaction`
    */
   constructor(tx_hex: string);
+  /**
+   * Return the transaction identifier.
+   */
   txid(): Txid;
+  /**
+   * Return the consensus encoded bytes of the transaction.
+   */
   bytes(): Uint8Array;
+  /**
+   * Return the fee of the transaction in the given asset.
+   * At the moment the only asset that can be used as fee is the policy asset (LBTC for mainnet).
+   */
   fee(policy_asset: AssetId): bigint;
+  /**
+   * Return the hex representation of the transaction. More precisely, they are the consensus encoded bytes of the transaction converted in hex.
+   */
   toString(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::TxBuilder`]
+ * A transaction builder
  */
 export class TxBuilder {
   free(): void;
@@ -664,31 +1088,87 @@ export class TxBuilder {
    */
   addExplicitRecipient(address: Address, satoshi: bigint, asset: AssetId): TxBuilder;
   /**
-   * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
+   * Issue an asset
+   *
+   * There will be `asset_sats` units of this asset that will be received by
+   * `asset_receiver` if it's set, otherwise to an address of the wallet generating the issuance.
+   *
+   * There will be `token_sats` reissuance tokens that allow token holder to reissue the created
+   * asset. Reissuance token will be received by `token_receiver` if it's some, or to an
+   * address of the wallet generating the issuance if none.
+   *
+   * If a `contract` is provided, it's metadata will be committed in the generated asset id.
+   *
+   * Can't be used if `reissue_asset` has been called
    */
   issueAsset(asset_sats: bigint, asset_receiver: Address | null | undefined, token_sats: bigint, token_receiver?: Address | null, contract?: Contract | null): TxBuilder;
   /**
-   * Reissue an asset, wrapper of [`lwk_wollet::TxBuilder::reissue_asset()`]
+   * Reissue an asset
+   *
+   * reissue the asset defined by `asset_to_reissue`, provided the reissuance token is owned
+   * by the wallet generating te reissuance.
+   *
+   * Generated transaction will create `satoshi_to_reissue` new asset units, and they will be
+   * sent to the provided `asset_receiver` address if some, or to an address from the wallet
+   * generating the reissuance transaction if none.
+   *
+   * If the issuance transaction does not involve this wallet,
+   * pass the issuance transaction in `issuance_tx`.
    */
   reissueAsset(asset_to_reissue: AssetId, satoshi_to_reissue: bigint, asset_receiver?: Address | null, issuance_tx?: Transaction | null): TxBuilder;
   /**
-   * Manual coin selection, wrapper of [`lwk_wollet::TxBuilder::set_wallet_utxos()`]
+   * Switch to manual coin selection by giving a list of internal UTXOs to use.
+   *
+   * All passed UTXOs are added to the transaction.
+   * No other wallet UTXO is added to the transaction, caller is supposed to add enough UTXOs to
+   * cover for all recipients and fees.
+   *
+   * This method never fails, any error will be raised in [`TxBuilder::finish`].
+   *
+   * Possible errors:
+   * * OutPoint doesn't belong to the wallet
+   * * Insufficient funds (remember to include L-BTC utxos for fees)
    */
   setWalletUtxos(outpoints: OutPoint[]): TxBuilder;
+  /**
+   * Return a string representation of the transaction builder (mostly for debugging)
+   */
   toString(): string;
+  /**
+   * Set data to create a PSET from which you
+   * can create a LiquiDEX proposal
+   */
   liquidexMake(utxo: OutPoint, address: Address, satoshi: bigint, asset_id: AssetId): TxBuilder;
+  /**
+   * Set data to take LiquiDEX proposals
+   */
   liquidexTake(proposals: ValidatedLiquidexProposal[]): TxBuilder;
 }
 /**
- * Wrapper of [`elements::TxOutSecrets`]
+ * Contains unblinded information such as the asset and the value of a transaction output
  */
 export class TxOutSecrets {
   private constructor();
   free(): void;
+  /**
+   * Return the asset of the output.
+   */
   asset(): AssetId;
+  /**
+   * Return the asset blinding factor as a hex string.
+   */
   assetBlindingFactor(): string;
+  /**
+   * Return the value of the output.
+   */
   value(): bigint;
+  /**
+   * Return the value blinding factor as a hex string.
+   */
   valueBlindingFactor(): string;
+  /**
+   * Return true if the output is explicit (no blinding factors).
+   */
   isExplicit(): boolean;
   /**
    * Get the asset commitment
@@ -711,13 +1191,26 @@ export class TxOutSecrets {
 export class Txid {
   free(): void;
   /**
-   * Creates a `Txid`
+   * Creates a `Txid` from its hex string representation (64 characters).
    */
   constructor(tx_id: string);
+  /**
+   * Return the string representation of the transaction identifier as shown in the explorer.
+   * This representation can be used to recreate the transaction identifier via `new()`
+   */
   toString(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::LiquidexProposal<Unvalidated>`]
+ * LiquiDEX swap proposal
+ *
+ * A LiquiDEX swap proposal is a transaction with one input and one output created by the "maker".
+ * The transaction "swaps" the input for the output, meaning that the "maker" sends the input and
+ * receives the output.
+ * However the transaction is incomplete (unbalanced and without a fee output), thus it cannot be
+ * broadcast.
+ * The "taker" can "complete" the transaction (using [`crate::TxBuilder::liquidex_take()`]) by
+ * adding more inputs and more outputs to balance the amounts, meaning that the "taker" sends the
+ * output and receives the input.
  */
 export class UnvalidatedLiquidexProposal {
   private constructor();
@@ -729,7 +1222,8 @@ export class UnvalidatedLiquidexProposal {
   toString(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::Update`]
+ * An Update contains the delta of information to be applied to the wallet to reach the latest status.
+ * It's created passing a reference to the wallet to the blockchain client
  */
 export class Update {
   free(): void;
@@ -737,14 +1231,33 @@ export class Update {
    * Creates an `Update`
    */
   constructor(bytes: Uint8Array);
+  /**
+   * Serialize an update to a byte array
+   */
   serialize(): Uint8Array;
+  /**
+   * Serialize an update to a base64 encoded string,
+   * encrypted with a key derived from the descriptor.
+   * Decrypt using `deserialize_decrypted_base64()`
+   */
   serializeEncryptedBase64(desc: WolletDescriptor): string;
+  /**
+   * Deserialize an update from a base64 encoded string,
+   * decrypted with a key derived from the descriptor.
+   * Create the base64 using `serialize_encrypted_base64()`
+   */
   static deserializeDecryptedBase64(base64: string, desc: WolletDescriptor): Update;
+  /**
+   * Whether this update only changes the tip
+   */
   onlyTip(): boolean;
+  /**
+   * Prune the update, removing unneeded data from transactions.
+   */
   prune(wollet: Wollet): void;
 }
 /**
- * Wrapper of [`lwk_wollet::LiquidexProposal<Validated>`]
+ * Created by validating `UnvalidatedLiquidexProposal` via `validate()` or `insecure_validate()`
  */
 export class ValidatedLiquidexProposal {
   private constructor();
@@ -754,38 +1267,96 @@ export class ValidatedLiquidexProposal {
   toString(): string;
 }
 /**
- * Wrapper of [`lwk_wollet::WalletTx`]
+ * Value returned by asking transactions to the wallet. Contains details about a transaction
+ * from the perspective of the wallet, for example the net-balance of the transaction for the
+ * wallet.
  */
 export class WalletTx {
   private constructor();
   free(): void;
+  /**
+   * Return a copy of the transaction.
+   */
   tx(): Transaction;
+  /**
+   * Return the height of the block containing the transaction if it's confirmed.
+   */
   height(): number | undefined;
-  balance(): any;
+  /**
+   * Return the net balance of the transaction for the wallet.
+   */
+  balance(): Balance;
+  /**
+   * Return the transaction identifier.
+   */
   txid(): Txid;
+  /**
+   * Return the fee of the transaction.
+   */
   fee(): bigint;
+  /**
+   * Return the type of the transaction. Can be "issuance", "reissuance", "burn", "redeposit", "incoming", "outgoing" or "unknown".
+   */
   txType(): string;
+  /**
+   * Return the timestamp of the block containing the transaction if it's confirmed.
+   */
   timestamp(): number | undefined;
+  /**
+   * Return a list with the same number of elements as the inputs of the transaction.
+   * The element in the list is a `WalletTxOut` (the output spent to create the input)
+   * if it belongs to the wallet, while it is None for inputs owned by others
+   */
   inputs(): OptionWalletTxOut[];
+  /**
+   * Return a list with the same number of elements as the outputs of the transaction.
+   * The element in the list is a `WalletTxOut` if it belongs to the wallet,
+   * while it is None for inputs owned by others
+   */
   outputs(): OptionWalletTxOut[];
+  /**
+   * Return the URL to the transaction on the given explorer including the information
+   * needed to unblind the transaction in the explorer UI.
+   */
   unblindedUrl(explorer_url: string): string;
 }
 /**
- * Wrapper of [`lwk_wollet::WalletTxOut`]
+ * Details of a wallet transaction output used in `WalletTx`
  */
 export class WalletTxOut {
   private constructor();
   free(): void;
+  /**
+   * Return the outpoint (txid and vout) of this `WalletTxOut`.
+   */
   outpoint(): OutPoint;
+  /**
+   * Return the script pubkey of the address of this `WalletTxOut`.
+   */
   scriptPubkey(): Script;
+  /**
+   * Return the height of the block containing this output if it's confirmed.
+   */
   height(): number | undefined;
+  /**
+   * Return the unblinded values of this `WalletTxOut`.
+   */
   unblinded(): TxOutSecrets;
+  /**
+   * Return the wildcard index used to derive the address of this `WalletTxOut`.
+   */
   wildcardIndex(): number;
+  /**
+   * Return the chain of this `WalletTxOut`. Can be "Chain::External" or "Chain::Internal" (change).
+   */
   extInt(): Chain;
+  /**
+   * Return the address of this `WalletTxOut`.
+   */
   address(): Address;
 }
 /**
- * Wrapper of [`lwk_wollet::Wollet`]
+ * A watch-only wallet defined by a CT descriptor.
  */
 export class Wollet {
   free(): void;
@@ -800,11 +1371,59 @@ export class Wollet {
    * otherwise the last unused address.
    */
   address(index?: number | null): AddressResult;
+  /**
+   * Get the full derivation path for an address
+   *
+   * Note: will be removed once we add the full path to lwk_wollet::AddressResult
+   */
   addressFullPath(index: number): Uint32Array;
+  /**
+   * Apply an update containing blockchain data
+   *
+   * To update the wallet you need to first obtain the blockchain data relevant for the wallet.
+   * This can be done using a `full_scan()`, which
+   * returns an `Update` that contains new transaction and other data relevant for the
+   * wallet.
+   * The update must then be applied to the `Wollet` so that wollet methods such as
+   * `balance()` or `transactions()` include the new data.
+   *
+   * However getting blockchain data involves network calls, so between the full scan start and
+   * when the update is applied it might elapse a significant amount of time.
+   * In that interval, applying any update, or any transaction using `apply_transaction()`,
+   * will cause this function to return a `Error::UpdateOnDifferentStatus`.
+   * Callers should either avoid applying updates and transactions, or they can catch the error
+   * and wait for a new full scan to be completed and applied.
+   */
   applyUpdate(update: Update): void;
-  applyTransaction(tx: Transaction): void;
-  balance(): any;
+  /**
+   * Apply a transaction to the wallet state
+   *
+   * Wallet transactions are normally obtained using a `full_scan()`
+   * and applying the result with `apply_update()`. However a
+   * full scan involves network calls and it can take a significant amount of time.
+   *
+   * If the caller does not want to wait for a full scan containing the transaction, it can
+   * apply the transaction to the wallet state using this function.
+   *
+   * Note: if this transaction is *not* returned by a next full scan, after `apply_update()` it will disappear from the
+   * transactions list, will not be included in balance computations, and by the remaining
+   * wollet methods.
+   *
+   * Calling this method, might cause `apply_update()` to fail with a
+   * `Error::UpdateOnDifferentStatus`, make sure to either avoid it or handle the error properly.
+   */
+  applyTransaction(tx: Transaction): Balance;
+  /**
+   * Get the wallet balance for each assets
+   */
+  balance(): Balance;
+  /**
+   * Get the asset identifiers owned by the wallet
+   */
   assetsOwned(): AssetIds;
+  /**
+   * Get the wallet transactions
+   */
   transactions(): WalletTx[];
   /**
    * Get the unspent transaction outputs of the wallet
@@ -818,12 +1437,29 @@ export class Wollet {
    * Finalize and consume the given PSET, returning the finalized one
    */
   finalize(pset: Pset): Pset;
+  /**
+   * Get the PSET details with respect to the wallet
+   */
   psetDetails(pset: Pset): PsetDetails;
+  /**
+   * Get a copy of the wallet descriptor of this wallet.
+   */
   descriptor(): WolletDescriptor;
+  /**
+   * A deterministic value derived from the descriptor, the config and the content of this wollet,
+   * including what's in the wallet store (transactions etc)
+   *
+   * In this case, we don't need cryptographic assurance guaranteed by the std default hasher (siphash)
+   * And we can use a much faster hasher, which is used also in the rust compiler.
+   * ([source](https://nnethercote.github.io/2021/12/08/a-brutally-effective-hash-function-in-rust.html))
+   */
   status(): bigint;
+  /**
+   * Get the blockchain tip at the time of the last update of this wollet.
+   */
   tip(): Tip;
   /**
-   * wraps [lwk_wollet::Wollet::never_scanned()]
+   * Returns true if this wollet has never received an updated applyed to it
    */
   neverScanned(): boolean;
   /**
@@ -832,7 +1468,7 @@ export class Wollet {
   isAmp0(): boolean;
 }
 /**
- * Wrapper of [`lwk_wollet::WolletDescriptor`]
+ * A wrapper that contains only the subset of CT descriptors handled by wollet
  */
 export class WolletDescriptor {
   free(): void;
@@ -840,8 +1476,20 @@ export class WolletDescriptor {
    * Creates a `WolletDescriptor`
    */
   constructor(descriptor: string);
+  /**
+   * Return the string representation of the descriptor, including the checksum.
+   * This representation can be used to recreate the descriptor via `new()`
+   */
   toString(): string;
+  /**
+   * Create a new multisig descriptor, where each participant is a keyorigin_xpub and it requires at least threshold signatures to spend.
+   * Errors if the threshold is 0 or greater than the number of participants.
+   * Uses slip77 for the blinding key.
+   */
   static newMultiWshSlip77(threshold: number, participants: string[]): WolletDescriptor;
+  /**
+   * Whether the descriptor is for mainnet
+   */
   isMainnet(): boolean;
   /**
    * Whether the descriptor is AMP0
@@ -849,19 +1497,32 @@ export class WolletDescriptor {
   isAmp0(): boolean;
 }
 /**
- * Wrapper of [`bip32::Xpub`]
+ * An extended public key
  */
 export class Xpub {
   free(): void;
   /**
-   * Creates a Mnemonic
+   * Creates a Xpub
    */
   constructor(s: string);
+  /**
+   * Return the string representation of the Xpub.
+   * This representation can be used to recreate the Xpub via `new()`
+   */
   toString(): string;
+  /**
+   * Return the identifier of the Xpub.
+   * This is a 40 hex characters string (20 bytes).
+   */
   identifier(): string;
+  /**
+   * Return the first four bytes of the identifier as hex string
+   * This is a 8 hex characters string (4 bytes).
+   */
   fingerprint(): string;
   /**
-   * Returns true if the passed string is a valid xpub with a valid keyorigin if present
+   * Returns true if the passed string is a valid xpub with a valid keyorigin if present.
+   * For example: "[73c5da0a/84h/1h/0h]tpub..."
    */
   static isValidWithKeyOrigin(s: string): boolean;
 }