lwk_node 0.14.1 → 0.16.0

package/lwk_wasm.js

@@ -102,15 +102,22 @@ function handleError(f, args) {
     }
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+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 isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -210,17 +217,6 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_4.get(idx);
     wasm.__externref_table_dealloc(idx);
@@ -233,6 +229,27 @@ function _assertClass(instance, klass) {
     }
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_4.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 let cachedUint32ArrayMemory0 = null;
 
 function getUint32ArrayMemory0() {
@@ -248,6 +265,14 @@ function passArray32ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+/**
+ * @returns {Promise<HIDDevice>}
+ */
+exports.searchLedgerDevice = function() {
+    const ret = wasm.searchLedgerDevice();
+    return ret;
+};
+
 /**
  * Convert the given string to a QR code image uri
  *
@@ -280,56 +305,32 @@ exports.stringToQr = function(str, pixel_per_module) {
     }
 };
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    for (let i = 0; i < array.length; i++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-/**
- * @returns {Promise<HIDDevice>}
- */
-exports.searchLedgerDevice = function() {
-    const ret = wasm.searchLedgerDevice();
-    return ret;
-};
-
-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);
 }
-function __wbg_adapter_12(arg0, arg1, arg2) {
-    wasm.closure1333_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_12(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h912986096667d3cb(arg0, arg1);
 }
 
-function __wbg_adapter_19(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h912986096667d3cb(arg0, arg1);
+function __wbg_adapter_15(arg0, arg1, arg2) {
+    wasm.closure1352_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_22(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h05232c3defb8be20(arg0, arg1);
+function __wbg_adapter_24(arg0, arg1, arg2) {
+    wasm.closure1999_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_25(arg0, arg1, arg2) {
-    wasm.closure1963_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_31(arg0, arg1, arg2) {
+    wasm.closure804_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_30(arg0, arg1, arg2) {
-    wasm.closure793_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_34(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h94f351489121fb87(arg0, arg1);
 }
 
-function __wbg_adapter_647(arg0, arg1, arg2, arg3) {
-    wasm.closure2737_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_694(arg0, arg1, arg2, arg3) {
+    wasm.closure2782_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 /**
@@ -1168,6 +1169,104 @@ if (Symbol.dispose) AssetAmount.prototype[Symbol.dispose] = AssetAmount.prototyp
 
 exports.AssetAmount = AssetAmount;
 
+const AssetBlindingFactorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_assetblindingfactor_free(ptr >>> 0, 1));
+/**
+ * A blinding factor for asset commitments.
+ */
+class AssetBlindingFactor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(AssetBlindingFactor.prototype);
+        obj.__wbg_ptr = ptr;
+        AssetBlindingFactorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AssetBlindingFactorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_assetblindingfactor_free(ptr, 0);
+    }
+    /**
+     * Creates an `AssetBlindingFactor` from a string.
+     * @param {string} s
+     * @returns {AssetBlindingFactor}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetblindingfactor_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Creates an `AssetBlindingFactor` from a byte slice.
+     * @param {Uint8Array} bytes
+     * @returns {AssetBlindingFactor}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetblindingfactor_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Returns a zero asset blinding factor.
+     * @returns {AssetBlindingFactor}
+     */
+    static zero() {
+        const ret = wasm.assetblindingfactor_zero();
+        return AssetBlindingFactor.__wrap(ret);
+    }
+    /**
+     * Returns the bytes (32 bytes) in little-endian byte order.
+     *
+     * This is the internal representation used by secp256k1. The byte order is
+     * reversed compared to the hex string representation (which uses big-endian,
+     * following Bitcoin display conventions).
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.assetblindingfactor_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns string representation of the ABF
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.assetblindingfactor_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);
+        }
+    }
+}
+if (Symbol.dispose) AssetBlindingFactor.prototype[Symbol.dispose] = AssetBlindingFactor.prototype.free;
+
+exports.AssetBlindingFactor = AssetBlindingFactor;
+
 const AssetIdFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_assetid_free(ptr >>> 0, 1));
@@ -1199,6 +1298,8 @@ class AssetId {
     }
     /**
      * Creates an `AssetId`
+     *
+     * Deprecated: use `from_string()` instead
      * @param {string} asset_id
      */
     constructor(asset_id) {
@@ -1212,9 +1313,47 @@ class AssetId {
         AssetIdFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Creates an `AssetId` from hex string
+     * @param {string} s
+     * @returns {AssetId}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetid_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetId.__wrap(ret[0]);
+    }
+    /**
+     * Creates an `AssetId` from a bytes.
+     * @param {Uint8Array} bytes
+     * @returns {AssetId}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.assetid_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return AssetId.__wrap(ret[0]);
+    }
+    /**
+     * Returns the `AssetId` bytes in little-endian byte order.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.assetid_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
     /**
      * Return the string representation of the asset identifier (64 hex characters).
-     * This representation can be used to recreate the asset identifier via `new()`
+     * This representation can be used to recreate the asset identifier via `fromString()`
      * @returns {string}
      */
     toString() {
@@ -2175,6 +2314,49 @@ if (Symbol.dispose) ExchangeRates.prototype[Symbol.dispose] = ExchangeRates.prot
 
 exports.ExchangeRates = ExchangeRates;
 
+const ExternalUtxoFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_externalutxo_free(ptr >>> 0, 1));
+/**
+ * An external UTXO, owned by another wallet.
+ */
+class ExternalUtxo {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExternalUtxoFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_externalutxo_free(ptr, 0);
+    }
+    /**
+     * Construct an ExternalUtxo
+     * @param {number} vout
+     * @param {Transaction} tx
+     * @param {TxOutSecrets} unblinded
+     * @param {number} max_weight_to_satisfy
+     * @param {boolean} is_segwit
+     */
+    constructor(vout, tx, unblinded, max_weight_to_satisfy, is_segwit) {
+        _assertClass(tx, Transaction);
+        _assertClass(unblinded, TxOutSecrets);
+        const ret = wasm.externalutxo_new(vout, tx.__wbg_ptr, unblinded.__wbg_ptr, max_weight_to_satisfy, is_segwit);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ExternalUtxoFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) ExternalUtxo.prototype[Symbol.dispose] = ExternalUtxo.prototype.free;
+
+exports.ExternalUtxo = ExternalUtxo;
+
 const InvoiceResponseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_invoiceresponse_free(ptr >>> 0, 1));
@@ -2672,6 +2854,122 @@ if (Symbol.dispose) JadeWebSocket.prototype[Symbol.dispose] = JadeWebSocket.prot
 
 exports.JadeWebSocket = JadeWebSocket;
 
+const JsStoreLinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsstorelink_free(ptr >>> 0, 1));
+/**
+ * A bridge that connects a [`JsStorage`] to [`lwk_common::Store`].
+ */
+class JsStoreLink {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsStoreLinkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsstorelink_free(ptr, 0);
+    }
+    /**
+     * Create a new `JsStoreLink` from a JavaScript storage object.
+     *
+     * The JS object must have `get(key)`, `put(key, value)`, and `remove(key)` methods.
+     * @param {any} storage
+     */
+    constructor(storage) {
+        const ret = wasm.jsstorelink_new(storage);
+        this.__wbg_ptr = ret >>> 0;
+        JsStoreLinkFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) JsStoreLink.prototype[Symbol.dispose] = JsStoreLink.prototype.free;
+
+exports.JsStoreLink = JsStoreLink;
+
+const JsTestStoreFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_jsteststore_free(ptr >>> 0, 1));
+/**
+ * Test helper to verify Rust can read/write through a JS store.
+ */
+class JsTestStore {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        JsTestStoreFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_jsteststore_free(ptr, 0);
+    }
+    /**
+     * Create a new test helper wrapping the given JS storage.
+     * @param {any} storage
+     */
+    constructor(storage) {
+        const ret = wasm.jsteststore_new(storage);
+        this.__wbg_ptr = ret >>> 0;
+        JsTestStoreFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Write a key-value pair to the store.
+     * @param {string} key
+     * @param {Uint8Array} value
+     */
+    write(key, value) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(value, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.jsteststore_write(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Read a value from the store.
+     * @param {string} key
+     * @returns {Uint8Array | undefined}
+     */
+    read(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsteststore_read(this.__wbg_ptr, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v2;
+        if (ret[0] !== 0) {
+            v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v2;
+    }
+    /**
+     * Remove a key from the store.
+     * @param {string} key
+     */
+    remove(key) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.jsteststore_remove(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+if (Symbol.dispose) JsTestStore.prototype[Symbol.dispose] = JsTestStore.prototype.free;
+
+exports.JsTestStore = JsTestStore;
+
 const LastUsedIndexResponseFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_lastusedindexresponse_free(ptr >>> 0, 1));
@@ -3191,6 +3489,22 @@ class Network {
         const ret = wasm.network_policyAsset(this.__wbg_ptr);
         return AssetId.__wrap(ret);
     }
+    /**
+     * Return the genesis block hash for this network as hex string.
+     * @returns {string}
+     */
+    genesisBlockHash() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.network_genesisBlockHash(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);
+        }
+    }
     /**
      * Return the transaction builder for this network
      * @returns {TxBuilder}
@@ -3296,7 +3610,7 @@ class OutPoint {
         wasm.__wbg_outpoint_free(ptr, 0);
     }
     /**
-     * Creates an `OutPoint`
+     * Creates an `OutPoint` from a string representation.
      * @param {string} s
      */
     constructor(s) {
@@ -3310,6 +3624,17 @@ class OutPoint {
         OutPointFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Creates an `OutPoint` from a transaction ID and output index.
+     * @param {Txid} txid
+     * @param {number} vout
+     * @returns {OutPoint}
+     */
+    static fromParts(txid, vout) {
+        _assertClass(txid, Txid);
+        const ret = wasm.outpoint_fromParts(txid.__wbg_ptr, vout);
+        return OutPoint.__wrap(ret);
+    }
     /**
      * Return the transaction identifier.
      * @returns {Txid}
@@ -3810,6 +4135,19 @@ class Pset {
         }
         return Transaction.__wrap(ret[0]);
     }
+    /**
+     * Get the unique id of the PSET as defined by [BIP-370](https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki#unique-identification)
+     *
+     * The unique id is the txid of the PSET with sequence numbers of inputs set to 0
+     * @returns {Txid}
+     */
+    uniqueId() {
+        const ret = wasm.pset_uniqueId(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Txid.__wrap(ret[0]);
+    }
     /**
      * Attempt to merge with another `Pset`.
      * @param {Pset} other
@@ -4035,6 +4373,22 @@ class PsetInput {
         const ret = wasm.psetinput_previousVout(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Prevout scriptpubkey of the input
+     * @returns {Script | undefined}
+     */
+    previousScriptPubkey() {
+        const ret = wasm.psetinput_previousScriptPubkey(this.__wbg_ptr);
+        return ret === 0 ? undefined : Script.__wrap(ret);
+    }
+    /**
+     * Redeem script of the input
+     * @returns {Script | undefined}
+     */
+    redeemScript() {
+        const ret = wasm.psetinput_redeemScript(this.__wbg_ptr);
+        return ret === 0 ? undefined : Script.__wrap(ret);
+    }
     /**
      * If the input has an issuance, the asset id
      * @returns {AssetId | undefined}
@@ -4051,6 +4405,36 @@ class PsetInput {
         const ret = wasm.psetinput_issuanceToken(this.__wbg_ptr);
         return ret === 0 ? undefined : AssetId.__wrap(ret);
     }
+    /**
+     * If the input has a (re)issuance, the issuance object
+     * @returns {Issuance | undefined}
+     */
+    issuance() {
+        const ret = wasm.psetinput_issuance(this.__wbg_ptr);
+        return ret === 0 ? undefined : Issuance.__wrap(ret);
+    }
+    /**
+     * Input sighash
+     * @returns {number}
+     */
+    sighash() {
+        const ret = wasm.psetinput_sighash(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * If the input has an issuance, returns [asset_id, token_id].
+     * Returns undefined if the input has no issuance.
+     * @returns {AssetId[] | undefined}
+     */
+    issuanceIds() {
+        const ret = wasm.psetinput_issuanceIds(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
 }
 if (Symbol.dispose) PsetInput.prototype[Symbol.dispose] = PsetInput.prototype.free;
 
@@ -4084,12 +4468,37 @@ class PsetOutput {
         wasm.__wbg_psetoutput_free(ptr, 0);
     }
     /**
+     * Get the script pubkey
      * @returns {Script}
      */
     scriptPubkey() {
         const ret = wasm.psetoutput_scriptPubkey(this.__wbg_ptr);
         return Script.__wrap(ret);
     }
+    /**
+     * Get the explicit amount, if set
+     * @returns {bigint | undefined}
+     */
+    amount() {
+        const ret = wasm.psetoutput_amount(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * Get the explicit asset ID, if set
+     * @returns {AssetId | undefined}
+     */
+    asset() {
+        const ret = wasm.psetoutput_asset(this.__wbg_ptr);
+        return ret === 0 ? undefined : AssetId.__wrap(ret);
+    }
+    /**
+     * Get the blinder index, if set
+     * @returns {number | undefined}
+     */
+    blinderIndex() {
+        const ret = wasm.psetoutput_blinderIndex(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
 }
 if (Symbol.dispose) PsetOutput.prototype[Symbol.dispose] = PsetOutput.prototype.free;
 
@@ -4517,6 +4926,14 @@ class Script {
         ScriptFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Creates an empty `Script`.
+     * @returns {Script}
+     */
+    static empty() {
+        const ret = wasm.script_empty();
+        return Script.__wrap(ret);
+    }
     /**
      * Return the consensus encoded bytes of the script.
      * @returns {Uint8Array}
@@ -4527,6 +4944,24 @@ class Script {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * Returns SHA256 of the script's consensus bytes.
+     *
+     * Returns an equivalent value to the `jet::input_script_hash(index)`/`jet::output_script_hash(index)`.
+     * @returns {string}
+     */
+    jet_sha256_hex() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.script_jet_sha256_hex(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);
+        }
+    }
     /**
      * Return the string of the script showing op codes and their arguments.
      *
@@ -4545,6 +4980,45 @@ class Script {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Creates an OP_RETURN script with the given data.
+     * @param {Uint8Array} data
+     * @returns {Script}
+     */
+    static newOpReturn(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.script_newOpReturn(ptr0, len0);
+        return Script.__wrap(ret);
+    }
+    /**
+     * Returns true if the script is provably unspendable.
+     *
+     * A script is provably unspendable if it starts with OP_RETURN or is larger
+     * than the maximum script size.
+     * @returns {boolean}
+     */
+    isProvablyUnspendable() {
+        const ret = wasm.script_isProvablyUnspendable(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Returns true if this script_pubkey is provably SegWit.
+     *
+     * This checks if the script_pubkey is provably SegWit based on the
+     * script_pubkey itself and an optional redeem_script.
+     * @param {Script | null} [redeem_script]
+     * @returns {boolean}
+     */
+    isProvablySegwit(redeem_script) {
+        let ptr0 = 0;
+        if (!isLikeNone(redeem_script)) {
+            _assertClass(redeem_script, Script);
+            ptr0 = redeem_script.__destroy_into_raw();
+        }
+        const ret = wasm.script_isProvablySegwit(this.__wbg_ptr, ptr0);
+        return ret !== 0;
+    }
     /**
      * 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()`
@@ -4930,6 +5404,8 @@ class Transaction {
     }
     /**
      * Creates a `Transaction`
+     *
+     * Deprecated: use `fromString()` instead.
      * @param {string} tx_hex
      */
     constructor(tx_hex) {
@@ -4943,6 +5419,34 @@ class Transaction {
         TransactionFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * Creates a `Transaction` from hex-encoded consensus bytes.
+     * @param {string} s
+     * @returns {Transaction}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.transaction_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Transaction.__wrap(ret[0]);
+    }
+    /**
+     * Creates a `Transaction` from consensus-encoded bytes.
+     * @param {Uint8Array} bytes
+     * @returns {Transaction}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.transaction_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Transaction.__wrap(ret[0]);
+    }
     /**
      * Return the transaction identifier.
      * @returns {Txid}
@@ -4955,6 +5459,18 @@ class Transaction {
      * Return the consensus encoded bytes of the transaction.
      * @returns {Uint8Array}
      */
+    toBytes() {
+        const ret = wasm.transaction_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Return the consensus encoded bytes of the transaction.
+     *
+     * Deprecated: use `toBytes()` instead.
+     * @returns {Uint8Array}
+     */
     bytes() {
         const ret = wasm.transaction_bytes(this.__wbg_ptr);
         var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
@@ -5026,7 +5542,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;
@@ -5355,6 +5871,19 @@ class TxOutSecrets {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_txoutsecrets_free(ptr, 0);
     }
+    /**
+     * Creates a new `TxOutSecrets` for an explicit (unblinded) output.
+     *
+     * The blinding factors are set to zero.
+     * @param {AssetId} asset_id
+     * @param {bigint} value
+     * @returns {TxOutSecrets}
+     */
+    static fromExplicit(asset_id, value) {
+        _assertClass(asset_id, AssetId);
+        const ret = wasm.txoutsecrets_fromExplicit(asset_id.__wbg_ptr, value);
+        return TxOutSecrets.__wrap(ret);
+    }
     /**
      * Return the asset of the output.
      * @returns {AssetId}
@@ -5364,20 +5893,12 @@ class TxOutSecrets {
         return AssetId.__wrap(ret);
     }
     /**
-     * Return the asset blinding factor as a hex string.
-     * @returns {string}
+     * Return the asset blinding factor as a typed object.
+     * @returns {AssetBlindingFactor}
      */
     assetBlindingFactor() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.txoutsecrets_assetBlindingFactor(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);
-        }
+        const ret = wasm.txoutsecrets_assetBlindingFactor(this.__wbg_ptr);
+        return AssetBlindingFactor.__wrap(ret);
     }
     /**
      * Return the value of the output.
@@ -5388,20 +5909,12 @@ class TxOutSecrets {
         return BigInt.asUintN(64, ret);
     }
     /**
-     * Return the value blinding factor as a hex string.
-     * @returns {string}
+     * Return the value blinding factor as a typed object.
+     * @returns {ValueBlindingFactor}
      */
     valueBlindingFactor() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.txoutsecrets_valueBlindingFactor(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);
-        }
+        const ret = wasm.txoutsecrets_valueBlindingFactor(this.__wbg_ptr);
+        return ValueBlindingFactor.__wrap(ret);
     }
     /**
      * Return true if the output is explicit (no blinding factors).
@@ -5814,6 +6327,104 @@ if (Symbol.dispose) ValidatedLiquidexProposal.prototype[Symbol.dispose] = Valida
 
 exports.ValidatedLiquidexProposal = ValidatedLiquidexProposal;
 
+const ValueBlindingFactorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_valueblindingfactor_free(ptr >>> 0, 1));
+/**
+ * A blinding factor for value commitments.
+ */
+class ValueBlindingFactor {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ValueBlindingFactor.prototype);
+        obj.__wbg_ptr = ptr;
+        ValueBlindingFactorFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ValueBlindingFactorFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_valueblindingfactor_free(ptr, 0);
+    }
+    /**
+     * Creates a `ValueBlindingFactor` from a string.
+     * @param {string} s
+     * @returns {ValueBlindingFactor}
+     */
+    static fromString(s) {
+        const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.valueblindingfactor_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ValueBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Creates a `ValueBlindingFactor` from a byte slice.
+     * @param {Uint8Array} bytes
+     * @returns {ValueBlindingFactor}
+     */
+    static fromBytes(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.valueblindingfactor_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ValueBlindingFactor.__wrap(ret[0]);
+    }
+    /**
+     * Returns a zero value blinding factor.
+     * @returns {ValueBlindingFactor}
+     */
+    static zero() {
+        const ret = wasm.valueblindingfactor_zero();
+        return ValueBlindingFactor.__wrap(ret);
+    }
+    /**
+     * Returns the bytes (32 bytes) in little-endian byte order.
+     *
+     * This is the internal representation used by secp256k1. The byte order is
+     * reversed compared to the hex string representation (which uses big-endian,
+     * following Bitcoin display conventions).
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        const ret = wasm.valueblindingfactor_toBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Returns string representation of the VBF
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.valueblindingfactor_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);
+        }
+    }
+}
+if (Symbol.dispose) ValueBlindingFactor.prototype[Symbol.dispose] = ValueBlindingFactor.prototype.free;
+
+exports.ValueBlindingFactor = ValueBlindingFactor;
+
 const WalletTxFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wallettx_free(ptr >>> 0, 1));
@@ -6590,6 +7201,11 @@ exports.__wbg_arrayBuffer_9c99b8e2809e8cbb = function() { return handleError(fun
     return ret;
 }, arguments) };
 
+exports.__wbg_assetid_new = function(arg0) {
+    const ret = AssetId.__wrap(arg0);
+    return ret;
+};
+
 exports.__wbg_assetmeta_new = function(arg0) {
     const ret = AssetMeta.__wrap(arg0);
     return ret;
@@ -6717,6 +7333,14 @@ exports.__wbg_get_0da715ceaecea5c8 = function(arg0, arg1) {
     return ret;
 };
 
+exports.__wbg_get_39bedfef9433a446 = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = arg1.get(getStringFromWasm0(arg2, arg3));
+    var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}, arguments) };
+
 exports.__wbg_get_458e874b43b18b25 = function() { return handleError(function (arg0, arg1) {
     const ret = Reflect.get(arg0, arg1);
     return ret;
@@ -6848,7 +7472,7 @@ exports.__wbg_length_6bb7e81f9d7713e4 = function(arg0) {
     return ret;
 };
 
-exports.__wbg_log_d1e4a0ea206b998f = function(arg0, arg1) {
+exports.__wbg_log_56ce8a47744d4384 = function(arg0, arg1) {
     console.log(getStringFromWasm0(arg0, arg1));
 };
 
@@ -6884,7 +7508,7 @@ exports.__wbg_new_2e3c58a15f39f5f9 = function(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_647(a, state0.b, arg0, arg1);
+                return __wbg_adapter_694(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -7055,6 +7679,10 @@ exports.__wbg_push_330b2eb93e4e1212 = function(arg0, arg1) {
     return ret;
 };
 
+exports.__wbg_put_fe176894adb408a3 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    arg0.put(getStringFromWasm0(arg1, arg2), getArrayU8FromWasm0(arg3, arg4));
+}, arguments) };
+
 exports.__wbg_queueMicrotask_25d0739ac89e8c88 = function(arg0) {
     queueMicrotask(arg0);
 };
@@ -7101,6 +7729,10 @@ exports.__wbg_registry_new = function(arg0) {
     return ret;
 };
 
+exports.__wbg_remove_730839cfb0946c97 = function() { return handleError(function (arg0, arg1, arg2) {
+    arg0.remove(getStringFromWasm0(arg1, arg2));
+}, arguments) };
+
 exports.__wbg_requestDevice_225891d9a80a7b19 = function(arg0, arg1) {
     const ret = arg0.requestDevice(arg1);
     return ret;
@@ -7434,15 +8066,9 @@ exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
     return ret;
 };
 
-exports.__wbindgen_cast_226189b342a397fe = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1332, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1333, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1332, __wbg_adapter_12);
-    return ret;
-};
-
-exports.__wbindgen_cast_29502e455aa89f54 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1470, function: Function { arguments: [], shim_idx: 1471, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1470, __wbg_adapter_19);
+exports.__wbindgen_cast_257f3a138b297868 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1351, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1352, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1351, __wbg_adapter_15);
     return ret;
 };
 
@@ -7452,21 +8078,15 @@ exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
     return ret;
 };
 
-exports.__wbindgen_cast_64946e166c77d13b = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1332, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1333, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1332, __wbg_adapter_12);
-    return ret;
-};
-
-exports.__wbindgen_cast_8498ce9f6d02ec68 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1952, function: Function { arguments: [Externref], shim_idx: 1963, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1952, __wbg_adapter_25);
+exports.__wbindgen_cast_502ef75e0c858dae = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1988, function: Function { arguments: [Externref], shim_idx: 1999, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1988, __wbg_adapter_24);
     return ret;
 };
 
-exports.__wbindgen_cast_8e4b3b9f090f0e9f = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 836, function: Function { arguments: [NamedExternref("HIDInputReportEvent")], shim_idx: 793, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 836, __wbg_adapter_30);
+exports.__wbindgen_cast_8b5320884bc68146 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1493, function: Function { arguments: [], shim_idx: 1494, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1493, __wbg_adapter_12);
     return ret;
 };
 
@@ -7476,21 +8096,9 @@ exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
     return ret;
 };
 
-exports.__wbindgen_cast_a5eca9837d7a56d8 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1332, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 1333, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1332, __wbg_adapter_12);
-    return ret;
-};
-
-exports.__wbindgen_cast_c7181fb9120fd364 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1332, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 1333, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1332, __wbg_adapter_12);
-    return ret;
-};
-
-exports.__wbindgen_cast_c8d7b74f3f2593d8 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 1915, function: Function { arguments: [], shim_idx: 1916, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, 1915, __wbg_adapter_22);
+exports.__wbindgen_cast_c00b3b75575ef5a8 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1351, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1352, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1351, __wbg_adapter_15);
     return ret;
 };
 
@@ -7500,12 +8108,36 @@ exports.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
     return ret;
 };
 
+exports.__wbindgen_cast_d13e729c37297ac9 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1351, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 1352, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1351, __wbg_adapter_15);
+    return ret;
+};
+
 exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;
     return ret;
 };
 
+exports.__wbindgen_cast_db7bbe564cc094a2 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1953, function: Function { arguments: [], shim_idx: 1954, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1953, __wbg_adapter_34);
+    return ret;
+};
+
+exports.__wbindgen_cast_f36c9415fb8ff7bb = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 671, function: Function { arguments: [NamedExternref("HIDInputReportEvent")], shim_idx: 804, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 671, __wbg_adapter_31);
+    return ret;
+};
+
+exports.__wbindgen_cast_f944d0f89d71242c = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1351, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 1352, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, 1351, __wbg_adapter_15);
+    return ret;
+};
+
 exports.__wbindgen_init_externref_table = function() {
     const table = wasm.__wbindgen_export_4;
     const offset = table.grow(4);