lwk_node 0.9.3 → 0.11.0

package/lwk_wasm.d.ts

@@ -59,6 +59,67 @@ export class AddressResult {
   address(): Address;
   index(): number;
 }
+/**
+ * Wrapper of [`lwk_wollet::amp0::Amp0`]
+ */
+export class Amp0 {
+  private constructor();
+  free(): void;
+  /**
+   * Create a new AMP0 context for the specified network
+   */
+  static newWithNetwork(network: Network, username: string, password: string, amp_id: string): Promise<Amp0>;
+  /**
+   * Create a new AMP0 context for testnet
+   */
+  static netTestnet(username: string, password: string, amp_id: string): Promise<Amp0>;
+  /**
+   * Create a new AMP0 context for mainnet
+   */
+  static newMainnet(username: string, password: string, amp_id: string): Promise<Amp0>;
+  /**
+   * Index of the last returned address
+   *
+   * Use this and [`crate::EsploraClient::full_scan_to_index()`] to sync the `Wollet`
+   */
+  lastIndex(): number;
+  /**
+   * AMP ID
+   */
+  ampId(): string;
+  /**
+   * Get an address
+   *
+   * If `index` is None, a new address is returned.
+   */
+  address(index?: number | null): Promise<AddressResult>;
+  /**
+   * The LWK watch-only wallet corresponding to the AMP0 (sub)account.
+   */
+  wollet(): Wollet;
+  /**
+   * Ask AMP0 server to cosign
+   */
+  sign(amp0pset: Amp0Pset): Promise<Transaction>;
+}
+/**
+ * Wrapper of [`lwk_wollet::amp0::Amp0Pset`]
+ */
+export class Amp0Pset {
+  free(): void;
+  /**
+   * Creates a `Amp0Pset`
+   */
+  constructor(pset: Pset, blinding_nonces: string[]);
+  /**
+   * Get the PSET
+   */
+  pset(): Pset;
+  /**
+   * Get the blinding nonces
+   */
+  blindingNonces(): string[];
+}
 /**
  * Wrapper of [`lwk_wollet::amp2::Amp2`]
  */
@@ -101,6 +162,15 @@ export class AssetId {
   constructor(asset_id: string);
   toString(): string;
 }
