@nockbox/iris-wasm 0.2.0-alpha.2 → 0.2.0-alpha.4

package/iris_wasm.js

@@ -1,5 +1,72 @@
 let wasm;
 
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+let WASM_VECTOR_LEN = 0;
+
 let cachedUint8ArrayMemory0 = null;
 
 function getUint8ArrayMemory0() {
@@ -9,29 +76,6 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let WASM_VECTOR_LEN = 0;
-
 const cachedTextEncoder = new TextEncoder();
 
 if (!('encodeInto' in cachedTextEncoder)) {
@@ -97,69 +141,25 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
     }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
 }
 
 function addToExternrefTable0(obj) {
@@ -214,189 +214,121 @@ 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_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(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 takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_externrefs.get(idx);
     wasm.__externref_table_dealloc(idx);
     return value;
 }
+
+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 _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
 /**
- * @param {Noun} noun
- * @returns {Uint8Array}
+ * Convert native SpendCondition to protobuf format.
+ * Returns the protobuf format used by the Nockchain gRPC interface and external dApps.
+ * @param {SpendCondition} value
+ * @returns {PbCom2SpendCondition}
  */
-export function jam(noun) {
-    const ret = wasm.jam(noun);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
+export function spendConditionToProtobuf(value) {
+    const ret = wasm.spendConditionToProtobuf(value);
+    return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {string}
+ * @param {Digest} d
+ * @returns {PbCom1Hash}
  */
-export function untas(noun) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-        const ret = wasm.untas(noun);
-        var ptr1 = ret[0];
-        var len1 = ret[1];
-        if (ret[3]) {
-            ptr1 = 0; len1 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred2_0 = ptr1;
-        deferred2_1 = len1;
-        return getStringFromWasm0(ptr1, len1);
-    } finally {
-        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-    }
+export function digestToProtobuf(d) {
+    const ret = wasm.digestToProtobuf(d);
+    return ret;
 }
 
 /**
- * @param {string} s
- * @returns {Noun}
+ * @param {Note} note
+ * @returns {PbCom2Note}
  */
-export function tas_belts(s) {
-    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.tas_belts(ptr0, len0);
+export function noteToProtobuf(note) {
+    const ret = wasm.noteToProtobuf(note);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {Noun}
+ * @param {PbCom1Hash} value
+ * @returns {Digest}
  */
-export function belts_to_atom(noun) {
-    const ret = wasm.belts_to_atom(noun);
+export function digestFromProtobuf(value) {
+    const ret = wasm.digestFromProtobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
 /**
- * @param {Uint8Array} jam
- * @returns {Noun}
+ * Return default transaction engine settings for V1 signing.
+ * @returns {TxEngineSettings}
  */
-export function cue(jam) {
-    const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.cue(ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function txEngineSettingsV1Default() {
+    const ret = wasm.txEngineSettingsV1Default();
+    return ret;
 }
 
 /**
- * @param {Noun} atom
- * @returns {Noun}
+ * Convert protobuf spend condition to native SpendCondition.
+ * Accepts the protobuf format used by the Nockchain gRPC interface and external dApps
+ * @param {PbCom2SpendCondition} value
+ * @returns {SpendCondition}
  */
-export function atom_to_belts(atom) {
-    const ret = wasm.atom_to_belts(atom);
+export function spendConditionFromProtobuf(value) {
+    const ret = wasm.spendConditionFromProtobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {string} s
- * @returns {Noun}
- */
-export function tas(s) {
-    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.tas(ptr0, len0);
-    return ret;
-}
-
-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_externrefs.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
-
-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 _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-/**
- * @param {Digest} d
- * @returns {string}
- */
-export function digest_to_hex(d) {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const ret = wasm.digest_to_hex(d);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
 /**
  * @param {PbCom2Note} value
  * @returns {Note}
  */
-export function note_from_protobuf(value) {
-    const ret = wasm.note_from_protobuf(value);
+export function noteFromProtobuf(value) {
+    const ret = wasm.noteFromProtobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {RawTxV1} tx
- * @returns {NockchainTx}
- */
-export function rawTxToNockchainTx(tx) {
-    const ret = wasm.rawTxToNockchainTx(tx);
-    return ret;
-}
-
-/**
- * @param {RawTx} tx
- * @returns {Note[]}
- */
-export function rawTxOutputs(tx) {
-    const ret = wasm.rawTxOutputs(tx);
-    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-    return v1;
-}
-
 /**
  * @param {PbCom2RawTransaction} tx
  * @returns {RawTx}
@@ -410,47 +342,61 @@ export function rawTxFromProtobuf(tx) {
 }
 
 /**
- * @param {Note} note
- * @returns {PbCom2Note}
+ * Convert raw transaction into protobuf format.
+ *
+ * Protobuf format is the one used by the Nockchain's gRPC interface, and the initial iris
+ * extension format. The new iris transaction signing API moves away from this format to use
+ * `NockchainTx`, as it includes the necessary spend condition and note information.
+ * @param {RawTxV1} tx
+ * @returns {PbCom2RawTransaction}
  */
-export function note_to_protobuf(note) {
-    const ret = wasm.note_to_protobuf(note);
+export function rawTxToProtobuf(tx) {
+    const ret = wasm.rawTxToProtobuf(tx);
     return ret;
 }
 
 /**
- * @param {Version} version
- * @param {number} origin_page
- * @param {Name} name
- * @param {NoteData} note_data
- * @param {Nicks} assets
- * @returns {Note}
+ * Return default transaction engine settings for V1 Bythos signing.
+ * @returns {TxEngineSettings}
  */
-export function create_note_v1(version, origin_page, name, note_data, assets) {
-    const ret = wasm.create_note_v1(version, origin_page, name, note_data, assets);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function txEngineSettingsV1BythosDefault() {
+    const ret = wasm.txEngineSettingsV1BythosDefault();
+    return ret;
 }
 
 /**
- * @param {Note} note
- * @returns {Digest}
+ * Convert an Atom into a string.
+ * @param {Noun} noun
+ * @returns {string}
  */
-export function note_hash(note) {
-    const ret = wasm.note_hash(note);
-    return ret;
+export function untas(noun) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.untas(noun);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
 }
 
 /**
- * @param {string} s
- * @returns {Digest}
+ * Cue a jammed Uint8Array into a Noun (see `jam`).
+ * @param {Uint8Array} jam
+ * @returns {Noun}
  */
-export function hex_to_digest(s) {
-    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function cue(jam) {
+    const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.hex_to_digest(ptr0, len0);
+    const ret = wasm.cue(ptr0, len0);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -458,19 +404,12 @@ export function hex_to_digest(s) {
 }
 
 /**
- * @param {number} origin_page
- * @param {bigint} sig_m
- * @param {Uint8Array[]} sig_pubkeys
- * @param {Digest} source_hash
- * @param {boolean} is_coinbase
- * @param {Timelock | null | undefined} timelock
- * @param {Nicks} assets
- * @returns {Note}
+ * Convert a sequence of belts back into one atom.
+ * @param {Noun} noun
+ * @returns {Noun}
  */
-export function create_note_v0(origin_page, sig_m, sig_pubkeys, source_hash, is_coinbase, timelock, assets) {
-    const ptr0 = passArrayJsValueToWasm0(sig_pubkeys, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.create_note_v0(origin_page, sig_m, ptr0, len0, source_hash, is_coinbase, isLikeNone(timelock) ? 0 : addToExternrefTable0(timelock), assets);
+export function belts_to_atom(noun) {
+    const ret = wasm.belts_to_atom(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -478,20 +417,27 @@ export function create_note_v0(origin_page, sig_m, sig_pubkeys, source_hash, is_
 }
 
 /**
- * @param {RawTxV1} tx
- * @returns {PbCom2RawTransaction}
+ * Encode a Noun as a Uint8Array of bytes.
+ * @param {Noun} noun
+ * @returns {Uint8Array}
  */
-export function rawTxToProtobuf(tx) {
-    const ret = wasm.rawTxToProtobuf(tx);
-    return ret;
+export function jam(noun) {
+    const ret = wasm.jam(noun);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
 }
 
 /**
- * @param {PbCom1Hash} value
- * @returns {Digest}
+ * Convert an Atom to belts.
+ * @param {Noun} atom
+ * @returns {Noun}
  */
-export function digest_from_protobuf(value) {
-    const ret = wasm.digest_from_protobuf(value);
+export function atom_to_belts(atom) {
+    const ret = wasm.atom_to_belts(atom);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -499,23 +445,47 @@ export function digest_from_protobuf(value) {
 }
 
 /**
- * @param {Digest} d
- * @returns {PbCom1Hash}
+ * Convert string to an Atom.
+ * @param {string} s
+ * @returns {Noun}
  */
-export function digest_to_protobuf(d) {
-    const ret = wasm.digest_to_protobuf(d);
+export function tas(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.tas(ptr0, len0);
     return ret;
 }
 
 /**
- * @param {NockchainTx} tx
- * @returns {RawTx}
+ * Convert a string to sequence of Belts.
+ *
+ * This is equivalent to `atom_to_belts(tas(s))`.
+ *
+ * Belts are Atoms that fit the goldilocks prime field.
+ *
+ * If a transaction contains non-based (not-fitting) atoms, it will be rejected.
+ * @param {string} s
+ * @returns {Noun}
  */
-export function nockchainTxToRaw(tx) {
-    const ret = wasm.nockchainTxToRaw(tx);
+export function tas_belts(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.tas_belts(ptr0, len0);
     return ret;
 }
 
+/**
+ * Derive master key from seed bytes
+ * @param {Uint8Array} seed
+ * @returns {ExtendedKey}
+ */
+export function deriveMasterKey(seed) {
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveMasterKey(ptr0, len0);
+    return ExtendedKey.__wrap(ret);
+}
+
 /**
  * Sign a message string with a private key
  * @param {Uint8Array} private_key_bytes
@@ -535,35 +505,36 @@ export function signMessage(private_key_bytes, message) {
 }
 
 /**
- * Derive master key from BIP39 mnemonic phrase
- * @param {string} mnemonic
- * @param {string | null} [passphrase]
- * @returns {ExtendedKey}
+ * Verify a signature with a public key
+ * @param {Uint8Array} public_key_bytes
+ * @param {Signature} signature
+ * @param {string} message
+ * @returns {boolean}
  */
-export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
-    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function verifySignature(public_key_bytes, signature, message) {
+    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len1 = WASM_VECTOR_LEN;
-    const ret = wasm.deriveMasterKeyFromMnemonic(ptr0, len0, ptr1, len1);
+    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.verifySignature(ptr0, len0, signature, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ExtendedKey.__wrap(ret[0]);
+    return ret[0] !== 0;
 }
 
 /**
- * Hash a public key to get its digest (for use in PKH)
- * @param {Uint8Array} public_key_bytes
+ * Hash a noun (jam as input)
+ * @param {Uint8Array} noun
  * @returns {string}
  */
-export function hashPublicKey(public_key_bytes) {
+export function hashNoun(noun) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
+        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashPublicKey(ptr0, len0);
+        const ret = wasm.hashNoun(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -578,25 +549,6 @@ export function hashPublicKey(public_key_bytes) {
     }
 }
 
-/**
- * Verify a signature with a public key
- * @param {Uint8Array} public_key_bytes
- * @param {Signature} signature
- * @param {string} message
- * @returns {boolean}
- */
-export function verifySignature(public_key_bytes, signature, message) {
-    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.verifySignature(ptr0, len0, signature, ptr1, len1);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return ret[0] !== 0;
-}
-
 /**
  * Hash a u64 value
  * @param {bigint} value
@@ -616,29 +568,35 @@ export function hashU64(value) {
 }
 
 /**
- * Derive master key from seed bytes
- * @param {Uint8Array} seed
+ * Derive master key from BIP39 mnemonic phrase
+ * @param {string} mnemonic
+ * @param {string | null} [passphrase]
  * @returns {ExtendedKey}
  */
-export function deriveMasterKey(seed) {
-    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.deriveMasterKey(ptr0, len0);
-    return ExtendedKey.__wrap(ret);
+    var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveMasterKeyFromMnemonic(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ExtendedKey.__wrap(ret[0]);
 }
 
 /**
- * Hash a noun (jam as input)
- * @param {Uint8Array} noun
+ * Hash a public key to get its digest (for use in PKH)
+ * @param {Uint8Array} public_key_bytes
  * @returns {string}
  */
-export function hashNoun(noun) {
+export function hashPublicKey(public_key_bytes) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashNoun(ptr0, len0);
+        const ret = wasm.hashPublicKey(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -654,20 +612,44 @@ export function hashNoun(noun) {
 }
 
 /**
- * @param {Input} v
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {SeedV0}
+ */
+export function seedV0FromNoun(noun) {
+    const ret = wasm.seedV0FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {SeedV0} v
  * @returns {Digest}
  */
-export function inputHash(v) {
-    const ret = wasm.inputHash(v);
+export function seedV0Hash(v) {
+    const ret = wasm.seedV0Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
+ * @param {SeedV0} v
+ * @returns {Noun}
+ */
+export function seedV0ToNoun(v) {
+    const ret = wasm.seedV0ToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Input}
+ * @returns {RawTxV0}
  */
-export function inputFromNoun(noun) {
-    const ret = wasm.inputFromNoun(noun);
+export function rawTxV0FromNoun(noun) {
+    const ret = wasm.rawTxV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -675,38 +657,41 @@ export function inputFromNoun(noun) {
 }
 
 /**
- * @param {Input} v
+ * r" Convert into `Noun`.
+ * @param {RawTxV0} v
  * @returns {Noun}
  */
-export function inputToNoun(v) {
-    const ret = wasm.inputToNoun(v);
+export function rawTxV0ToNoun(v) {
+    const ret = wasm.rawTxV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Inputs} v
+ * r" Convert into `Noun`.
+ * @param {TimelockIntent} v
  * @returns {Noun}
  */
-export function inputsToNoun(v) {
-    const ret = wasm.inputsToNoun(v);
+export function timelockIntentToNoun(v) {
+    const ret = wasm.timelockIntentToNoun(v);
     return ret;
 }
 
 /**
- * @param {Inputs} v
+ * @param {TimelockIntent} v
  * @returns {Digest}
  */
-export function inputsHash(v) {
-    const ret = wasm.inputsHash(v);
+export function timelockIntentHash(v) {
+    const ret = wasm.timelockIntentHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Inputs}
+ * @returns {TimelockIntent}
  */
-export function inputsFromNoun(noun) {
-    const ret = wasm.inputsFromNoun(noun);
+export function timelockIntentFromNoun(noun) {
+    const ret = wasm.timelockIntentFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -714,20 +699,66 @@ export function inputsFromNoun(noun) {
 }
 
 /**
- * @param {SeedsV0} v
+ * @param {Pkh} pkh
+ * @returns {NoteData}
+ */
+export function noteDataFromPkh(pkh) {
+    const ret = wasm.noteDataFromPkh(pkh);
+    return ret;
+}
+
+/**
+ * @returns {NoteData}
+ */
+export function noteDataEmpty() {
+    const ret = wasm.noteDataEmpty();
+    return ret;
+}
+
+/**
+ * @param {NoteData} obj
+ * @returns {bigint}
+ */
+export function noteDataFeeWords(obj) {
+    const ret = wasm.noteDataFeeWords(obj);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {Spend1V1} obj
+ * @returns {Digest}
+ */
+export function spend1V1SigHash(obj) {
+    const ret = wasm.spend1V1SigHash(obj);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {LockMetadata} v
  * @returns {Noun}
  */
-export function seedsV0ToNoun(v) {
-    const ret = wasm.seedsV0ToNoun(v);
+export function lockMetadataToNoun(v) {
+    const ret = wasm.lockMetadataToNoun(v);
     return ret;
 }
 
 /**
+ * @param {LockMetadata} v
+ * @returns {Digest}
+ */
+export function lockMetadataHash(v) {
+    const ret = wasm.lockMetadataHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedsV0}
+ * @returns {LockMetadata}
  */
-export function seedsV0FromNoun(noun) {
-    const ret = wasm.seedsV0FromNoun(noun);
+export function lockMetadataFromNoun(noun) {
+    const ret = wasm.lockMetadataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -735,20 +766,44 @@ export function seedsV0FromNoun(noun) {
 }
 
 /**
- * @param {SeedsV0} v
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {LockPrimitive}
+ */
+export function lockPrimitiveFromNoun(noun) {
+    const ret = wasm.lockPrimitiveFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {LockPrimitive} v
+ * @returns {Noun}
+ */
+export function lockPrimitiveToNoun(v) {
+    const ret = wasm.lockPrimitiveToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {LockPrimitive} v
  * @returns {Digest}
  */
-export function seedsV0Hash(v) {
-    const ret = wasm.seedsV0Hash(v);
+export function lockPrimitiveHash(v) {
+    const ret = wasm.lockPrimitiveHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendV0}
+ * @returns {Name}
  */
-export function spendV0FromNoun(noun) {
-    const ret = wasm.spendV0FromNoun(noun);
+export function nameFromNoun(noun) {
+    const ret = wasm.nameFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -756,38 +811,50 @@ export function spendV0FromNoun(noun) {
 }
 
 /**
- * @param {SpendV0} v
+ * r" Convert into `Noun`.
+ * @param {Name} v
  * @returns {Noun}
  */
-export function spendV0ToNoun(v) {
-    const ret = wasm.spendV0ToNoun(v);
+export function nameToNoun(v) {
+    const ret = wasm.nameToNoun(v);
     return ret;
 }
 
 /**
- * @param {SpendV0} v
+ * @param {Name} v
  * @returns {Digest}
  */
-export function spendV0Hash(v) {
-    const ret = wasm.spendV0Hash(v);
+export function nameHash(v) {
+    const ret = wasm.nameHash(v);
     return ret;
 }
 
 /**
- * @param {NoteInner} v
+ * @param {Hax} v
  * @returns {Digest}
  */
-export function noteInnerHash(v) {
-    const ret = wasm.noteInnerHash(v);
+export function haxHash(v) {
+    const ret = wasm.haxHash(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
+ * @param {Hax} v
+ * @returns {Noun}
+ */
+export function haxToNoun(v) {
+    const ret = wasm.haxToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteInner}
+ * @returns {Hax}
  */
-export function noteInnerFromNoun(noun) {
-    const ret = wasm.noteInnerFromNoun(noun);
+export function haxFromNoun(noun) {
+    const ret = wasm.haxFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -795,20 +862,31 @@ export function noteInnerFromNoun(noun) {
 }
 
 /**
- * @param {NoteInner} v
+ * r" Convert into `Noun`.
+ * @param {Pkh} v
  * @returns {Noun}
  */
-export function noteInnerToNoun(v) {
-    const ret = wasm.noteInnerToNoun(v);
+export function pkhToNoun(v) {
+    const ret = wasm.pkhToNoun(v);
     return ret;
 }
 
 /**
+ * @param {Pkh} v
+ * @returns {Digest}
+ */
+export function pkhHash(v) {
+    const ret = wasm.pkhHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Hax}
+ * @returns {Pkh}
  */
-export function haxFromNoun(noun) {
-    const ret = wasm.haxFromNoun(noun);
+export function pkhFromNoun(noun) {
+    const ret = wasm.pkhFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -816,47 +894,176 @@ export function haxFromNoun(noun) {
 }
 
 /**
- * @param {Hax} v
+ * @param {Digest} hash
+ * @returns {Pkh}
+ */
+export function pkhSingle(hash) {
+    const ret = wasm.pkhSingle(hash);
+    return ret;
+}
+
+/**
+ * @param {bigint} m
+ * @param {Digest[]} hashes
+ * @returns {Pkh}
+ */
+export function pkhNew(m, hashes) {
+    const ptr0 = passArrayJsValueToWasm0(hashes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.pkhNew(m, ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {SpendCondition} v
  * @returns {Digest}
  */
-export function haxHash(v) {
-    const ret = wasm.haxHash(v);
+export function spendConditionHash(v) {
+    const ret = wasm.spendConditionHash(v);
     return ret;
 }
 
 /**
- * @param {Hax} v
+ * r" Convert into `Noun`.
+ * @param {SpendCondition} v
  * @returns {Noun}
  */
-export function haxToNoun(v) {
-    const ret = wasm.haxToNoun(v);
+export function spendConditionToNoun(v) {
+    const ret = wasm.spendConditionToNoun(v);
     return ret;
 }
 
 /**
- * @param {NoteV1} v
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {SpendCondition}
+ */
+export function spendConditionFromNoun(noun) {
+    const ret = wasm.spendConditionFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Pkh} pkh
+ * @returns {SpendCondition}
+ */
+export function spendConditionNewPkh(pkh) {
+    const ret = wasm.spendConditionNewPkh(pkh);
+    return ret;
+}
+
+/**
+ * @param {SpendCondition} obj
+ * @returns {Hax[]}
+ */
+export function spendConditionHax(obj) {
+    const ret = wasm.spendConditionHax(obj);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * @param {SpendCondition} obj
  * @returns {Digest}
  */
-export function noteV1Hash(v) {
-    const ret = wasm.noteV1Hash(v);
+export function spendConditionFirstName(obj) {
+    const ret = wasm.spendConditionFirstName(obj);
     return ret;
 }
 
 /**
- * @param {NoteV1} v
+ * @param {SpendCondition} obj
+ * @returns {Pkh[]}
+ */
+export function spendConditionPkh(obj) {
+    const ret = wasm.spendConditionPkh(obj);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * @param {SpendCondition} obj
+ * @returns {boolean}
+ */
+export function spendConditionBrn(obj) {
+    const ret = wasm.spendConditionBrn(obj);
+    return ret !== 0;
+}
+
+/**
+ * @param {SpendCondition} obj
+ * @returns {Timelock[]}
+ */
+export function spendConditionTim(obj) {
+    const ret = wasm.spendConditionTim(obj);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Source}
+ */
+export function sourceFromNoun(noun) {
+    const ret = wasm.sourceFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Source} v
+ * @returns {Digest}
+ */
+export function sourceHash(v) {
+    const ret = wasm.sourceHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {Source} v
  * @returns {Noun}
  */
-export function noteV1ToNoun(v) {
-    const ret = wasm.noteV1ToNoun(v);
+export function sourceToNoun(v) {
+    const ret = wasm.sourceToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {TimelockRange} v
+ * @returns {Digest}
+ */
+export function timelockRangeHash(v) {
+    const ret = wasm.timelockRangeHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {TimelockRange} v
+ * @returns {Noun}
+ */
+export function timelockRangeToNoun(v) {
+    const ret = wasm.timelockRangeToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteV1}
+ * @returns {TimelockRange}
  */
-export function noteV1FromNoun(noun) {
-    const ret = wasm.noteV1FromNoun(noun);
+export function timelockRangeFromNoun(noun) {
+    const ret = wasm.timelockRangeFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -864,20 +1071,50 @@ export function noteV1FromNoun(noun) {
 }
 
 /**
- * @param {SeedV1} v
+ * @param {RawTx} obj
+ * @returns {Version}
+ */
+export function rawTxVersion(obj) {
+    const ret = wasm.rawTxVersion(obj);
+    return ret;
+}
+
+/**
+ * @param {RawTx} obj
  * @returns {Digest}
  */
-export function seedV1Hash(v) {
-    const ret = wasm.seedV1Hash(v);
+export function rawTxId(obj) {
+    const ret = wasm.rawTxId(obj);
     return ret;
 }
 
 /**
+ * @param {RawTx} obj
+ * @returns {Note[]}
+ */
+export function rawTxOutputs(obj) {
+    const ret = wasm.rawTxOutputs(obj);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
+}
+
+/**
+ * @param {Input} v
+ * @returns {Digest}
+ */
+export function inputHash(v) {
+    const ret = wasm.inputHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedV1}
+ * @returns {Input}
  */
-export function seedV1FromNoun(noun) {
-    const ret = wasm.seedV1FromNoun(noun);
+export function inputFromNoun(noun) {
+    const ret = wasm.inputFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -885,38 +1122,105 @@ export function seedV1FromNoun(noun) {
 }
 
 /**
- * @param {SeedV1} v
+ * r" Convert into `Noun`.
+ * @param {Input} v
  * @returns {Noun}
  */
-export function seedV1ToNoun(v) {
-    const ret = wasm.seedV1ToNoun(v);
+export function inputToNoun(v) {
+    const ret = wasm.inputToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {Inputs} v
+ * @returns {Digest}
+ */
+export function inputsHash(v) {
+    const ret = wasm.inputsHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Inputs}
+ */
+export function inputsFromNoun(noun) {
+    const ret = wasm.inputsFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {Inputs} v
+ * @returns {Noun}
+ */
+export function inputsToNoun(v) {
+    const ret = wasm.inputsToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {SeedsV0}
+ */
+export function seedsV0FromNoun(noun) {
+    const ret = wasm.seedsV0FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {SeedsV0} v
+ * @returns {Noun}
+ */
+export function seedsV0ToNoun(v) {
+    const ret = wasm.seedsV0ToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {SeedsV0} v
+ * @returns {Digest}
+ */
+export function seedsV0Hash(v) {
+    const ret = wasm.seedsV0Hash(v);
     return ret;
 }
 
 /**
- * @param {Witness} v
+ * @param {SpendV0} v
  * @returns {Digest}
  */
-export function witnessHash(v) {
-    const ret = wasm.witnessHash(v);
+export function spendV0Hash(v) {
+    const ret = wasm.spendV0Hash(v);
     return ret;
 }
 
 /**
- * @param {Witness} v
+ * r" Convert into `Noun`.
+ * @param {SpendV0} v
  * @returns {Noun}
  */
-export function witnessToNoun(v) {
-    const ret = wasm.witnessToNoun(v);
+export function spendV0ToNoun(v) {
+    const ret = wasm.spendV0ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Witness}
+ * @returns {SpendV0}
  */
-export function witnessFromNoun(noun) {
-    const ret = wasm.witnessFromNoun(noun);
+export function spendV0FromNoun(noun) {
+    const ret = wasm.spendV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -924,29 +1228,31 @@ export function witnessFromNoun(noun) {
 }
 
 /**
- * @param {SeedsV1} v
+ * @param {Timelock} v
  * @returns {Digest}
  */
-export function seedsV1Hash(v) {
-    const ret = wasm.seedsV1Hash(v);
+export function timelockHash(v) {
+    const ret = wasm.timelockHash(v);
     return ret;
 }
 
 /**
- * @param {SeedsV1} v
+ * r" Convert into `Noun`.
+ * @param {Timelock} v
  * @returns {Noun}
  */
-export function seedsV1ToNoun(v) {
-    const ret = wasm.seedsV1ToNoun(v);
+export function timelockToNoun(v) {
+    const ret = wasm.timelockToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedsV1}
+ * @returns {Timelock}
  */
-export function seedsV1FromNoun(noun) {
-    const ret = wasm.seedsV1FromNoun(noun);
+export function timelockFromNoun(noun) {
+    const ret = wasm.timelockFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -954,20 +1260,22 @@ export function seedsV1FromNoun(noun) {
 }
 
 /**
- * @param {SpendV1} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {LegacySignature} v
+ * @returns {Noun}
  */
-export function spendV1Hash(v) {
-    const ret = wasm.spendV1Hash(v);
+export function legacySignatureToNoun(v) {
+    const ret = wasm.legacySignatureToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendV1}
+ * @returns {LegacySignature}
  */
-export function spendV1FromNoun(noun) {
-    const ret = wasm.spendV1FromNoun(noun);
+export function legacySignatureFromNoun(noun) {
+    const ret = wasm.legacySignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -975,44 +1283,14 @@ export function spendV1FromNoun(noun) {
 }
 
 /**
- * @param {SpendV1} v
- * @returns {Noun}
- */
-export function spendV1ToNoun(v) {
-    const ret = wasm.spendV1ToNoun(v);
-    return ret;
-}
-
-/**
- * @param {LockRoot} v
- * @returns {Noun}
- */
-export function lockRootToNoun(v) {
-    const ret = wasm.lockRootToNoun(v);
-    return ret;
-}
-
-/**
- * @param {LockRoot} v
+ * @param {LegacySignature} v
  * @returns {Digest}
  */
-export function lockRootHash(v) {
-    const ret = wasm.lockRootHash(v);
+export function legacySignatureHash(v) {
+    const ret = wasm.legacySignatureHash(v);
     return ret;
 }
 
-/**
- * @param {Noun} noun
- * @returns {LockRoot}
- */
-export function lockRootFromNoun(noun) {
-    const ret = wasm.lockRootFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
 /**
  * @param {NoteData} v
  * @returns {Digest}
@@ -1023,6 +1301,7 @@ export function noteDataHash(v) {
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {NoteData} v
  * @returns {Noun}
  */
@@ -1032,6 +1311,7 @@ export function noteDataToNoun(v) {
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
  * @returns {NoteData}
  */
@@ -1044,6 +1324,7 @@ export function noteDataFromNoun(noun) {
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {RawTxV1} v
  * @returns {Noun}
  */
@@ -1053,6 +1334,7 @@ export function rawTxV1ToNoun(v) {
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
  * @returns {RawTxV1}
  */
@@ -1065,11 +1347,22 @@ export function rawTxV1FromNoun(noun) {
 }
 
 /**
+ * r" Convert into `Noun`.
+ * @param {NockchainTx} v
+ * @returns {Noun}
+ */
+export function nockchainTxToNoun(v) {
+    const ret = wasm.nockchainTxToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendsV1}
+ * @returns {NockchainTx}
  */
-export function spendsV1FromNoun(noun) {
-    const ret = wasm.spendsV1FromNoun(noun);
+export function nockchainTxFromNoun(noun) {
+    const ret = wasm.nockchainTxFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1077,50 +1370,62 @@ export function spendsV1FromNoun(noun) {
 }
 
 /**
- * @param {SpendsV1} v
- * @returns {Noun}
+ * @param {SpendsV1} spends
+ * @returns {RawTxV1}
  */
-export function spendsV1ToNoun(v) {
-    const ret = wasm.spendsV1ToNoun(v);
+export function rawTxV1New(spends) {
+    const ret = wasm.rawTxV1New(spends);
     return ret;
 }
 
 /**
- * @param {SpendsV1} v
+ * @param {RawTxV1} obj
  * @returns {Digest}
  */
-export function spendsV1Hash(v) {
-    const ret = wasm.spendsV1Hash(v);
+export function rawTxV1CalcId(obj) {
+    const ret = wasm.rawTxV1CalcId(obj);
     return ret;
 }
 
 /**
- * @param {NockchainTx} v
- * @returns {Noun}
+ * @param {RawTxV1} obj
+ * @returns {Version}
  */
-export function nockchainTxToNoun(v) {
-    const ret = wasm.nockchainTxToNoun(v);
+export function rawTxV1Version(obj) {
+    const ret = wasm.rawTxV1Version(obj);
     return ret;
 }
 
 /**
- * @param {Noun} noun
+ * @param {RawTxV1} obj
  * @returns {NockchainTx}
  */
-export function nockchainTxFromNoun(noun) {
-    const ret = wasm.nockchainTxFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function rawTxV1ToNockchainTx(obj) {
+    const ret = wasm.rawTxV1ToNockchainTx(obj);
+    return ret;
+}
+
+/**
+ * Calculate output notes from the transaction spends.
+ *
+ * This function combines seeds across multiple spends into one output note per-lock-root.
+ * @param {RawTxV1} obj
+ * @returns {NoteV1[]}
+ */
+export function rawTxV1Outputs(obj) {
+    const ret = wasm.rawTxV1Outputs(obj);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {PkhSignature}
+ * @returns {InputDisplay}
  */
-export function pkhSignatureFromNoun(noun) {
-    const ret = wasm.pkhSignatureFromNoun(noun);
+export function inputDisplayFromNoun(noun) {
+    const ret = wasm.inputDisplayFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1128,15 +1433,17 @@ export function pkhSignatureFromNoun(noun) {
 }
 
 /**
- * @param {PkhSignature} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {InputDisplay} v
+ * @returns {Noun}
  */
-export function pkhSignatureHash(v) {
-    const ret = wasm.pkhSignatureHash(v);
+export function inputDisplayToNoun(v) {
+    const ret = wasm.inputDisplayToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {PkhSignature} v
  * @returns {Noun}
  */
@@ -1146,29 +1453,21 @@ export function pkhSignatureToNoun(v) {
 }
 
 /**
- * @param {Note} v
- * @returns {Noun}
- */
-export function noteToNoun(v) {
-    const ret = wasm.noteToNoun(v);
-    return ret;
-}
-
-/**
- * @param {Note} v
+ * @param {PkhSignature} v
  * @returns {Digest}
  */
-export function noteHash(v) {
-    const ret = wasm.noteHash(v);
+export function pkhSignatureHash(v) {
+    const ret = wasm.pkhSignatureHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Note}
+ * @returns {PkhSignature}
  */
-export function noteFromNoun(noun) {
-    const ret = wasm.noteFromNoun(noun);
+export function pkhSignatureFromNoun(noun) {
+    const ret = wasm.pkhSignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1176,59 +1475,65 @@ export function noteFromNoun(noun) {
 }
 
 /**
- * @param {MerkleProof} v
- * @returns {Digest}
+ * @param {NockchainTx} obj
+ * @returns {RawTxV1}
  */
-export function merkleProofHash(v) {
-    const ret = wasm.merkleProofHash(v);
+export function nockchainTxToRawTx(obj) {
+    const ret = wasm.nockchainTxToRawTx(obj);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {MerkleProof}
+ * @param {NockchainTx} obj
+ * @returns {NoteV1[]}
  */
-export function merkleProofFromNoun(noun) {
-    const ret = wasm.merkleProofFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function nockchainTxOutputs(obj) {
+    const ret = wasm.nockchainTxOutputs(obj);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
 }
 
 /**
- * @param {MerkleProof} v
+ * r" Convert into `Noun`.
+ * @param {TransactionDisplay} v
  * @returns {Noun}
  */
-export function merkleProofToNoun(v) {
-    const ret = wasm.merkleProofToNoun(v);
+export function transactionDisplayToNoun(v) {
+    const ret = wasm.transactionDisplayToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockPrimitive} v
- * @returns {Noun}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {TransactionDisplay}
  */
-export function lockPrimitiveToNoun(v) {
-    const ret = wasm.lockPrimitiveToNoun(v);
-    return ret;
+export function transactionDisplayFromNoun(noun) {
+    const ret = wasm.transactionDisplayFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {LockPrimitive} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Balance} v
+ * @returns {Noun}
  */
-export function lockPrimitiveHash(v) {
-    const ret = wasm.lockPrimitiveHash(v);
+export function balanceToNoun(v) {
+    const ret = wasm.balanceToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockPrimitive}
+ * @returns {Balance}
  */
-export function lockPrimitiveFromNoun(noun) {
-    const ret = wasm.lockPrimitiveFromNoun(noun);
+export function balanceFromNoun(noun) {
+    const ret = wasm.balanceFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1245,6 +1550,7 @@ export function versionHash(v) {
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {Version} v
  * @returns {Noun}
  */
@@ -1254,6 +1560,7 @@ export function versionToNoun(v) {
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
  * @returns {Version}
  */
@@ -1266,11 +1573,12 @@ export function versionFromNoun(noun) {
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Sig}
+ * @returns {BalanceUpdate}
  */
-export function sigFromNoun(noun) {
-    const ret = wasm.sigFromNoun(noun);
+export function balanceUpdateFromNoun(noun) {
+    const ret = wasm.balanceUpdateFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1278,11 +1586,12 @@ export function sigFromNoun(noun) {
 }
 
 /**
- * @param {Sig} v
+ * r" Convert into `Noun`.
+ * @param {BalanceUpdate} v
  * @returns {Noun}
  */
-export function sigToNoun(v) {
-    const ret = wasm.sigToNoun(v);
+export function balanceUpdateToNoun(v) {
+    const ret = wasm.balanceUpdateToNoun(v);
     return ret;
 }
 
@@ -1296,20 +1605,12 @@ export function sigHash(v) {
 }
 
 /**
- * @param {TimelockIntent} v
- * @returns {Digest}
- */
-export function timelockIntentHash(v) {
-    const ret = wasm.timelockIntentHash(v);
-    return ret;
-}
-
-/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockIntent}
+ * @returns {Sig}
  */
-export function timelockIntentFromNoun(noun) {
-    const ret = wasm.timelockIntentFromNoun(noun);
+export function sigFromNoun(noun) {
+    const ret = wasm.sigFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1317,20 +1618,31 @@ export function timelockIntentFromNoun(noun) {
 }
 
 /**
- * @param {TimelockIntent} v
+ * r" Convert into `Noun`.
+ * @param {Sig} v
  * @returns {Noun}
  */
-export function timelockIntentToNoun(v) {
-    const ret = wasm.timelockIntentToNoun(v);
+export function sigToNoun(v) {
+    const ret = wasm.sigToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {NoteV0} v
+ * @returns {Digest}
+ */
+export function noteV0Hash(v) {
+    const ret = wasm.noteV0Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LegacySignature}
+ * @returns {NoteV0}
  */
-export function legacySignatureFromNoun(noun) {
-    const ret = wasm.legacySignatureFromNoun(noun);
+export function noteV0FromNoun(noun) {
+    const ret = wasm.noteV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1338,47 +1650,54 @@ export function legacySignatureFromNoun(noun) {
 }
 
 /**
- * @param {LegacySignature} v
+ * r" Convert into `Noun`.
+ * @param {NoteV0} v
  * @returns {Noun}
  */
-export function legacySignatureToNoun(v) {
-    const ret = wasm.legacySignatureToNoun(v);
+export function noteV0ToNoun(v) {
+    const ret = wasm.noteV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {LegacySignature} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {NoteInner} v
+ * @returns {Noun}
  */
-export function legacySignatureHash(v) {
-    const ret = wasm.legacySignatureHash(v);
+export function noteInnerToNoun(v) {
+    const ret = wasm.noteInnerToNoun(v);
     return ret;
 }
 
 /**
- * @param {Name} v
- * @returns {Noun}
+ * @param {NoteInner} v
+ * @returns {Digest}
  */
-export function nameToNoun(v) {
-    const ret = wasm.nameToNoun(v);
+export function noteInnerHash(v) {
+    const ret = wasm.noteInnerHash(v);
     return ret;
 }
 
 /**
- * @param {Name} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {NoteInner}
  */
-export function nameHash(v) {
-    const ret = wasm.nameHash(v);
-    return ret;
+export function noteInnerFromNoun(noun) {
+    const ret = wasm.noteInnerFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Name}
+ * @returns {NoteV1}
  */
-export function nameFromNoun(noun) {
-    const ret = wasm.nameFromNoun(noun);
+export function noteV1FromNoun(noun) {
+    const ret = wasm.noteV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1386,29 +1705,41 @@ export function nameFromNoun(noun) {
 }
 
 /**
- * @param {Source} v
+ * r" Convert into `Noun`.
+ * @param {NoteV1} v
  * @returns {Noun}
  */
-export function sourceToNoun(v) {
-    const ret = wasm.sourceToNoun(v);
+export function noteV1ToNoun(v) {
+    const ret = wasm.noteV1ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Source} v
+ * @param {NoteV1} v
  * @returns {Digest}
  */
-export function sourceHash(v) {
-    const ret = wasm.sourceHash(v);
+export function noteV1Hash(v) {
+    const ret = wasm.noteV1Hash(v);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {SeedV1} v
+ * @returns {Noun}
+ */
+export function seedV1ToNoun(v) {
+    const ret = wasm.seedV1ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Source}
+ * @returns {SeedV1}
  */
-export function sourceFromNoun(noun) {
-    const ret = wasm.sourceFromNoun(noun);
+export function seedV1FromNoun(noun) {
+    const ret = wasm.seedV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1416,29 +1747,21 @@ export function sourceFromNoun(noun) {
 }
 
 /**
- * @param {NoteV0} v
+ * @param {SeedV1} v
  * @returns {Digest}
  */
-export function noteV0Hash(v) {
-    const ret = wasm.noteV0Hash(v);
-    return ret;
-}
-
-/**
- * @param {NoteV0} v
- * @returns {Noun}
- */
-export function noteV0ToNoun(v) {
-    const ret = wasm.noteV0ToNoun(v);
+export function seedV1Hash(v) {
+    const ret = wasm.seedV1Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteV0}
+ * @returns {Witness}
  */
-export function noteV0FromNoun(noun) {
-    const ret = wasm.noteV0FromNoun(noun);
+export function witnessFromNoun(noun) {
+    const ret = wasm.witnessFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1446,41 +1769,40 @@ export function noteV0FromNoun(noun) {
 }
 
 /**
- * @param {Noun} noun
- * @returns {Pkh}
+ * r" Convert into `Noun`.
+ * @param {Witness} v
+ * @returns {Noun}
  */
-export function pkhFromNoun(noun) {
-    const ret = wasm.pkhFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function witnessToNoun(v) {
+    const ret = wasm.witnessToNoun(v);
+    return ret;
 }
 
 /**
- * @param {Pkh} v
+ * @param {Witness} v
  * @returns {Digest}
  */
-export function pkhHash(v) {
-    const ret = wasm.pkhHash(v);
+export function witnessHash(v) {
+    const ret = wasm.witnessHash(v);
     return ret;
 }
 
 /**
- * @param {Pkh} v
- * @returns {Noun}
+ * @param {SeedsV1} v
+ * @returns {Digest}
  */
-export function pkhToNoun(v) {
-    const ret = wasm.pkhToNoun(v);
+export function seedsV1Hash(v) {
+    const ret = wasm.seedsV1Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {WitnessData}
+ * @returns {SeedsV1}
  */
-export function witnessDataFromNoun(noun) {
-    const ret = wasm.witnessDataFromNoun(noun);
+export function seedsV1FromNoun(noun) {
+    const ret = wasm.seedsV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1488,38 +1810,41 @@ export function witnessDataFromNoun(noun) {
 }
 
 /**
- * @param {WitnessData} v
+ * r" Convert into `Noun`.
+ * @param {SeedsV1} v
  * @returns {Noun}
  */
-export function witnessDataToNoun(v) {
-    const ret = wasm.witnessDataToNoun(v);
+export function seedsV1ToNoun(v) {
+    const ret = wasm.seedsV1ToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockMetadata} v
- * @returns {Noun}
+ * @param {SpendV1} v
+ * @returns {Digest}
  */
-export function lockMetadataToNoun(v) {
-    const ret = wasm.lockMetadataToNoun(v);
+export function spendV1Hash(v) {
+    const ret = wasm.spendV1Hash(v);
     return ret;
 }
 
 /**
- * @param {LockMetadata} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {SpendV1} v
+ * @returns {Noun}
  */
-export function lockMetadataHash(v) {
-    const ret = wasm.lockMetadataHash(v);
+export function spendV1ToNoun(v) {
+    const ret = wasm.spendV1ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockMetadata}
+ * @returns {SpendV1}
  */
-export function lockMetadataFromNoun(noun) {
-    const ret = wasm.lockMetadataFromNoun(noun);
+export function spendV1FromNoun(noun) {
+    const ret = wasm.spendV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1527,59 +1852,63 @@ export function lockMetadataFromNoun(noun) {
 }
 
 /**
- * @param {TimelockRange} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {LockRoot}
  */
-export function timelockRangeHash(v) {
-    const ret = wasm.timelockRangeHash(v);
-    return ret;
+export function lockRootFromNoun(noun) {
+    const ret = wasm.lockRootFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {TimelockRange} v
+ * r" Convert into `Noun`.
+ * @param {LockRoot} v
  * @returns {Noun}
  */
-export function timelockRangeToNoun(v) {
-    const ret = wasm.timelockRangeToNoun(v);
+export function lockRootToNoun(v) {
+    const ret = wasm.lockRootToNoun(v);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {TimelockRange}
+ * @param {LockRoot} v
+ * @returns {Digest}
  */
-export function timelockRangeFromNoun(noun) {
-    const ret = wasm.timelockRangeFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function lockRootHash(v) {
+    const ret = wasm.lockRootHash(v);
+    return ret;
 }
 
 /**
- * @param {SeedV0} v
+ * @param {SpendsV1} v
  * @returns {Digest}
  */
-export function seedV0Hash(v) {
-    const ret = wasm.seedV0Hash(v);
+export function spendsV1Hash(v) {
+    const ret = wasm.spendsV1Hash(v);
     return ret;
 }
 
 /**
- * @param {SeedV0} v
+ * r" Convert into `Noun`.
+ * @param {SpendsV1} v
  * @returns {Noun}
  */
-export function seedV0ToNoun(v) {
-    const ret = wasm.seedV0ToNoun(v);
+export function spendsV1ToNoun(v) {
+    const ret = wasm.spendsV1ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedV0}
+ * @returns {SpendsV1}
  */
-export function seedV0FromNoun(noun) {
-    const ret = wasm.seedV0FromNoun(noun);
+export function spendsV1FromNoun(noun) {
+    const ret = wasm.spendsV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1587,83 +1916,91 @@ export function seedV0FromNoun(noun) {
 }
 
 /**
- * @param {Timelock} v
- * @returns {Noun}
+ * @param {SeedV1} obj
+ * @returns {bigint}
  */
-export function timelockToNoun(v) {
-    const ret = wasm.timelockToNoun(v);
-    return ret;
+export function seedV1NoteDataWords(obj) {
+    const ret = wasm.seedV1NoteDataWords(obj);
+    return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {Timelock} v
- * @returns {Digest}
+ * @param {Digest} pkh
+ * @param {Nicks} gift
+ * @param {Digest} parent_hash
+ * @param {boolean} include_lock_data
+ * @returns {SeedV1}
  */
-export function timelockHash(v) {
-    const ret = wasm.timelockHash(v);
+export function seedV1NewSinglePkh(pkh, gift, parent_hash, include_lock_data) {
+    const ret = wasm.seedV1NewSinglePkh(pkh, gift, parent_hash, include_lock_data);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {Timelock}
+ * @param {SpendV1} obj
+ * @returns {Digest}
  */
-export function timelockFromNoun(noun) {
-    const ret = wasm.timelockFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1SigHash(obj) {
+    const ret = wasm.spendV1SigHash(obj);
+    return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {RawTxV0}
+ * @param {SeedsV1} seeds
+ * @param {Nicks} fee
+ * @returns {SpendV1}
  */
-export function rawTxV0FromNoun(noun) {
-    const ret = wasm.rawTxV0FromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1NewLegacy(seeds, fee) {
+    const ret = wasm.spendV1NewLegacy(seeds, fee);
+    return ret;
 }
 
 /**
- * @param {RawTxV0} v
- * @returns {Noun}
+ * @param {Witness} witness
+ * @param {SeedsV1} seeds
+ * @param {Nicks} fee
+ * @returns {SpendV1}
  */
-export function rawTxV0ToNoun(v) {
-    const ret = wasm.rawTxV0ToNoun(v);
+export function spendV1NewWitness(witness, seeds, fee) {
+    const ret = wasm.spendV1NewWitness(witness, seeds, fee);
     return ret;
 }
 
 /**
- * @param {InputDisplay} v
- * @returns {Noun}
+ * @param {SpendV1} obj
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function inputDisplayToNoun(v) {
-    const ret = wasm.inputDisplayToNoun(v);
+export function spendV1UnclampedFee(obj, settings) {
+    const ret = wasm.spendV1UnclampedFee(obj, settings);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {InputDisplay}
+ * @param {SpendV1} obj
+ * @returns {Nicks}
  */
-export function inputDisplayFromNoun(noun) {
-    const ret = wasm.inputDisplayFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1Fee(obj) {
+    const ret = wasm.spendV1Fee(obj);
+    return ret;
+}
+
+/**
+ * @param {SpendV1} obj
+ * @returns {SeedsV1}
+ */
+export function spendV1Seeds(obj) {
+    const ret = wasm.spendV1Seeds(obj);
+    return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendCondition}
+ * @returns {MerkleProof}
  */
-export function spendConditionFromNoun(noun) {
-    const ret = wasm.spendConditionFromNoun(noun);
+export function merkleProofFromNoun(noun) {
+    const ret = wasm.merkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1671,47 +2008,41 @@ export function spendConditionFromNoun(noun) {
 }
 
 /**
- * @param {SpendCondition} v
+ * @param {MerkleProof} v
  * @returns {Digest}
  */
-export function spendConditionHash(v) {
-    const ret = wasm.spendConditionHash(v);
+export function merkleProofHash(v) {
+    const ret = wasm.merkleProofHash(v);
     return ret;
 }
 
 /**
- * @param {SpendCondition} v
+ * r" Convert into `Noun`.
+ * @param {MerkleProof} v
  * @returns {Noun}
  */
-export function spendConditionToNoun(v) {
-    const ret = wasm.spendConditionToNoun(v);
+export function merkleProofToNoun(v) {
+    const ret = wasm.merkleProofToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockMerkleProof} v
+ * r" Convert into `Noun`.
+ * @param {WitnessData} v
  * @returns {Noun}
  */
-export function lockMerkleProofToNoun(v) {
-    const ret = wasm.lockMerkleProofToNoun(v);
-    return ret;
-}
-
-/**
- * @param {LockMerkleProof} v
- * @returns {Digest}
- */
-export function lockMerkleProofHash(v) {
-    const ret = wasm.lockMerkleProofHash(v);
+export function witnessDataToNoun(v) {
+    const ret = wasm.witnessDataToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockMerkleProof}
+ * @returns {WitnessData}
  */
-export function lockMerkleProofFromNoun(noun) {
-    const ret = wasm.lockMerkleProofFromNoun(noun);
+export function witnessDataFromNoun(noun) {
+    const ret = wasm.witnessDataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1719,41 +2050,42 @@ export function lockMerkleProofFromNoun(noun) {
 }
 
 /**
- * @param {TransactionDisplay} v
- * @returns {Noun}
+ * @param {SpendsV1} obj
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function transactionDisplayToNoun(v) {
-    const ret = wasm.transactionDisplayToNoun(v);
+export function spendsV1Fee(obj, settings) {
+    const ret = wasm.spendsV1Fee(obj, settings);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {TransactionDisplay}
+ * @param {SpendsV1} obj
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function transactionDisplayFromNoun(noun) {
-    const ret = wasm.transactionDisplayFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendsV1UnclampedFee(obj, settings) {
+    const ret = wasm.spendsV1UnclampedFee(obj, settings);
+    return ret;
 }
 
 /**
- * @param {Balance} v
- * @returns {Noun}
+ * @param {SpendsV1} obj
+ * @param {WitnessData} witness_data
+ * @returns {SpendsV1}
  */
-export function balanceToNoun(v) {
-    const ret = wasm.balanceToNoun(v);
+export function spendsV1ApplyWitness(obj, witness_data) {
+    const ret = wasm.spendsV1ApplyWitness(obj, witness_data);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Balance}
+ * @returns {LockMerkleProof}
  */
-export function balanceFromNoun(noun) {
-    const ret = wasm.balanceFromNoun(noun);
+export function lockMerkleProofFromNoun(noun) {
+    const ret = wasm.lockMerkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1761,20 +2093,31 @@ export function balanceFromNoun(noun) {
 }
 
 /**
- * @param {BalanceUpdate} v
+ * @param {LockMerkleProof} v
+ * @returns {Digest}
+ */
+export function lockMerkleProofHash(v) {
+    const ret = wasm.lockMerkleProofHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {LockMerkleProof} v
  * @returns {Noun}
  */
-export function balanceUpdateToNoun(v) {
-    const ret = wasm.balanceUpdateToNoun(v);
+export function lockMerkleProofToNoun(v) {
+    const ret = wasm.lockMerkleProofToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {BalanceUpdate}
+ * @returns {Note}
  */
-export function balanceUpdateFromNoun(noun) {
-    const ret = wasm.balanceUpdateFromNoun(noun);
+export function noteFromNoun(noun) {
+    const ret = wasm.noteFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1782,11 +2125,21 @@ export function balanceUpdateFromNoun(noun) {
 }
 
 /**
- * @param {Digest} v
+ * r" Convert into `Noun`.
+ * @param {Note} v
  * @returns {Noun}
  */
-export function digestToNoun(v) {
-    const ret = wasm.digestToNoun(v);
+export function noteToNoun(v) {
+    const ret = wasm.noteToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {Note} v
+ * @returns {Digest}
+ */
+export function noteHash(v) {
+    const ret = wasm.noteHash(v);
     return ret;
 }
 
@@ -1800,6 +2153,17 @@ export function digestHash(v) {
 }
 
 /**
+ * r" Convert into `Noun`.
+ * @param {Digest} v
+ * @returns {Noun}
+ */
+export function digestToNoun(v) {
+    const ret = wasm.digestToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
  * @returns {Digest}
  */
@@ -1811,12 +2175,12 @@ export function digestFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h7f888ae473d7b77e(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h7f888ae473d7b77e(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h2bc9de53710866b6(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h2bc9de53710866b6(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h326fdb3bcde44ceb(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h326fdb3bcde44ceb(arg0, arg1, arg2, arg3);
 }
 
 const __wbindgen_enum_ReadableStreamType = ["bytes"];
@@ -2124,6 +2488,124 @@ export class IntoUnderlyingSource {
 }
 if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
 
+const PrivateKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_privatekey_free(ptr >>> 0, 1));
+
+export class PrivateKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PrivateKey.prototype);
+        obj.__wbg_ptr = ptr;
+        PrivateKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PrivateKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_privatekey_free(ptr, 0);
+    }
+    /**
+     * Construct a bytes-backed key.
+     * @param {Uint8Array} signing_key_bytes
+     * @returns {PrivateKey}
+     */
+    static fromBytes(signing_key_bytes) {
+        const ptr0 = passArray8ToWasm0(signing_key_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.privatekey_fromBytes(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PrivateKey.__wrap(ret[0]);
+    }
+    /**
+     * Return this key's public key as 97-byte uncompressed bytes.
+     * @returns {Uint8Array}
+     */
+    get publicKey() {
+        const ret = wasm.privatekey_publicKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * Return the backend kind for debugging and feature checks.
+     * @returns {string}
+     */
+    backendKind() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.privatekey_backendKind(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 derivation path for this key backend, if available.
+     *
+     * Bytes-backed keys return `undefined` in JavaScript.
+     * @returns {string | undefined}
+     */
+    get derivationPath() {
+        const ret = wasm.privatekey_derivationPath(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * Construct a wasm `PrivateKey` from 32-byte private key material.
+     *
+     * This object is created in JavaScript and then passed into Rust signing APIs.
+     *
+     * # JavaScript example
+     *
+     * ```javascript
+     * import init, { PrivateKey, TxBuilder } from "iris-wasm";
+     *
+     * await init();
+     *
+     * const keyBytes = Uint8Array.from([
+     *   // 32 bytes
+     * ]);
+     *
+     * const key = PrivateKey.fromBytes(keyBytes);
+     *
+     * const builder = new TxBuilder(settings);
+     * // ... configure builder ...
+     * await builder.sign(key);
+     * ```
+     * @param {Uint8Array} signing_key_bytes
+     */
+    constructor(signing_key_bytes) {
+        const ptr0 = passArray8ToWasm0(signing_key_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.privatekey_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        PrivateKeyFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) PrivateKey.prototype[Symbol.dispose] = PrivateKey.prototype.free;
+
 const SpendBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spendbuilder_free(ptr >>> 0, 1));
@@ -2228,17 +2710,13 @@ export class SpendBuilder {
         }
     }
     /**
-     * @param {Uint8Array} signing_key_bytes
-     * @returns {boolean}
+     * @param {PrivateKey} signing_key
+     * @returns {Promise<boolean>}
      */
-    sign(signing_key_bytes) {
-        const ptr0 = passArray8ToWasm0(signing_key_bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.spendbuilder_sign(this.__wbg_ptr, ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] !== 0;
+    sign(signing_key) {
+        _assertClass(signing_key, PrivateKey);
+        const ret = wasm.spendbuilder_sign(this.__wbg_ptr, signing_key.__wbg_ptr);
+        return ret;
     }
 }
 if (Symbol.dispose) SpendBuilder.prototype[Symbol.dispose] = SpendBuilder.prototype.free;
@@ -2340,15 +2818,13 @@ export class TxBuilder {
         return this;
     }
     /**
-     * @param {Uint8Array} signing_key_bytes
+     * @param {PrivateKey} signing_key
+     * @returns {Promise<void>}
      */
-    sign(signing_key_bytes) {
-        const ptr0 = passArray8ToWasm0(signing_key_bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.txbuilder_sign(this.__wbg_ptr, ptr0, len0);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+    sign(signing_key) {
+        _assertClass(signing_key, PrivateKey);
+        const ret = wasm.txbuilder_sign(this.__wbg_ptr, signing_key.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {NockchainTx}
@@ -2461,32 +2937,6 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
-        const ret = Error(getStringFromWasm0(arg0, arg1));
-        return ret;
-    };
-    imports.wbg.__wbg_Number_bb48ca12f395cd08 = function(arg0) {
-        const ret = Number(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
-        const ret = String(arg1);
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
-    imports.wbg.__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd = function(arg0, arg1) {
-        const v = arg1;
-        const ret = typeof(v) === 'bigint' ? v : undefined;
-        getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-    };
-    imports.wbg.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {
-        const v = arg0;
-        const ret = typeof(v) === 'boolean' ? v : undefined;
-        return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
-    };
     imports.wbg.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
         const ret = debugString(arg1);
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2494,14 +2944,6 @@ function __wbg_get_imports() {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
-    imports.wbg.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {
-        const ret = arg0 in arg1;
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_is_bigint_cb320707dcd35f0b = function(arg0) {
-        const ret = typeof(arg0) === 'bigint';
-        return ret;
-    };
     imports.wbg.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
         const ret = typeof(arg0) === 'function';
         return ret;
@@ -2511,28 +2953,10 @@ function __wbg_get_imports() {
         const ret = typeof(val) === 'object' && val !== null;
         return ret;
     };
-    imports.wbg.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
-        const ret = typeof(arg0) === 'string';
-        return ret;
-    };
     imports.wbg.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
         const ret = arg0 === undefined;
         return ret;
     };
-    imports.wbg.__wbg___wbindgen_jsval_eq_6b13ab83478b1c50 = function(arg0, arg1) {
-        const ret = arg0 === arg1;
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147 = function(arg0, arg1) {
-        const ret = arg0 == arg1;
-        return ret;
-    };
-    imports.wbg.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
-        const obj = arg1;
-        const ret = typeof(obj) === 'number' ? obj : undefined;
-        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-    };
     imports.wbg.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {
         const obj = arg1;
         const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -2599,10 +3023,6 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_enqueue_7b18a650aec77898 = function() { return handleError(function (arg0, arg1) {
         arg0.enqueue(arg1);
     }, arguments) };
-    imports.wbg.__wbg_entries_e171b586f8f6bdbf = function(arg0) {
-        const ret = Object.entries(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_fetch_769f3df592e37b75 = function(arg0, arg1) {
         const ret = fetch(arg0, arg1);
         return ret;
@@ -2631,10 +3051,6 @@ function __wbg_get_imports() {
         const ret = arg0.value;
         return ret;
     };
-    imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
-        const ret = arg0[arg1];
-        return ret;
-    };
     imports.wbg.__wbg_has_787fafc980c3ccdb = function() { return handleError(function (arg0, arg1) {
         const ret = Reflect.has(arg0, arg1);
         return ret;
@@ -2643,44 +3059,6 @@ function __wbg_get_imports() {
         const ret = arg0.headers;
         return ret;
     };
-    imports.wbg.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {
-        let result;
-        try {
-            result = arg0 instanceof ArrayBuffer;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Map_8579b5e2ab5437c7 = function(arg0) {
-        let result;
-        try {
-            result = arg0 instanceof Map;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
-        let result;
-        try {
-            result = arg0 instanceof Uint8Array;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
-    imports.wbg.__wbg_isArray_96e0af9891d0945d = function(arg0) {
-        const ret = Array.isArray(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {
-        const ret = Number.isSafeInteger(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_iterator_e5822695327a3c39 = function() {
         const ret = Symbol.iterator;
         return ret;
@@ -2689,10 +3067,6 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_length_cdd215e10d9dd507 = function(arg0) {
-        const ret = arg0.length;
-        return ret;
-    };
     imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
         const ret = new Object();
         return ret;
@@ -2704,7 +3078,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return wasm_bindgen__convert__closures_____invoke__h2bc9de53710866b6(a, state0.b, arg0, arg1);
+                    return wasm_bindgen__convert__closures_____invoke__h326fdb3bcde44ceb(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2727,10 +3101,6 @@ function __wbg_get_imports() {
         const ret = new Error(getStringFromWasm0(arg0, arg1));
         return ret;
     };
-    imports.wbg.__wbg_new_e17d9f43105b08be = function() {
-        const ret = new Array();
-        return ret;
-    };
     imports.wbg.__wbg_new_from_slice_92f4d78ca282a2d2 = function(arg0, arg1) {
         const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
         return ret;
@@ -2755,6 +3125,10 @@ function __wbg_get_imports() {
         const ret = arg0.next;
         return ret;
     };
+    imports.wbg.__wbg_parse_2a704d6b78abb2b8 = function() { return handleError(function (arg0, arg1) {
+        const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
@@ -2779,18 +3153,12 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_respond_0f4dbf5386f5c73e = function() { return handleError(function (arg0, arg1) {
         arg0.respond(arg1 >>> 0);
     }, arguments) };
-    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
-        arg0[arg1] = arg2;
-    };
     imports.wbg.__wbg_set_9e6516df7b7d0f19 = function(arg0, arg1, arg2) {
         arg0.set(getArrayU8FromWasm0(arg1, arg2));
     };
     imports.wbg.__wbg_set_body_3c365989753d61f4 = function(arg0, arg1) {
         arg0.body = arg1;
     };
-    imports.wbg.__wbg_set_c213c871859d6500 = function(arg0, arg1, arg2) {
-        arg0[arg1 >>> 0] = arg2;
-    };
     imports.wbg.__wbg_set_cache_2f9deb19b92b81e3 = function(arg0, arg1) {
         arg0.cache = __wbindgen_enum_RequestCache[arg1];
     };
@@ -2842,6 +3210,10 @@ function __wbg_get_imports() {
         const ret = arg0.status;
         return ret;
     };
+    imports.wbg.__wbg_stringify_b5fb28f6465d9c3e = function() { return handleError(function (arg0) {
+        const ret = JSON.stringify(arg0);
+        return ret;
+    }, arguments) };
     imports.wbg.__wbg_then_4f46f6544e6b4a28 = function(arg0, arg1) {
         const ret = arg0.then(arg1);
         return ret;
@@ -2867,24 +3239,9 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
     };
-    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
-        // Cast intrinsic for `U64 -> Externref`.
-        const ret = BigInt.asUintN(64, arg0);
-        return ret;
-    };
-    imports.wbg.__wbindgen_cast_663c73182bf372f2 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 369, function: Function { arguments: [Externref], shim_idx: 370, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h20e54f17b0de8c43, wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b);
-        return ret;
-    };
-    imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
-        // Cast intrinsic for `I64 -> Externref`.
-        const ret = arg0;
-        return ret;
-    };
-    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
-        // Cast intrinsic for `F64 -> Externref`.
-        const ret = arg0;
+    imports.wbg.__wbindgen_cast_b1bcbba6fa3c236c = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 357, function: Function { arguments: [Externref], shim_idx: 358, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__haffc2f8a6add1279, wasm_bindgen__convert__closures_____invoke__h7f888ae473d7b77e);
         return ret;
     };
     imports.wbg.__wbindgen_init_externref_table = function() {