lwk_node 0.8.5

package/README.md

@@ -0,0 +1,92 @@
+
+# Liquid Wallet Kit for WASM
+
+This is only a proof of concept at the moment but we want to show our commitment to have the 
+Liquid Wallet Kit working in the WASM environment.
+
+[Available](https://www.npmjs.com/package/lwk_wasm) as npm package.
+
+For an example usage see the [Liquid Web Wallet](https://liquidwebwallet.org/) ([source](https://github.com/RCasatta/liquid-web-wallet)). Works as CT descriptor watch-only wallet or connected to a Jade.
+
+
+## For LWK Library developers
+
+To build the WASM library you need [rust](https://www.rust-lang.org/learn/get-started) and
+[wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) installed
+
+```shell
+$ wasm-pack build --dev
+```
+
+To enable web-serial:
+
+```shell
+$ RUSTFLAGS="--cfg=web_sys_unstable_apis" wasm-pack build --dev --features serial
+```
+
+## For LWK library consumers (front-end developers)
+
+Download the Liquid Web Wallet source
+
+```shell
+$ git clone https://github.com/RCasatta/liquid-web-wallet
+$ npm install
+$ npm run start
+```
+
+Open the browser at `http://localhost:8080`
+
+### Test
+
+```shell
+$ cd lwk_wasm
+$ wasm-pack test --firefox # or --chrome
+```
+
+Then open the browser at http://127.0.0.1:8000, open also the dev tools to see console messages and
+network requests.
+
+To avoid requiring opening the browser the headless mode is possible.
+
+Note the increased timeout specified via the env var, the 20s default one could be too low.
+
+```shell
+$ cd lwk_wasm
+$ WASM_BINDGEN_TEST_TIMEOUT=60 wasm-pack test --firefox --headless
+```
+
+run specific test (note the double `--`)
+
+```shell
+$ wasm-pack test --firefox --headless -- -- balance_test_testnet
+```
+
+### Build NPM Package for release
+
+Build rust crates in release mode, optimizing for space.
+
+```shell
+$ cd lwk_wasm/
+$ RUSTFLAGS="--cfg=web_sys_unstable_apis" CARGO_PROFILE_RELEASE_OPT_LEVEL=z wasm-pack build --features serial
+```
+
+```shell
+$ cd pkg
+$ npm publish
+```
+
+### Build wasm lib for profiling
+
+To analyze the generated wasm file to optimize for size, we want to follow the same optimization
+as release but we want to keep debug info to analyze the produced lib with function names.
+
+```shell
+$ cd lwk_wasm/
+$ RUSTFLAGS="--cfg=web_sys_unstable_apis" CARGO_PROFILE_RELEASE_OPT_LEVEL=z CARGO_PROFILE_RELEASE_DEBUG=2 wasm-pack build --profiling --features serial
+```
+
+With [twiggy](https://github.com/rustwasm/twiggy) is then possible to analyze the library:
+
+```shell
+twiggy top -n 10 pkg/lwk_wasm_bg.wasm
+```

package/lwk_wasm.d.ts

@@ -0,0 +1,606 @@
+/* tslint:disable */
+/* eslint-disable */
+export function search_ledger_device(): Promise<HIDDevice>;
+/**
+ * Wallet chain
+ */
+export enum Chain {
+  /**
+   * External address, shown when asked for a payment.
+   * Wallet having a single descriptor are considered External
+   */
+  External = 0,
+  /**
+   * Internal address, used for the change
+   */
+  Internal = 1,
+}
+/**
+ * Wrapper of [`elements::Address`]
+ */
+export class Address {
+  free(): void;
+  /**
+   * Creates an `Address`
+   */
+  constructor(s: string);
+  scriptPubkey(): Script;
+  isBlinded(): boolean;
+  isMainnet(): boolean;
+  toUnconfidential(): Address;
+  toString(): string;
+  /**
+   * Returns a string encoding an image in a uri
+   *
+   * The string can be open in the browser or be used as `src` field in `img` in HTML
+   *
+   * For max efficiency we suggest to pass `None` to `pixel_per_module`, get a very small image
+   * and use styling to scale up the image in the browser. eg
+   * `style="image-rendering: pixelated; border: 20px solid white;"`
+   */
+  QRCodeUri(pixel_per_module?: number): string;
+  /**
+   * Returns a string of the QR code printable in a terminal environment
+   */
+  QRCodeText(): string;
+}
+/**
+ * Wrapper of [`lwk_wollet::AddressResult`]
+ */
+export class AddressResult {
+  private constructor();
+  free(): void;
+  address(): Address;
+  index(): number;
+}
+/**
+ * Wrapper of [`lwk_wollet::amp2::Amp2`]
+ */
+export class Amp2 {
+  private constructor();
+  free(): void;
+  static new_testnet(): Amp2;
+  descriptor_from_str(keyorigin_xpub: string): Amp2Descriptor;
+  register(desc: Amp2Descriptor): Promise<string>;
+  cosign(pset: Pset): Promise<Pset>;
+}
+/**
+ * Wrapper of [`lwk_wollet::amp2::Amp2Descriptor`]
+ */
+export class Amp2Descriptor {
+  private constructor();
+  free(): void;
+  descriptor(): WolletDescriptor;
+  toString(): string;
+}
+/**
+ * A valid asset identifier. wrapper of [`elements::AssetId`]
+ *
+ * 32 bytes encoded as hex string.
+ */
+export class AssetId {
+  free(): void;
+  /**
+   * Creates an `AssetId`
+   */
+  constructor(asset_id: string);
+  toString(): string;
+}
+/**
+ * wrapper over [`lwk_common::Bip`]
+ */
+export class Bip {
+  private constructor();
+  free(): void;
+  /**
+   * Creates a bip49 variant
+   */
+  static bip49(): Bip;
+  /**
+   * Creates a bip84 variant
+   */
+  static bip84(): Bip;
+  /**
+   * Creates a bip87 variant
+   */
+  static bip87(): Bip;
+  toString(): string;
+}
+/**
+ * Wrapper of [`lwk_wollet::Contract`]
+ */
+export class Contract {
+  free(): void;
+  /**
+   * Creates a `Contract`
+   */
+  constructor(domain: string, issuer_pubkey: string, name: string, precision: number, ticker: string, version: number);
+  toString(): string;
+}
+/**
+ * Wrapper of [`asyncr::EsploraClient`]
+ */
+export class EsploraClient {
+  free(): void;
+  /**
+   * Creates a client, wrapper of [`asyncr::EsploraClient`]
+   */
+  constructor(network: Network, url: string, waterfalls: boolean);
+  fullScan(wollet: Wollet): Promise<Update | undefined>;
+  broadcast(pset: Pset): Promise<Txid>;
+  set_waterfalls_server_recipient(recipient: string): Promise<void>;
+}
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::Issuance`]
+ */
+export class Issuance {
+  private constructor();
+  free(): void;
+  asset(): AssetId | undefined;
+  token(): AssetId | undefined;
+  prevVout(): number | undefined;
+  prevTxid(): Txid | undefined;
+  isIssuance(): boolean;
+  isReissuance(): boolean;
+}
+/**
+ * Wrapper of [`asyncr::Jade`]
+ */
+export class Jade {
+  free(): void;
+  /**
+   * Creates a Jade from Web Serial for the given network
+   *
+   * When filter is true, it will filter available serial with Blockstream released chips, use
+   * false if you don't see your DYI jade
+   */
+  constructor(network: Network, filter: boolean);
+  getVersion(): Promise<any>;
+  getMasterXpub(): Promise<Xpub>;
+  /**
+   * Return a single sig address with the given `variant` and `path` derivation
+   */
+  getReceiveAddressSingle(variant: Singlesig, path: Uint32Array): Promise<string>;
+  /**
+   * Return a multisig address of a registered `multisig_name` wallet
+   *
+   * This method accept `path` and `path_n` in place of a single `Vec<Vec<u32>>` because the
+   * latter is not supported by wasm_bindgen (and neither `(u32, Vec<u32>)`). `path` and `path_n`
+   * are converted internally to a `Vec<Vec<u32>>` with the caveat all the paths are the same,
+   * which is almost always the case.
+   */
+  getReceiveAddressMulti(multisig_name: string, path: Uint32Array): Promise<string>;
+  /**
+   * Sign and consume the given PSET, returning the signed one
+   */
+  sign(pset: Pset): Promise<Pset>;
+  wpkh(): Promise<WolletDescriptor>;
+  shWpkh(): Promise<WolletDescriptor>;
+  multi(name: string): Promise<WolletDescriptor>;
+  getRegisteredMultisigs(): Promise<any>;
+  keyoriginXpub(bip: Bip): Promise<string>;
+  registerDescriptor(name: string, desc: WolletDescriptor): Promise<boolean>;
+}
+export class LedgerWeb {
+  free(): void;
+  constructor(hid_device: HIDDevice);
+  get_version(): Promise<string>;
+}
+/**
+ * Wrapper of [`bip39::Mnemonic`]
+ */
+export class Mnemonic {
+  free(): void;
+  /**
+   * Creates a Mnemonic
+   */
+  constructor(s: string);
+  toString(): string;
+  /**
+   * Creates a Mnemonic from entropy, at least 16 bytes are needed.
+   */
+  static fromEntropy(b: Uint8Array): Mnemonic;
+  /**
+   * Creates a random Mnemonic of given words (12,15,18,21,24)
+   */
+  static fromRandom(word_count: number): Mnemonic;
+}
+/**
+ * Wrapper of [`lwk_wollet::ElementsNetwork`]
+ */
+export class Network {
+  private constructor();
+  free(): void;
+  /**
+   * Creates a mainnet `Network``
+   */
+  static mainnet(): Network;
+  /**
+   * Creates a testnet `Network``
+   */
+  static testnet(): Network;
+  /**
+   * Creates a regtest `Network``
+   */
+  static regtest(policy_asset: AssetId): Network;
+  /**
+   * Creates the default regtest `Network`
+   */
+  static regtestDefault(): Network;
+  defaultEsploraClient(): EsploraClient;
+  isMainnet(): boolean;
+  toString(): string;
+  policyAsset(): AssetId;
+  txBuilder(): TxBuilder;
+  defaultExplorerUrl(): string;
+}
+/**
+ * An optional wallet transaction output. Could be None when it's not possible to unblind.
+ * It seems required by wasm_bindgen because we can't return `Vec<Option<WalletTxOut>>`
+ */
+export class OptionWalletTxOut {
+  private constructor();
+  free(): void;
+  get(): WalletTxOut | undefined;
+}
+/**
+ * Wrapper of [`elements::OutPoint`]
+ */
+export class OutPoint {
+  free(): void;
+  /**
+   * Creates an `OutPoint`
+   */
+  constructor(s: string);
+  txid(): Txid;
+  vout(): number;
+}
+/**
+ * Wrapper of [`lwk_common::precision::Precision`]
+ */
+export class Precision {
+  free(): void;
+  /**
+   * Creates a Precision
+   */
+  constructor(precision: number);
+  satsToString(sats: bigint): string;
+  stringToSats(sats: string): bigint;
+}
+/**
+ * Partially Signed Elements Transaction, wrapper of [`PartiallySignedTransaction`]
+ */
+export class Pset {
+  free(): void;
+  /**
+   * Creates a `Pset`
+   */
+  constructor(base64: string);
+  toString(): string;
+  extractTx(): Transaction;
+  combine(other: Pset): void;
+  inputs(): (PsetInput)[];
+}
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetBalance`]
+ */
+export class PsetBalance {
+  private constructor();
+  free(): void;
+  fee(): bigint;
+  /**
+   * The net balance for every asset with respect of the wallet asking the pset details
+   */
+  balances(): any;
+  recipients(): (Recipient)[];
+}
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetDetails`]
+ */
+export class PsetDetails {
+  private constructor();
+  free(): void;
+  balance(): PsetBalance;
+  /**
+   * For each input existing or missing signatures
+   */
+  signatures(): (PsetSignatures)[];
+  fingerprintsMissing(): (string)[];
+  fingerprintsHas(): (string)[];
+  /**
+   * Return an element for every input that could possibly be a issuance or a reissuance
+   */
+  inputsIssuances(): (Issuance)[];
+}
+/**
+ * PSET input
+ */
+export class PsetInput {
+  private constructor();
+  free(): void;
+  /**
+   * Prevout TXID of the input
+   */
+  previous_txid(): Txid;
+  /**
+   * Prevout vout of the input
+   */
+  previous_vout(): number;
+  /**
+   * If the input has an issuance, the asset id
+   */
+  issuanceAsset(): AssetId | undefined;
+  /**
+   * If the input has an issuance, the token id
+   */
+  issuanceToken(): AssetId | undefined;
+}
+/**
+ * PSET details from a perspective of a wallet, wrapper of [`lwk_common::PsetSignatures`]
+ */
+export class PsetSignatures {
+  private constructor();
+  free(): void;
+  /**
+   * Returns `Vec<(PublicKey, KeySource)>`
+   */
+  hasSignature(): any;
+  missingSignature(): any;
+}
+/**
+ * Recipient of a PSET, in other words outputs that doesn't belong to the wallet
+ */
+export class Recipient {
+  private constructor();
+  free(): void;
+  asset(): AssetId | undefined;
+  value(): bigint | undefined;
+  address(): Address | undefined;
+  vout(): number;
+}
+/**
+ * Wrapper of [`elements::Script`]
+ */
+export class Script {
+  free(): void;
+  /**
+   * Creates a `Script`
+   */
+  constructor(s: string);
+  bytes(): Uint8Array;
+  asm(): string;
+  toString(): string;
+}
+/**
+ * A Software signer, wrapper of [`lwk_signer::SwSigner`]
+ */
+export class Signer {
+  free(): void;
+  /**
+   * Creates a `Signer`
+   */
+  constructor(mnemonic: Mnemonic, network: Network);
+  /**
+   * Sign and consume the given PSET, returning the signed one
+   */
+  sign(pset: Pset): Pset;
+  wpkhSlip77Descriptor(): WolletDescriptor;
+  getMasterXpub(): Xpub;
+  keyoriginXpub(bip: Bip): string;
+  mnemonic(): Mnemonic;
+}
+export class Singlesig {
+  private constructor();
+  free(): void;
+  static from(variant: string): Singlesig;
+}
+/**
+ * Wrapper of [`lwk_wollet::Tip`]
+ */
+export class Tip {
+  private constructor();
+  free(): void;
+  height(): number;
+  hash(): string;
+  timestamp(): number | undefined;
+}
+/**
+ * A Liquid transaction, wrapper of [`elements::Transaction`]
+ *
+ * See [`crate::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 {
+  free(): void;
+  /**
+   * Creates a `Transaction`
+   */
+  constructor(tx_hex: string);
+  txid(): Txid;
+  bytes(): Uint8Array;
+  fee(policy_asset: AssetId): bigint;
+  toString(): string;
+}
+/**
+ * Wrapper of [`lwk_wollet::TxBuilder`]
+ */
+export class TxBuilder {
+  free(): void;
+  /**
+   * Creates a transaction builder
+   */
+  constructor(network: Network);
+  /**
+   * Build the transaction
+   */
+  finish(wollet: Wollet): Pset;
+  /**
+   * Set the fee rate
+   */
+  feeRate(fee_rate?: number): TxBuilder;
+  /**
+   * Select all available L-BTC inputs
+   */
+  drainLbtcWallet(): TxBuilder;
+  /**
+   * Sets the address to drain excess L-BTC to
+   */
+  drainLbtcTo(address: Address): TxBuilder;
+  /**
+   * Add a recipient receiving L-BTC
+   *
+   * Errors if address's network is incompatible
+   */
+  addLbtcRecipient(address: Address, satoshi: bigint): TxBuilder;
+  /**
+   * Add a recipient receiving the given asset
+   *
+   * Errors if address's network is incompatible
+   */
+  addRecipient(address: Address, satoshi: bigint, asset: AssetId): TxBuilder;
+  /**
+   * Burn satoshi units of the given asset
+   */
+  addBurn(satoshi: bigint, asset: AssetId): TxBuilder;
+  /**
+   * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
+   */
+  issueAsset(asset_sats: bigint, asset_receiver: Address | undefined, token_sats: bigint, token_receiver?: Address, contract?: Contract): TxBuilder;
+  /**
+   * Reissue an asset, wrapper of [`lwk_wollet::TxBuilder::reissue_asset()`]
+   */
+  reissueAsset(asset_to_reissue: AssetId, satoshi_to_reissue: bigint, asset_receiver?: Address, issuance_tx?: Transaction): TxBuilder;
+  toString(): string;
+}
+/**
+ * Wrapper of [`elements::TxOutSecrets`]
+ */
+export class TxOutSecrets {
+  private constructor();
+  free(): void;
+  asset(): AssetId;
+  assetBlindingFactor(): string;
+  value(): bigint;
+  valueBlindingFactor(): string;
+}
+/**
+ * A valid transaction identifier.
+ *
+ * 32 bytes encoded as hex string.
+ */
+export class Txid {
+  free(): void;
+  /**
+   * Creates a `Txid`
+   */
+  constructor(tx_id: string);
+  toString(): string;
+}
+/**
+ * Wrapper of [`lwk_wollet::Update`]
+ */
+export class Update {
+  free(): void;
+  /**
+   * Creates an `Update`
+   */
+  constructor(bytes: Uint8Array);
+  serialize(): Uint8Array;
+  serializeEncryptedBase64(desc: WolletDescriptor): string;
+  static deserializeDecryptedBase64(base64: string, desc: WolletDescriptor): Update;
+  onlyTip(): boolean;
+  prune(wollet: Wollet): void;
+}
+/**
+ * Wrapper of [`lwk_wollet::WalletTx`]
+ */
+export class WalletTx {
+  private constructor();
+  free(): void;
+  tx(): Transaction;
+  height(): number | undefined;
+  balance(): any;
+  txid(): Txid;
+  fee(): bigint;
+  txType(): string;
+  timestamp(): number | undefined;
+  inputs(): (OptionWalletTxOut)[];
+  outputs(): (OptionWalletTxOut)[];
+  unblindedUrl(explorer_url: string): string;
+}
+/**
+ * Wrapper of [`lwk_wollet::WalletTxOut`]
+ */
+export class WalletTxOut {
+  private constructor();
+  free(): void;
+  outpoint(): OutPoint;
+  scriptPubkey(): Script;
+  height(): number | undefined;
+  unblinded(): TxOutSecrets;
+  wildcardIndex(): number;
+  extInt(): Chain;
+}
+/**
+ * Wrapper of [`lwk_wollet::Wollet`]
+ */
+export class Wollet {
+  free(): void;
+  /**
+   * Create a `Wollet`
+   */
+  constructor(network: Network, descriptor: WolletDescriptor);
+  /**
+   * Get a wallet address with the correspondong derivation index
+   *
+   * If Some return the address at the given index,
+   * otherwise the last unused address.
+   */
+  address(index?: number): AddressResult;
+  addressFullPath(index: number): Uint32Array;
+  applyUpdate(update: Update): void;
+  balance(): any;
+  transactions(): (WalletTx)[];
+  /**
+   * Finalize and consume the given PSET, returning the finalized one
+   */
+  finalize(pset: Pset): Pset;
+  psetDetails(pset: Pset): PsetDetails;
+  descriptor(): WolletDescriptor;
+  status(): bigint;
+  tip(): Tip;
+  /**
+   * wraps [lwk_wollet::Wollet::never_scanned()]
+   */
+  neverScanned(): boolean;
+}
+/**
+ * Wrapper of [`lwk_wollet::WolletDescriptor`]
+ */
+export class WolletDescriptor {
+  free(): void;
+  /**
+   * Creates a `WolletDescriptor`
+   */
+  constructor(descriptor: string);
+  toString(): string;
+  static newMultiWshSlip77(threshold: number, participants: (string)[]): WolletDescriptor;
+  isMainnet(): boolean;
+}
+/**
+ * Wrapper of [`bip32::Xpub`]
+ */
+export class Xpub {
+  free(): void;
+  /**
+   * Creates a Mnemonic
+   */
+  constructor(s: string);
+  toString(): string;
+  identifier(): string;
+  fingerprint(): string;
+  /**
+   * Returns true if the passed string is a valid xpub with a valid keyorigin if present
+   */
+  static isValidWithKeyOrigin(s: string): boolean;
+}