+/**
+ * A collection of asset identifiers. wrapper of [`Vec<elements::AssetId>`]
+ */
+export class AssetIds {
+  private constructor();
+  free(): void;
+  static empty(): AssetIds;
+  toString(): string;
+}
 export class AssetMeta {
   private constructor();
   free(): void;
@@ -148,12 +218,13 @@ export class EsploraClient {
   /**
    * Creates a client, wrapper of [`asyncr::EsploraClient`]
    */
-  constructor(network: Network, url: string, waterfalls: boolean, concurrency: number);
+  constructor(network: Network, url: string, waterfalls: boolean, concurrency: number, utxo_only: boolean);
   fullScan(wollet: Wollet): Promise<Update | undefined>;
   /**
    * Scan the blockchain for the scripts generated by a watch-only wallet up to a specified derivation index
    */
   fullScanToIndex(wollet: Wollet, index: number): Promise<Update | undefined>;
+  broadcastTx(tx: Transaction): Promise<Txid>;
   broadcast(pset: Pset): Promise<Txid>;
   set_waterfalls_server_recipient(recipient: string): Promise<void>;
 }
@@ -454,10 +525,22 @@ export class Recipient {
 export class Registry {
   private constructor();
   free(): void;
-  static new(url: string): Registry;
-  static defaultForNetwork(network: Network): Registry;
+  static new(url: string, asset_ids: AssetIds): Promise<Registry>;
+  static defaultForNetwork(network: Network, asset_ids: AssetIds): Promise<Registry>;
+  static defaultHardcodedForNetwork(network: Network): Registry;
   fetchWithTx(asset_id: AssetId, client: EsploraClient): Promise<AssetMeta>;
   post(data: RegistryPost): Promise<void>;
+  get(asset_id: AssetId): RegistryData | undefined;
+  getAssetOfToken(token_id: AssetId): RegistryData | undefined;
+  addContracts(pset: Pset): Pset;
+}
+export class RegistryData {
+  private constructor();
+  free(): void;
+  precision(): number;
+  ticker(): string;
+  name(): string;
+  domain(): string;
 }
 export class RegistryPost {
   free(): void;
@@ -544,6 +627,10 @@ export class TxBuilder {
    * Build the transaction
    */
   finish(wollet: Wollet): Pset;
+  /**
+   * Build the transaction for AMP0
+   */
+  finishForAmp0(wollet: Wollet): Amp0Pset;
   /**
    * Set the fee rate
    */
@@ -572,6 +659,10 @@ export class TxBuilder {
    * Burn satoshi units of the given asset
    */
   addBurn(satoshi: bigint, asset: AssetId): TxBuilder;
+  /**
+   * Add explicit recipient
+   */
+  addExplicitRecipient(address: Address, satoshi: bigint, asset: AssetId): TxBuilder;
   /**
    * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
    */
@@ -598,6 +689,19 @@ export class TxOutSecrets {
   assetBlindingFactor(): string;
   value(): bigint;
   valueBlindingFactor(): string;
+  isExplicit(): boolean;
+  /**
+   * Get the asset commitment
+   *
+   * If the output is explicit, returns the empty string
+   */
+  assetCommitment(): string;
+  /**
+   * Get the value commitment
+   *
+   * If the output is explicit, returns the empty string
+   */
+  valueCommitment(): string;
 }
 /**
  * A valid transaction identifier.
@@ -698,7 +802,9 @@ export class Wollet {
   address(index?: number | null): AddressResult;
   addressFullPath(index: number): Uint32Array;
   applyUpdate(update: Update): void;
+  applyTransaction(tx: Transaction): void;
   balance(): any;
+  assetsOwned(): AssetIds;
   transactions(): WalletTx[];
   /**
    * Get the unspent transaction outputs of the wallet
@@ -720,6 +826,10 @@ export class Wollet {
    * wraps [lwk_wollet::Wollet::never_scanned()]
    */
   neverScanned(): boolean;
+  /**
+   * Whether the wallet is AMP0
+   */
+  isAmp0(): boolean;
 }
 /**
  * Wrapper of [`lwk_wollet::WolletDescriptor`]
@@ -733,6 +843,10 @@ export class WolletDescriptor {
   toString(): string;
   static newMultiWshSlip77(threshold: number, participants: string[]): WolletDescriptor;
   isMainnet(): boolean;
+  /**
+   * Whether the descriptor is AMP0
+   */
+  isAmp0(): boolean;
 }
 /**
  * Wrapper of [`bip32::Xpub`]

package/lwk_wasm.js

@@ -219,13 +219,6 @@ function _assertClass(instance, klass) {
     }
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
@@ -235,6 +228,13 @@ function passArrayJsValueToWasm0(array, malloc) {
     WASM_VECTOR_LEN = array.length;
     return ptr;
 }
+/**
+ * @returns {Promise<HIDDevice>}
+ */
+module.exports.searchLedgerDevice = function() {
+    const ret = wasm.searchLedgerDevice();
+    return ret;
+};
 
 let cachedUint32ArrayMemory0 = null;
 
@@ -263,28 +263,27 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
-/**
- * @returns {Promise<HIDDevice>}
- */
-module.exports.searchLedgerDevice = function() {
-    const ret = wasm.searchLedgerDevice();
-    return ret;
-};
-
 function __wbg_adapter_36(arg0, arg1, arg2) {
-    wasm.closure285_externref_shim(arg0, arg1, arg2);
+    wasm.closure451_externref_shim(arg0, arg1, arg2);
 }
 
 function __wbg_adapter_43(arg0, arg1, arg2) {
-    wasm.closure1166_externref_shim(arg0, arg1, arg2);
+    wasm.closure1348_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_481(arg0, arg1, arg2, arg3) {
-    wasm.closure1915_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_526(arg0, arg1, arg2, arg3) {
+    wasm.closure2120_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -510,6 +509,214 @@ class AddressResult {
 }
 module.exports.AddressResult = AddressResult;
 
+const Amp0Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp0_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::amp0::Amp0`]
+ */
+class Amp0 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp0.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp0Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp0Finalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp0_free(ptr, 0);
+    }
+    /**
+     * Create a new AMP0 context for the specified network
+     * @param {Network} network
+     * @param {string} username
+     * @param {string} password
+     * @param {string} amp_id
+     * @returns {Promise<Amp0>}
+     */
+    static newWithNetwork(network, username, password, amp_id) {
+        _assertClass(network, Network);
+        var ptr0 = network.__destroy_into_raw();
+        const ptr1 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(amp_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0_newWithNetwork(ptr0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * Create a new AMP0 context for testnet
+     * @param {string} username
+     * @param {string} password
+     * @param {string} amp_id
+     * @returns {Promise<Amp0>}
+     */
+    static netTestnet(username, password, amp_id) {
+        const ptr0 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(amp_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0_netTestnet(ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * Create a new AMP0 context for mainnet
+     * @param {string} username
+     * @param {string} password
+     * @param {string} amp_id
+     * @returns {Promise<Amp0>}
+     */
+    static newMainnet(username, password, amp_id) {
+        const ptr0 = passStringToWasm0(username, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(password, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(amp_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0_newMainnet(ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * Index of the last returned address
+     *
+     * Use this and [`crate::EsploraClient::full_scan_to_index()`] to sync the `Wollet`
+     * @returns {number}
+     */
+    lastIndex() {
+        const ret = wasm.amp0_lastIndex(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * AMP ID
+     * @returns {string}
+     */
+    ampId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.amp0_ampId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get an address
+     *
+     * If `index` is None, a new address is returned.
+     * @param {number | null} [index]
+     * @returns {Promise<AddressResult>}
+     */
+    address(index) {
+        const ret = wasm.amp0_address(this.__wbg_ptr, isLikeNone(index) ? 0x100000001 : (index) >>> 0);
+        return ret;
+    }
+    /**
+     * The LWK watch-only wallet corresponding to the AMP0 (sub)account.
+     * @returns {Wollet}
+     */
+    wollet() {
+        const ret = wasm.amp0_wollet(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Wollet.__wrap(ret[0]);
+    }
+    /**
+     * Ask AMP0 server to cosign
+     * @param {Amp0Pset} amp0pset
+     * @returns {Promise<Transaction>}
+     */
+    sign(amp0pset) {
+        _assertClass(amp0pset, Amp0Pset);
+        const ret = wasm.amp0_sign(this.__wbg_ptr, amp0pset.__wbg_ptr);
+        return ret;
+    }
+}
+module.exports.Amp0 = Amp0;
+
+const Amp0PsetFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_amp0pset_free(ptr >>> 0, 1));
+/**
+ * Wrapper of [`lwk_wollet::amp0::Amp0Pset`]
+ */
+class Amp0Pset {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Amp0Pset.prototype);
+        obj.__wbg_ptr = ptr;
+        Amp0PsetFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Amp0PsetFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_amp0pset_free(ptr, 0);
+    }
+    /**
+     * Creates a `Amp0Pset`
+     * @param {Pset} pset
+     * @param {string[]} blinding_nonces
+     */
+    constructor(pset, blinding_nonces) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ptr1 = passArrayJsValueToWasm0(blinding_nonces, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.amp0pset_new(ptr0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        Amp0PsetFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the PSET
+     * @returns {Pset}
+     */
+    pset() {
+        const ret = wasm.amp0pset_pset(this.__wbg_ptr);
+        return Pset.__wrap(ret);
+    }
+    /**
+     * Get the blinding nonces
+     * @returns {string[]}
+     */
+    blindingNonces() {
+        const ret = wasm.amp0pset_blindingNonces(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+}
+module.exports.Amp0Pset = Amp0Pset;
+
 const Amp2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_amp2_free(ptr >>> 0, 1));
@@ -736,6 +943,61 @@ class AssetId {
 }
 module.exports.AssetId = AssetId;
 
+const AssetIdsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_assetids_free(ptr >>> 0, 1));
+/**
+ * A collection of asset identifiers. wrapper of [`Vec<elements::AssetId>`]
+ */
+class AssetIds {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AssetIds.prototype);
+        obj.__wbg_ptr = ptr;
+        AssetIdsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AssetIdsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_assetids_free(ptr, 0);
+    }
+    /**
+     * @returns {AssetIds}
+     */
+    static empty() {
+        const ret = wasm.assetids_empty();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetIds.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.assetids_toString(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.AssetIds = AssetIds;
+
 const AssetMetaFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetmeta_free(ptr >>> 0, 1));
@@ -973,13 +1235,17 @@ class EsploraClient {
      * @param {string} url
      * @param {boolean} waterfalls
      * @param {number} concurrency
+     * @param {boolean} utxo_only
      */
-    constructor(network, url, waterfalls, concurrency) {
+    constructor(network, url, waterfalls, concurrency, utxo_only) {
         _assertClass(network, Network);
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.esploraclient_new(network.__wbg_ptr, ptr0, len0, waterfalls, concurrency);
-        this.__wbg_ptr = ret >>> 0;
+        const ret = wasm.esploraclient_new(network.__wbg_ptr, ptr0, len0, waterfalls, concurrency, utxo_only);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
         EsploraClientFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
@@ -1003,6 +1269,15 @@ class EsploraClient {
         const ret = wasm.esploraclient_fullScanToIndex(this.__wbg_ptr, wollet.__wbg_ptr, index);
         return ret;
     }
+    /**
+     * @param {Transaction} tx
+     * @returns {Promise<Txid>}
+     */
+    broadcastTx(tx) {
+        _assertClass(tx, Transaction);
+        const ret = wasm.esploraclient_broadcastTx(this.__wbg_ptr, tx.__wbg_ptr);
+        return ret;
+    }
     /**
      * @param {Pset} pset
      * @returns {Promise<Txid>}
@@ -2345,24 +2620,34 @@ class Registry {
     }
     /**
      * @param {string} url
-     * @returns {Registry}
+     * @param {AssetIds} asset_ids
+     * @returns {Promise<Registry>}
      */
-    static new(url) {
+    static new(url, asset_ids) {
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.registry_new(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Registry.__wrap(ret[0]);
+        _assertClass(asset_ids, AssetIds);
+        const ret = wasm.registry_new(ptr0, len0, asset_ids.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Network} network
+     * @param {AssetIds} asset_ids
+     * @returns {Promise<Registry>}
+     */
+    static defaultForNetwork(network, asset_ids) {
+        _assertClass(network, Network);
+        _assertClass(asset_ids, AssetIds);
+        const ret = wasm.registry_defaultForNetwork(network.__wbg_ptr, asset_ids.__wbg_ptr);
+        return ret;
     }
     /**
      * @param {Network} network
      * @returns {Registry}
      */
-    static defaultForNetwork(network) {
+    static defaultHardcodedForNetwork(network) {
         _assertClass(network, Network);
-        const ret = wasm.registry_defaultForNetwork(network.__wbg_ptr);
+        const ret = wasm.registry_defaultHardcodedForNetwork(network.__wbg_ptr);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -2388,9 +2673,120 @@ class Registry {
         const ret = wasm.registry_post(this.__wbg_ptr, data.__wbg_ptr);
         return ret;
     }
+    /**
+     * @param {AssetId} asset_id
+     * @returns {RegistryData | undefined}
+     */
+    get(asset_id) {
+        _assertClass(asset_id, AssetId);
+        const ret = wasm.registry_get(this.__wbg_ptr, asset_id.__wbg_ptr);
+        return ret === 0 ? undefined : RegistryData.__wrap(ret);
+    }
+    /**
+     * @param {AssetId} token_id
+     * @returns {RegistryData | undefined}
+     */
+    getAssetOfToken(token_id) {
+        _assertClass(token_id, AssetId);
+        const ret = wasm.registry_getAssetOfToken(this.__wbg_ptr, token_id.__wbg_ptr);
+        return ret === 0 ? undefined : RegistryData.__wrap(ret);
+    }
+    /**
+     * @param {Pset} pset
+     * @returns {Pset}
+     */
+    addContracts(pset) {
+        _assertClass(pset, Pset);
+        var ptr0 = pset.__destroy_into_raw();
+        const ret = wasm.registry_addContracts(this.__wbg_ptr, ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Pset.__wrap(ret[0]);
+    }
 }
 module.exports.Registry = Registry;
 
+const RegistryDataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_registrydata_free(ptr >>> 0, 1));
+
+class RegistryData {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RegistryData.prototype);
+        obj.__wbg_ptr = ptr;
+        RegistryDataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RegistryDataFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_registrydata_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    precision() {
+        const ret = wasm.registrydata_precision(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {string}
+     */
+    ticker() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.registrydata_ticker(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.registrydata_name(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    domain() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.registrydata_domain(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+module.exports.RegistryData = RegistryData;
+
 const RegistryPostFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_registrypost_free(ptr >>> 0, 1));
@@ -2872,7 +3268,7 @@ class TxBuilder {
      */
     constructor(network) {
         _assertClass(network, Network);
-        const ret = wasm.txbuilder_new(network.__wbg_ptr);
+        const ret = wasm.network_txBuilder(network.__wbg_ptr);
         this.__wbg_ptr = ret >>> 0;
         TxBuilderFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -2891,6 +3287,20 @@ class TxBuilder {
         }
         return Pset.__wrap(ret[0]);
     }
+    /**
+     * Build the transaction for AMP0
+     * @param {Wollet} wollet
+     * @returns {Amp0Pset}
+     */
+    finishForAmp0(wollet) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(wollet, Wollet);
+        const ret = wasm.txbuilder_finishForAmp0(ptr, wollet.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Amp0Pset.__wrap(ret[0]);
+    }
     /**
      * Set the fee rate
      * @param {number | null} [fee_rate]
@@ -2970,6 +3380,24 @@ class TxBuilder {
         const ret = wasm.txbuilder_addBurn(ptr, satoshi, asset.__wbg_ptr);
         return TxBuilder.__wrap(ret);
     }
+    /**
+     * Add explicit recipient
+     * @param {Address} address
+     * @param {bigint} satoshi
+     * @param {AssetId} asset
+     * @returns {TxBuilder}
+     */
+    addExplicitRecipient(address, satoshi, asset) {
+        const ptr = this.__destroy_into_raw();
+        _assertClass(address, Address);
+        var ptr0 = address.__destroy_into_raw();
+        _assertClass(asset, AssetId);
+        const ret = wasm.txbuilder_addExplicitRecipient(ptr, ptr0, satoshi, asset.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return TxBuilder.__wrap(ret[0]);
+    }
     /**
      * Issue an asset, wrapper of [`lwk_wollet::TxBuilder::issue_asset()`]
      * @param {bigint} asset_sats
@@ -3166,6 +3594,49 @@ class TxOutSecrets {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {boolean}
+     */
+    isExplicit() {
+        const ret = wasm.txoutsecrets_isExplicit(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the asset commitment
+     *
+     * If the output is explicit, returns the empty string
+     * @returns {string}
+     */
+    assetCommitment() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.txoutsecrets_assetCommitment(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the value commitment
+     *
+     * If the output is explicit, returns the empty string
+     * @returns {string}
+     */
+    valueCommitment() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.txoutsecrets_valueCommitment(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
 }
 module.exports.TxOutSecrets = TxOutSecrets;
 
@@ -3715,6 +4186,14 @@ const WolletFinalization = (typeof FinalizationRegistry === 'undefined')
  */
 class Wollet {
 
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Wollet.prototype);
+        obj.__wbg_ptr = ptr;
+        WolletFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -3780,6 +4259,16 @@ class Wollet {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * @param {Transaction} tx
+     */
+    applyTransaction(tx) {
+        _assertClass(tx, Transaction);
+        const ret = wasm.wollet_applyTransaction(this.__wbg_ptr, tx.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * @returns {any}
      */
@@ -3790,6 +4279,16 @@ class Wollet {
         }
         return takeFromExternrefTable0(ret[0]);
     }
+    /**
+     * @returns {AssetIds}
+     */
+    assetsOwned() {
+        const ret = wasm.wollet_assetsOwned(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetIds.__wrap(ret[0]);
+    }
     /**
      * @returns {WalletTx[]}
      */
@@ -3886,6 +4385,14 @@ class Wollet {
         const ret = wasm.wollet_neverScanned(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Whether the wallet is AMP0
+     * @returns {boolean}
+     */
+    isAmp0() {
+        const ret = wasm.wollet_isAmp0(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 module.exports.Wollet = Wollet;
 
@@ -3967,6 +4474,14 @@ class WolletDescriptor {
         const ret = wasm.wolletdescriptor_isMainnet(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Whether the descriptor is AMP0
+     * @returns {boolean}
+     */
+    isAmp0() {
+        const ret = wasm.wolletdescriptor_isAmp0(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 module.exports.WolletDescriptor = WolletDescriptor;
 
@@ -4083,6 +4598,16 @@ module.exports.__wbg_abort_775ef1d17fc65868 = function(arg0) {
     arg0.abort();
 };
 
+module.exports.__wbg_addressresult_new = function(arg0) {
+    const ret = AddressResult.__wrap(arg0);
+    return ret;
+};
+
+module.exports.__wbg_amp0_new = function(arg0) {
+    const ret = Amp0.__wrap(arg0);
+    return ret;
+};
+
 module.exports.__wbg_append_8c7dd8d641a5f01b = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments) };
@@ -4296,7 +4821,7 @@ module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
     return ret;
 };
 
-module.exports.__wbg_log_a059746199e3a950 = function(arg0, arg1) {
+module.exports.__wbg_log_1c0673da475f4734 = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -4327,7 +4852,7 @@ module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_481(a, state0.b, arg0, arg1);
+                return __wbg_adapter_526(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -4389,6 +4914,11 @@ module.exports.__wbg_newwithstrandinit_06c535e0a867c635 = function() { return ha
     return ret;
 }, arguments) };
 
+module.exports.__wbg_newwithstrsequence_6e9d6479e1cf978d = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = new WebSocket(getStringFromWasm0(arg0, arg1), arg2);
+    return ret;
+}, arguments) };
+
 module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) {
     const ret = arg0.next;
     return ret;
@@ -4469,6 +4999,11 @@ module.exports.__wbg_psetsignatures_new = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_push_737cfc8c1432c2c6 = function(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+};
+
 module.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) {
     queueMicrotask(arg0);
 };
@@ -4497,6 +5032,11 @@ module.exports.__wbg_recipient_new = function(arg0) {
     return ret;
 };
 
+module.exports.__wbg_registry_new = function(arg0) {
+    const ret = Registry.__wrap(arg0);
+    return ret;
+};
+
 module.exports.__wbg_requestDevice_b9904d52d001d64d = function(arg0, arg1) {
     const ret = arg0.requestDevice(arg1);
     return ret;
@@ -4527,6 +5067,10 @@ module.exports.__wbg_sendReport_4d1024566077f413 = function() { return handleErr
     return ret;
 }, arguments) };
 
+module.exports.__wbg_send_0293179ba074ffb4 = function() { return handleError(function (arg0, arg1, arg2) {
+    arg0.send(getStringFromWasm0(arg1, arg2));
+}, arguments) };
+
 module.exports.__wbg_send_7c4769e24cf1d784 = function() { return handleError(function (arg0, arg1) {
     arg0.send(arg1);
 }, arguments) };
@@ -4665,6 +5209,11 @@ module.exports.__wbg_then_48b406749878a531 = function(arg0, arg1, arg2) {
     return ret;
 };
 
+module.exports.__wbg_transaction_new = function(arg0) {
+    const ret = Transaction.__wrap(arg0);
+    return ret;
+};
+
 module.exports.__wbg_txid_new = function(arg0) {
     const ret = Txid.__wrap(arg0);
     return ret;
@@ -4748,23 +5297,23 @@ module.exports.__wbindgen_cb_drop = function(arg0) {
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper10168 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1167, __wbg_adapter_43);
+module.exports.__wbindgen_closure_wrapper12419 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 1349, __wbg_adapter_43);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper5011 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 287, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper4731 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 452, __wbg_adapter_36);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper5013 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 286, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper4733 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 453, __wbg_adapter_36);
     return ret;
 };
 
-module.exports.__wbindgen_closure_wrapper5015 = function(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 287, __wbg_adapter_36);
+module.exports.__wbindgen_closure_wrapper4735 = function(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 452, __wbg_adapter_36);
     return ret;
 };
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lwk_node",
   "description": "Liquid Wallet Kit - WASM",
-  "version": "0.9.3",
+  "version": "0.11.0",
   "license": "MIT OR BSD-2-Clause",
   "files": [
     "lwk_wasm_bg.wasm",