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

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) {
@@ -219,80 +219,113 @@ function takeFromExternrefTable0(idx) {
     wasm.__externref_table_dealloc(idx);
     return value;
 }
+
+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 {Noun} noun
- * @returns {Uint8Array}
+ * Hash a public key to get its digest (for use in PKH)
+ * @param {Uint8Array} public_key_bytes
+ * @returns {string}
  */
-export function jam(noun) {
-    const ret = wasm.jam(noun);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
+export function hashPublicKey(public_key_bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hashPublicKey(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
+        if (ret[3]) {
+            ptr2 = 0; len2 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
 }
 
 /**
- * @param {Noun} noun
+ * Hash a noun (jam as input)
+ * @param {Uint8Array} noun
  * @returns {string}
  */
-export function untas(noun) {
-    let deferred2_0;
-    let deferred2_1;
+export function hashNoun(noun) {
+    let deferred3_0;
+    let deferred3_1;
     try {
-        const ret = wasm.untas(noun);
-        var ptr1 = ret[0];
-        var len1 = ret[1];
+        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.hashNoun(ptr0, len0);
+        var ptr2 = ret[0];
+        var len2 = ret[1];
         if (ret[3]) {
-            ptr1 = 0; len1 = 0;
+            ptr2 = 0; len2 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred2_0 = ptr1;
-        deferred2_1 = len1;
-        return getStringFromWasm0(ptr1, len1);
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
     } finally {
-        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
 
 /**
- * @param {string} s
- * @returns {Noun}
+ * Hash a u64 value
+ * @param {bigint} value
+ * @returns {string}
  */
-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;
+export function hashU64(value) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.hashU64(value);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
 }
 
 /**
- * @param {Noun} noun
- * @returns {Noun}
+ * Derive master key from BIP39 mnemonic phrase
+ * @param {string} mnemonic
+ * @param {string | null} [passphrase]
+ * @returns {ExtendedKey}
  */
-export function belts_to_atom(noun) {
-    const ret = wasm.belts_to_atom(noun);
+export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    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);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    return ExtendedKey.__wrap(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}
+ * Sign a message string with a private key
+ * @param {Uint8Array} private_key_bytes
+ * @param {string} message
+ * @returns {Signature}
  */
-export function cue(jam) {
-    const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
+export function signMessage(private_key_bytes, message) {
+    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.cue(ptr0, len0);
+    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.signMessage(ptr0, len0, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -300,77 +333,87 @@ export function cue(jam) {
 }
 
 /**
- * @param {Noun} atom
- * @returns {Noun}
+ * Derive master key from seed bytes
+ * @param {Uint8Array} seed
+ * @returns {ExtendedKey}
  */
-export function atom_to_belts(atom) {
-    const ret = wasm.atom_to_belts(atom);
+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);
+}
+
+/**
+ * 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 takeFromExternrefTable0(ret[0]);
+    return ret[0] !== 0;
 }
 
 /**
+ * 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 tas(s) {
+export function tas_belts(s) {
     const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.tas(ptr0, len0);
+    const ret = wasm.tas_belts(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
+ * Convert an Atom into a string.
+ * @param {Noun} noun
  * @returns {string}
  */
-export function digest_to_hex(d) {
-    let deferred1_0;
-    let deferred1_1;
+export function untas(noun) {
+    let deferred2_0;
+    let deferred2_1;
     try {
-        const ret = wasm.digest_to_hex(d);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
+        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(deferred1_0, deferred1_1, 1);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
 
 /**
- * @param {PbCom2Note} value
- * @returns {Note}
+ * Cue a jammed Uint8Array into a Noun (see `jam`).
+ * @param {Uint8Array} jam
+ * @returns {Noun}
  */
-export function note_from_protobuf(value) {
-    const ret = wasm.note_from_protobuf(value);
+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]);
     }
@@ -378,71 +421,84 @@ export function note_from_protobuf(value) {
 }
 
 /**
- * @param {RawTxV1} tx
- * @returns {NockchainTx}
- */
-export function rawTxToNockchainTx(tx) {
-    const ret = wasm.rawTxToNockchainTx(tx);
-    return ret;
-}
-
-/**
- * @param {RawTx} tx
- * @returns {Note[]}
+ * Convert a sequence of belts back into one atom.
+ * @param {Noun} noun
+ * @returns {Noun}
  */
-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;
+export function belts_to_atom(noun) {
+    const ret = wasm.belts_to_atom(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {PbCom2RawTransaction} tx
- * @returns {RawTx}
+ * Encode a Noun as a Uint8Array of bytes.
+ * @param {Noun} noun
+ * @returns {Uint8Array}
  */
-export function rawTxFromProtobuf(tx) {
-    const ret = wasm.rawTxFromProtobuf(tx);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function jam(noun) {
+    const ret = wasm.jam(noun);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
     }
-    return takeFromExternrefTable0(ret[0]);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
 }
 
 /**
- * @param {Note} note
- * @returns {PbCom2Note}
+ * Convert string to an Atom.
+ * @param {string} s
+ * @returns {Noun}
  */
-export function note_to_protobuf(note) {
-    const ret = wasm.note_to_protobuf(note);
+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 {Version} version
- * @param {number} origin_page
- * @param {Name} name
- * @param {NoteData} note_data
- * @param {Nicks} assets
- * @returns {Note}
+ * Convert an Atom to belts.
+ * @param {Noun} atom
+ * @returns {Noun}
  */
-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);
+export function atom_to_belts(atom) {
+    const ret = wasm.atom_to_belts(atom);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {Note} note
- * @returns {Digest}
- */
-export function note_hash(note) {
-    const ret = wasm.note_hash(note);
-    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 {string} s
  * @returns {Digest}
@@ -478,6 +534,11 @@ export function create_note_v0(origin_page, sig_m, sig_pubkeys, source_hash, is_
 }
 
 /**
+ * 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}
  */
@@ -487,11 +548,15 @@ export function rawTxToProtobuf(tx) {
 }
 
 /**
- * @param {PbCom1Hash} value
- * @returns {Digest}
+ * @param {Version} version
+ * @param {number} origin_page
+ * @param {Name} name
+ * @param {NoteData} note_data
+ * @param {Nicks} assets
+ * @returns {Note}
  */
-export function digest_from_protobuf(value) {
-    const ret = wasm.digest_from_protobuf(value);
+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]);
     }
@@ -499,35 +564,11 @@ export function digest_from_protobuf(value) {
 }
 
 /**
- * @param {Digest} d
- * @returns {PbCom1Hash}
- */
-export function digest_to_protobuf(d) {
-    const ret = wasm.digest_to_protobuf(d);
-    return ret;
-}
-
-/**
- * @param {NockchainTx} tx
- * @returns {RawTx}
- */
-export function nockchainTxToRaw(tx) {
-    const ret = wasm.nockchainTxToRaw(tx);
-    return ret;
-}
-
-/**
- * Sign a message string with a private key
- * @param {Uint8Array} private_key_bytes
- * @param {string} message
- * @returns {Signature}
+ * @param {PbCom1Hash} value
+ * @returns {Digest}
  */
-export function signMessage(private_key_bytes, message) {
-    const ptr0 = passArray8ToWasm0(private_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.signMessage(ptr0, len0, ptr1, len1);
+export function digest_from_protobuf(value) {
+    const ret = wasm.digest_from_protobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -535,78 +576,24 @@ export function signMessage(private_key_bytes, message) {
 }
 
 /**
- * Derive master key from BIP39 mnemonic phrase
- * @param {string} mnemonic
- * @param {string | null} [passphrase]
- * @returns {ExtendedKey}
- */
-export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
-    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    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);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return ExtendedKey.__wrap(ret[0]);
-}
-
-/**
- * Hash a public key to get its digest (for use in PKH)
- * @param {Uint8Array} public_key_bytes
- * @returns {string}
- */
-export function hashPublicKey(public_key_bytes) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashPublicKey(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-    }
-}
-
-/**
- * Verify a signature with a public key
- * @param {Uint8Array} public_key_bytes
- * @param {Signature} signature
- * @param {string} message
- * @returns {boolean}
+ * Lossily convert raw transaction into a nockchain transaction, splitting witness away.
+ * @param {RawTxV1} tx
+ * @returns {NockchainTx}
  */
-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;
+export function rawTxToNockchainTx(tx) {
+    const ret = wasm.rawTxToNockchainTx(tx);
+    return ret;
 }
 
 /**
- * Hash a u64 value
- * @param {bigint} value
+ * @param {Digest} d
  * @returns {string}
  */
-export function hashU64(value) {
+export function digest_to_hex(d) {
     let deferred1_0;
     let deferred1_1;
     try {
-        const ret = wasm.hashU64(value);
+        const ret = wasm.digest_to_hex(d);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -616,58 +603,49 @@ export function hashU64(value) {
 }
 
 /**
- * Derive master key from seed bytes
- * @param {Uint8Array} seed
- * @returns {ExtendedKey}
+ * @param {Note} note
+ * @returns {PbCom2Note}
  */
-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);
+export function note_to_protobuf(note) {
+    const ret = wasm.note_to_protobuf(note);
+    return ret;
 }
 
 /**
- * Hash a noun (jam as input)
- * @param {Uint8Array} noun
- * @returns {string}
+ * @param {RawTx} tx
+ * @returns {Note[]}
  */
-export function hashNoun(noun) {
-    let deferred3_0;
-    let deferred3_1;
-    try {
-        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashNoun(ptr0, len0);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
-        if (ret[3]) {
-            ptr2 = 0; len2 = 0;
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
-    } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-    }
+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 {Input} v
+ * @param {Digest} d
+ * @returns {PbCom1Hash}
+ */
+export function digest_to_protobuf(d) {
+    const ret = wasm.digest_to_protobuf(d);
+    return ret;
+}
+
+/**
+ * @param {Note} note
  * @returns {Digest}
  */
-export function inputHash(v) {
-    const ret = wasm.inputHash(v);
+export function note_hash(note) {
+    const ret = wasm.note_hash(note);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {Input}
+ * @param {PbCom2Note} value
+ * @returns {Note}
  */
-export function inputFromNoun(noun) {
-    const ret = wasm.inputFromNoun(noun);
+export function note_from_protobuf(value) {
+    const ret = wasm.note_from_protobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -675,38 +653,45 @@ export function inputFromNoun(noun) {
 }
 
 /**
- * @param {Input} v
- * @returns {Noun}
+ * @param {PbCom2RawTransaction} tx
+ * @returns {RawTx}
  */
-export function inputToNoun(v) {
-    const ret = wasm.inputToNoun(v);
-    return ret;
+export function rawTxFromProtobuf(tx) {
+    const ret = wasm.rawTxFromProtobuf(tx);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {Inputs} v
- * @returns {Noun}
+ * Convert NockchainTx into RawTx by recombining witness_data with the transaction, and
+ * recalculating the transaction ID.
+ * @param {NockchainTx} tx
+ * @returns {RawTx}
  */
-export function inputsToNoun(v) {
-    const ret = wasm.inputsToNoun(v);
+export function nockchainTxToRaw(tx) {
+    const ret = wasm.nockchainTxToRaw(tx);
     return ret;
 }
 
 /**
- * @param {Inputs} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {WitnessData} v
+ * @returns {Noun}
  */
-export function inputsHash(v) {
-    const ret = wasm.inputsHash(v);
+export function witnessDataToNoun(v) {
+    const ret = wasm.witnessDataToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Inputs}
+ * @returns {WitnessData}
  */
-export function inputsFromNoun(noun) {
-    const ret = wasm.inputsFromNoun(noun);
+export function witnessDataFromNoun(noun) {
+    const ret = wasm.witnessDataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -714,20 +699,31 @@ export function inputsFromNoun(noun) {
 }
 
 /**
- * @param {SeedsV0} v
+ * @param {LockMetadata} v
+ * @returns {Digest}
+ */
+export function lockMetadataHash(v) {
+    const ret = wasm.lockMetadataHash(v);
+    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;
 }
 
 /**
+ * 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 +731,12 @@ export function seedsV0FromNoun(noun) {
 }
 
 /**
- * @param {SeedsV0} v
- * @returns {Digest}
- */
-export function seedsV0Hash(v) {
-    const ret = wasm.seedsV0Hash(v);
-    return ret;
-}
-
-/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendV0}
+ * @returns {Version}
  */
-export function spendV0FromNoun(noun) {
-    const ret = wasm.spendV0FromNoun(noun);
+export function versionFromNoun(noun) {
+    const ret = wasm.versionFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -756,38 +744,41 @@ export function spendV0FromNoun(noun) {
 }
 
 /**
- * @param {SpendV0} v
+ * r" Convert into `Noun`.
+ * @param {Version} v
  * @returns {Noun}
  */
-export function spendV0ToNoun(v) {
-    const ret = wasm.spendV0ToNoun(v);
+export function versionToNoun(v) {
+    const ret = wasm.versionToNoun(v);
     return ret;
 }
 
 /**
- * @param {SpendV0} v
+ * @param {Version} v
  * @returns {Digest}
  */
-export function spendV0Hash(v) {
-    const ret = wasm.spendV0Hash(v);
+export function versionHash(v) {
+    const ret = wasm.versionHash(v);
     return ret;
 }
 
 /**
- * @param {NoteInner} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {TimelockIntent} v
+ * @returns {Noun}
  */
-export function noteInnerHash(v) {
-    const ret = wasm.noteInnerHash(v);
+export function timelockIntentToNoun(v) {
+    const ret = wasm.timelockIntentToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteInner}
+ * @returns {TimelockIntent}
  */
-export function noteInnerFromNoun(noun) {
-    const ret = wasm.noteInnerFromNoun(noun);
+export function timelockIntentFromNoun(noun) {
+    const ret = wasm.timelockIntentFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -795,20 +786,40 @@ export function noteInnerFromNoun(noun) {
 }
 
 /**
- * @param {NoteInner} v
+ * @param {TimelockIntent} v
+ * @returns {Digest}
+ */
+export function timelockIntentHash(v) {
+    const ret = wasm.timelockIntentHash(v);
+    return ret;
+}
+
+/**
+ * @param {LegacySignature} v
+ * @returns {Digest}
+ */
+export function legacySignatureHash(v) {
+    const ret = wasm.legacySignatureHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {LegacySignature} v
  * @returns {Noun}
  */
-export function noteInnerToNoun(v) {
-    const ret = wasm.noteInnerToNoun(v);
+export function legacySignatureToNoun(v) {
+    const ret = wasm.legacySignatureToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Hax}
+ * @returns {LegacySignature}
  */
-export function haxFromNoun(noun) {
-    const ret = wasm.haxFromNoun(noun);
+export function legacySignatureFromNoun(noun) {
+    const ret = wasm.legacySignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -825,6 +836,7 @@ export function haxHash(v) {
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {Hax} v
  * @returns {Noun}
  */
@@ -834,29 +846,35 @@ export function haxToNoun(v) {
 }
 
 /**
- * @param {NoteV1} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Hax}
  */
-export function noteV1Hash(v) {
-    const ret = wasm.noteV1Hash(v);
-    return ret;
+export function haxFromNoun(noun) {
+    const ret = wasm.haxFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {NoteV1} v
+ * r" Convert into `Noun`.
+ * @param {Pkh} v
  * @returns {Noun}
  */
-export function noteV1ToNoun(v) {
-    const ret = wasm.noteV1ToNoun(v);
+export function pkhToNoun(v) {
+    const ret = wasm.pkhToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteV1}
+ * @returns {Pkh}
  */
-export function noteV1FromNoun(noun) {
-    const ret = wasm.noteV1FromNoun(noun);
+export function pkhFromNoun(noun) {
+    const ret = wasm.pkhFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -864,20 +882,21 @@ export function noteV1FromNoun(noun) {
 }
 
 /**
- * @param {SeedV1} v
+ * @param {Pkh} v
  * @returns {Digest}
  */
-export function seedV1Hash(v) {
-    const ret = wasm.seedV1Hash(v);
+export function pkhHash(v) {
+    const ret = wasm.pkhHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedV1}
+ * @returns {NoteV1}
  */
-export function seedV1FromNoun(noun) {
-    const ret = wasm.seedV1FromNoun(noun);
+export function noteV1FromNoun(noun) {
+    const ret = wasm.noteV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -885,38 +904,31 @@ export function seedV1FromNoun(noun) {
 }
 
 /**
- * @param {SeedV1} v
+ * r" Convert into `Noun`.
+ * @param {NoteV1} v
  * @returns {Noun}
  */
-export function seedV1ToNoun(v) {
-    const ret = wasm.seedV1ToNoun(v);
+export function noteV1ToNoun(v) {
+    const ret = wasm.noteV1ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Witness} v
+ * @param {NoteV1} v
  * @returns {Digest}
  */
-export function witnessHash(v) {
-    const ret = wasm.witnessHash(v);
-    return ret;
-}
-
-/**
- * @param {Witness} v
- * @returns {Noun}
- */
-export function witnessToNoun(v) {
-    const ret = wasm.witnessToNoun(v);
+export function noteV1Hash(v) {
+    const ret = wasm.noteV1Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Witness}
+ * @returns {SeedV1}
  */
-export function witnessFromNoun(noun) {
-    const ret = wasm.witnessFromNoun(noun);
+export function seedV1FromNoun(noun) {
+    const ret = wasm.seedV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -924,24 +936,26 @@ export function witnessFromNoun(noun) {
 }
 
 /**
- * @param {SeedsV1} v
+ * @param {SeedV1} v
  * @returns {Digest}
  */
-export function seedsV1Hash(v) {
-    const ret = wasm.seedsV1Hash(v);
+export function seedV1Hash(v) {
+    const ret = wasm.seedV1Hash(v);
     return ret;
 }
 
 /**
- * @param {SeedsV1} v
+ * r" Convert into `Noun`.
+ * @param {SeedV1} v
  * @returns {Noun}
  */
-export function seedsV1ToNoun(v) {
-    const ret = wasm.seedsV1ToNoun(v);
+export function seedV1ToNoun(v) {
+    const ret = wasm.seedV1ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
  * @returns {SeedsV1}
  */
@@ -954,36 +968,26 @@ export function seedsV1FromNoun(noun) {
 }
 
 /**
- * @param {SpendV1} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {SeedsV1} v
+ * @returns {Noun}
  */
-export function spendV1Hash(v) {
-    const ret = wasm.spendV1Hash(v);
+export function seedsV1ToNoun(v) {
+    const ret = wasm.seedsV1ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {SpendV1}
- */
-export function spendV1FromNoun(noun) {
-    const ret = wasm.spendV1FromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * @param {SpendV1} v
- * @returns {Noun}
+ * @param {SeedsV1} v
+ * @returns {Digest}
  */
-export function spendV1ToNoun(v) {
-    const ret = wasm.spendV1ToNoun(v);
+export function seedsV1Hash(v) {
+    const ret = wasm.seedsV1Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {LockRoot} v
  * @returns {Noun}
  */
@@ -1002,6 +1006,7 @@ export function lockRootHash(v) {
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
  * @returns {LockRoot}
  */
@@ -1014,29 +1019,53 @@ export function lockRootFromNoun(noun) {
 }
 
 /**
- * @param {NoteData} 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]);
+}
+
+/**
+ * @param {LockPrimitive} v
  * @returns {Digest}
  */
-export function noteDataHash(v) {
-    const ret = wasm.noteDataHash(v);
+export function lockPrimitiveHash(v) {
+    const ret = wasm.lockPrimitiveHash(v);
     return ret;
 }
 
 /**
- * @param {NoteData} v
+ * r" Convert into `Noun`.
+ * @param {LockPrimitive} v
  * @returns {Noun}
  */
-export function noteDataToNoun(v) {
-    const ret = wasm.noteDataToNoun(v);
+export function lockPrimitiveToNoun(v) {
+    const ret = wasm.lockPrimitiveToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {SpendCondition} v
+ * @returns {Digest}
+ */
+export function spendConditionHash(v) {
+    const ret = wasm.spendConditionHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteData}
+ * @returns {SpendCondition}
  */
-export function noteDataFromNoun(noun) {
-    const ret = wasm.noteDataFromNoun(noun);
+export function spendConditionFromNoun(noun) {
+    const ret = wasm.spendConditionFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1044,32 +1073,41 @@ export function noteDataFromNoun(noun) {
 }
 
 /**
- * @param {RawTxV1} v
+ * r" Convert into `Noun`.
+ * @param {SpendCondition} v
  * @returns {Noun}
  */
-export function rawTxV1ToNoun(v) {
-    const ret = wasm.rawTxV1ToNoun(v);
+export function spendConditionToNoun(v) {
+    const ret = wasm.spendConditionToNoun(v);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {RawTxV1}
+ * r" Convert into `Noun`.
+ * @param {LockMerkleProof} v
+ * @returns {Noun}
  */
-export function rawTxV1FromNoun(noun) {
-    const ret = wasm.rawTxV1FromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+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);
+    return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendsV1}
+ * @returns {LockMerkleProof}
  */
-export function spendsV1FromNoun(noun) {
-    const ret = wasm.spendsV1FromNoun(noun);
+export function lockMerkleProofFromNoun(noun) {
+    const ret = wasm.lockMerkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1077,38 +1115,54 @@ export function spendsV1FromNoun(noun) {
 }
 
 /**
- * @param {SpendsV1} v
+ * r" Convert into `Noun`.
+ * @param {Name} v
  * @returns {Noun}
  */
-export function spendsV1ToNoun(v) {
-    const ret = wasm.spendsV1ToNoun(v);
+export function nameToNoun(v) {
+    const ret = wasm.nameToNoun(v);
     return ret;
 }
 
 /**
- * @param {SpendsV1} v
+ * @param {Name} v
  * @returns {Digest}
  */
-export function spendsV1Hash(v) {
-    const ret = wasm.spendsV1Hash(v);
+export function nameHash(v) {
+    const ret = wasm.nameHash(v);
     return ret;
 }
 
 /**
- * @param {NockchainTx} v
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Name}
+ */
+export function nameFromNoun(noun) {
+    const ret = wasm.nameFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {RawTxV0} v
  * @returns {Noun}
  */
-export function nockchainTxToNoun(v) {
-    const ret = wasm.nockchainTxToNoun(v);
+export function rawTxV0ToNoun(v) {
+    const ret = wasm.rawTxV0ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NockchainTx}
+ * @returns {RawTxV0}
  */
-export function nockchainTxFromNoun(noun) {
-    const ret = wasm.nockchainTxFromNoun(noun);
+export function rawTxV0FromNoun(noun) {
+    const ret = wasm.rawTxV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1116,11 +1170,12 @@ export function nockchainTxFromNoun(noun) {
 }
 
 /**
+ * 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,47 +1183,54 @@ 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;
 }
 
 /**
- * @param {PkhSignature} v
- * @returns {Noun}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {TimelockRange}
  */
-export function pkhSignatureToNoun(v) {
-    const ret = wasm.pkhSignatureToNoun(v);
-    return ret;
+export function timelockRangeFromNoun(noun) {
+    const ret = wasm.timelockRangeFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {Note} v
+ * r" Convert into `Noun`.
+ * @param {TimelockRange} v
  * @returns {Noun}
  */
-export function noteToNoun(v) {
-    const ret = wasm.noteToNoun(v);
+export function timelockRangeToNoun(v) {
+    const ret = wasm.timelockRangeToNoun(v);
     return ret;
 }
 
 /**
- * @param {Note} v
+ * @param {TimelockRange} v
  * @returns {Digest}
  */
-export function noteHash(v) {
-    const ret = wasm.noteHash(v);
+export function timelockRangeHash(v) {
+    const ret = wasm.timelockRangeHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Note}
+ * @returns {Sig}
  */
-export function noteFromNoun(noun) {
-    const ret = wasm.noteFromNoun(noun);
+export function sigFromNoun(noun) {
+    const ret = wasm.sigFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1176,20 +1238,31 @@ export function noteFromNoun(noun) {
 }
 
 /**
- * @param {MerkleProof} v
+ * r" Convert into `Noun`.
+ * @param {Sig} v
+ * @returns {Noun}
+ */
+export function sigToNoun(v) {
+    const ret = wasm.sigToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {Sig} v
  * @returns {Digest}
  */
-export function merkleProofHash(v) {
-    const ret = wasm.merkleProofHash(v);
+export function sigHash(v) {
+    const ret = wasm.sigHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {MerkleProof}
+ * @returns {Input}
  */
-export function merkleProofFromNoun(noun) {
-    const ret = wasm.merkleProofFromNoun(noun);
+export function inputFromNoun(noun) {
+    const ret = wasm.inputFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1197,38 +1270,50 @@ export function merkleProofFromNoun(noun) {
 }
 
 /**
- * @param {MerkleProof} v
- * @returns {Noun}
+ * @param {Input} v
+ * @returns {Digest}
  */
-export function merkleProofToNoun(v) {
-    const ret = wasm.merkleProofToNoun(v);
+export function inputHash(v) {
+    const ret = wasm.inputHash(v);
     return ret;
 }
 
 /**
- * @param {LockPrimitive} v
+ * r" Convert into `Noun`.
+ * @param {Input} v
  * @returns {Noun}
  */
-export function lockPrimitiveToNoun(v) {
-    const ret = wasm.lockPrimitiveToNoun(v);
+export function inputToNoun(v) {
+    const ret = wasm.inputToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockPrimitive} v
+ * @param {Inputs} v
  * @returns {Digest}
  */
-export function lockPrimitiveHash(v) {
-    const ret = wasm.lockPrimitiveHash(v);
+export function inputsHash(v) {
+    const ret = wasm.inputsHash(v);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {LockPrimitive}
+ * r" Convert into `Noun`.
+ * @param {Inputs} v
+ * @returns {Noun}
  */
-export function lockPrimitiveFromNoun(noun) {
-    const ret = wasm.lockPrimitiveFromNoun(noun);
+export function inputsToNoun(v) {
+    const ret = wasm.inputsToNoun(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]);
     }
@@ -1236,29 +1321,31 @@ export function lockPrimitiveFromNoun(noun) {
 }
 
 /**
- * @param {Version} v
+ * @param {NoteV0} v
  * @returns {Digest}
  */
-export function versionHash(v) {
-    const ret = wasm.versionHash(v);
+export function noteV0Hash(v) {
+    const ret = wasm.noteV0Hash(v);
     return ret;
 }
 
 /**
- * @param {Version} v
+ * r" Convert into `Noun`.
+ * @param {NoteV0} v
  * @returns {Noun}
  */
-export function versionToNoun(v) {
-    const ret = wasm.versionToNoun(v);
+export function noteV0ToNoun(v) {
+    const ret = wasm.noteV0ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Version}
+ * @returns {NoteV0}
  */
-export function versionFromNoun(noun) {
-    const ret = wasm.versionFromNoun(noun);
+export function noteV0FromNoun(noun) {
+    const ret = wasm.noteV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1266,11 +1353,21 @@ export function versionFromNoun(noun) {
 }
 
 /**
+ * @param {SeedV0} v
+ * @returns {Digest}
+ */
+export function seedV0Hash(v) {
+    const ret = wasm.seedV0Hash(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Sig}
+ * @returns {SeedV0}
  */
-export function sigFromNoun(noun) {
-    const ret = wasm.sigFromNoun(noun);
+export function seedV0FromNoun(noun) {
+    const ret = wasm.seedV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1278,38 +1375,32 @@ export function sigFromNoun(noun) {
 }
 
 /**
- * @param {Sig} v
+ * r" Convert into `Noun`.
+ * @param {SeedV0} v
  * @returns {Noun}
  */
-export function sigToNoun(v) {
-    const ret = wasm.sigToNoun(v);
-    return ret;
-}
-
-/**
- * @param {Sig} v
- * @returns {Digest}
- */
-export function sigHash(v) {
-    const ret = wasm.sigHash(v);
+export function seedV0ToNoun(v) {
+    const ret = wasm.seedV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {TimelockIntent} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {SeedsV0} v
+ * @returns {Noun}
  */
-export function timelockIntentHash(v) {
-    const ret = wasm.timelockIntentHash(v);
+export function seedsV0ToNoun(v) {
+    const ret = wasm.seedsV0ToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockIntent}
+ * @returns {SeedsV0}
  */
-export function timelockIntentFromNoun(noun) {
-    const ret = wasm.timelockIntentFromNoun(noun);
+export function seedsV0FromNoun(noun) {
+    const ret = wasm.seedsV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1317,20 +1408,30 @@ export function timelockIntentFromNoun(noun) {
 }
 
 /**
- * @param {TimelockIntent} v
- * @returns {Noun}
+ * @param {SeedsV0} v
+ * @returns {Digest}
  */
-export function timelockIntentToNoun(v) {
-    const ret = wasm.timelockIntentToNoun(v);
+export function seedsV0Hash(v) {
+    const ret = wasm.seedsV0Hash(v);
+    return ret;
+}
+
+/**
+ * @param {SpendV0} v
+ * @returns {Digest}
+ */
+export function spendV0Hash(v) {
+    const ret = wasm.spendV0Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LegacySignature}
+ * @returns {SpendV0}
  */
-export function legacySignatureFromNoun(noun) {
-    const ret = wasm.legacySignatureFromNoun(noun);
+export function spendV0FromNoun(noun) {
+    const ret = wasm.spendV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1338,47 +1439,41 @@ export function legacySignatureFromNoun(noun) {
 }
 
 /**
- * @param {LegacySignature} v
+ * r" Convert into `Noun`.
+ * @param {SpendV0} v
  * @returns {Noun}
  */
-export function legacySignatureToNoun(v) {
-    const ret = wasm.legacySignatureToNoun(v);
-    return ret;
-}
-
-/**
- * @param {LegacySignature} v
- * @returns {Digest}
- */
-export function legacySignatureHash(v) {
-    const ret = wasm.legacySignatureHash(v);
+export function spendV0ToNoun(v) {
+    const ret = wasm.spendV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Name} v
+ * r" Convert into `Noun`.
+ * @param {Timelock} v
  * @returns {Noun}
  */
-export function nameToNoun(v) {
-    const ret = wasm.nameToNoun(v);
+export function timelockToNoun(v) {
+    const ret = wasm.timelockToNoun(v);
     return ret;
 }
 
 /**
- * @param {Name} v
+ * @param {Timelock} v
  * @returns {Digest}
  */
-export function nameHash(v) {
-    const ret = wasm.nameHash(v);
+export function timelockHash(v) {
+    const ret = wasm.timelockHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Name}
+ * @returns {Timelock}
  */
-export function nameFromNoun(noun) {
-    const ret = wasm.nameFromNoun(noun);
+export function timelockFromNoun(noun) {
+    const ret = wasm.timelockFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1386,29 +1481,21 @@ export function nameFromNoun(noun) {
 }
 
 /**
- * @param {Source} v
- * @returns {Noun}
- */
-export function sourceToNoun(v) {
-    const ret = wasm.sourceToNoun(v);
-    return ret;
-}
-
-/**
- * @param {Source} v
+ * @param {Witness} v
  * @returns {Digest}
  */
-export function sourceHash(v) {
-    const ret = wasm.sourceHash(v);
+export function witnessHash(v) {
+    const ret = wasm.witnessHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Source}
+ * @returns {Witness}
  */
-export function sourceFromNoun(noun) {
-    const ret = wasm.sourceFromNoun(noun);
+export function witnessFromNoun(noun) {
+    const ret = wasm.witnessFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1416,29 +1503,22 @@ export function sourceFromNoun(noun) {
 }
 
 /**
- * @param {NoteV0} v
- * @returns {Digest}
- */
-export function noteV0Hash(v) {
-    const ret = wasm.noteV0Hash(v);
-    return ret;
-}
-
-/**
- * @param {NoteV0} v
+ * r" Convert into `Noun`.
+ * @param {Witness} v
  * @returns {Noun}
  */
-export function noteV0ToNoun(v) {
-    const ret = wasm.noteV0ToNoun(v);
+export function witnessToNoun(v) {
+    const ret = wasm.witnessToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteV0}
+ * @returns {SpendV1}
  */
-export function noteV0FromNoun(noun) {
-    const ret = wasm.noteV0FromNoun(noun);
+export function spendV1FromNoun(noun) {
+    const ret = wasm.spendV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1446,41 +1526,40 @@ export function noteV0FromNoun(noun) {
 }
 
 /**
- * @param {Noun} noun
- * @returns {Pkh}
+ * @param {SpendV1} v
+ * @returns {Digest}
  */
-export function pkhFromNoun(noun) {
-    const ret = wasm.pkhFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1Hash(v) {
+    const ret = wasm.spendV1Hash(v);
+    return ret;
 }
 
 /**
- * @param {Pkh} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {SpendV1} v
+ * @returns {Noun}
  */
-export function pkhHash(v) {
-    const ret = wasm.pkhHash(v);
+export function spendV1ToNoun(v) {
+    const ret = wasm.spendV1ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Pkh} v
- * @returns {Noun}
+ * @param {NoteData} v
+ * @returns {Digest}
  */
-export function pkhToNoun(v) {
-    const ret = wasm.pkhToNoun(v);
+export function noteDataHash(v) {
+    const ret = wasm.noteDataHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {WitnessData}
+ * @returns {NoteData}
  */
-export function witnessDataFromNoun(noun) {
-    const ret = wasm.witnessDataFromNoun(noun);
+export function noteDataFromNoun(noun) {
+    const ret = wasm.noteDataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1488,38 +1567,54 @@ export function witnessDataFromNoun(noun) {
 }
 
 /**
- * @param {WitnessData} v
+ * r" Convert into `Noun`.
+ * @param {NoteData} v
  * @returns {Noun}
  */
-export function witnessDataToNoun(v) {
-    const ret = wasm.witnessDataToNoun(v);
+export function noteDataToNoun(v) {
+    const ret = wasm.noteDataToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockMetadata} v
+ * r" Convert into `Noun`.
+ * @param {RawTxV1} v
  * @returns {Noun}
  */
-export function lockMetadataToNoun(v) {
-    const ret = wasm.lockMetadataToNoun(v);
+export function rawTxV1ToNoun(v) {
+    const ret = wasm.rawTxV1ToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockMetadata} v
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {RawTxV1}
+ */
+export function rawTxV1FromNoun(noun) {
+    const ret = wasm.rawTxV1FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {SpendsV1} v
  * @returns {Digest}
  */
-export function lockMetadataHash(v) {
-    const ret = wasm.lockMetadataHash(v);
+export function spendsV1Hash(v) {
+    const ret = wasm.spendsV1Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockMetadata}
+ * @returns {SpendsV1}
  */
-export function lockMetadataFromNoun(noun) {
-    const ret = wasm.lockMetadataFromNoun(noun);
+export function spendsV1FromNoun(noun) {
+    const ret = wasm.spendsV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1527,29 +1622,41 @@ export function lockMetadataFromNoun(noun) {
 }
 
 /**
- * @param {TimelockRange} v
+ * r" Convert into `Noun`.
+ * @param {SpendsV1} v
+ * @returns {Noun}
+ */
+export function spendsV1ToNoun(v) {
+    const ret = wasm.spendsV1ToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {MerkleProof} v
  * @returns {Digest}
  */
-export function timelockRangeHash(v) {
-    const ret = wasm.timelockRangeHash(v);
+export function merkleProofHash(v) {
+    const ret = wasm.merkleProofHash(v);
     return ret;
 }
 
 /**
- * @param {TimelockRange} v
+ * r" Convert into `Noun`.
+ * @param {MerkleProof} v
  * @returns {Noun}
  */
-export function timelockRangeToNoun(v) {
-    const ret = wasm.timelockRangeToNoun(v);
+export function merkleProofToNoun(v) {
+    const ret = wasm.merkleProofToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockRange}
+ * @returns {MerkleProof}
  */
-export function timelockRangeFromNoun(noun) {
-    const ret = wasm.timelockRangeFromNoun(noun);
+export function merkleProofFromNoun(noun) {
+    const ret = wasm.merkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1557,29 +1664,22 @@ export function timelockRangeFromNoun(noun) {
 }
 
 /**
- * @param {SeedV0} v
- * @returns {Digest}
- */
-export function seedV0Hash(v) {
-    const ret = wasm.seedV0Hash(v);
-    return ret;
-}
-
-/**
- * @param {SeedV0} v
+ * r" Convert into `Noun`.
+ * @param {NockchainTx} v
  * @returns {Noun}
  */
-export function seedV0ToNoun(v) {
-    const ret = wasm.seedV0ToNoun(v);
+export function nockchainTxToNoun(v) {
+    const ret = wasm.nockchainTxToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedV0}
+ * @returns {NockchainTx}
  */
-export function seedV0FromNoun(noun) {
-    const ret = wasm.seedV0FromNoun(noun);
+export function nockchainTxFromNoun(noun) {
+    const ret = wasm.nockchainTxFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1587,29 +1687,31 @@ export function seedV0FromNoun(noun) {
 }
 
 /**
- * @param {Timelock} v
+ * r" Convert into `Noun`.
+ * @param {PkhSignature} v
  * @returns {Noun}
  */
-export function timelockToNoun(v) {
-    const ret = wasm.timelockToNoun(v);
+export function pkhSignatureToNoun(v) {
+    const ret = wasm.pkhSignatureToNoun(v);
     return ret;
 }
 
 /**
- * @param {Timelock} v
+ * @param {PkhSignature} v
  * @returns {Digest}
  */
-export function timelockHash(v) {
-    const ret = wasm.timelockHash(v);
+export function pkhSignatureHash(v) {
+    const ret = wasm.pkhSignatureHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Timelock}
+ * @returns {PkhSignature}
  */
-export function timelockFromNoun(noun) {
-    const ret = wasm.timelockFromNoun(noun);
+export function pkhSignatureFromNoun(noun) {
+    const ret = wasm.pkhSignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1617,11 +1719,22 @@ export function timelockFromNoun(noun) {
 }
 
 /**
+ * r" Convert into `Noun`.
+ * @param {TransactionDisplay} v
+ * @returns {Noun}
+ */
+export function transactionDisplayToNoun(v) {
+    const ret = wasm.transactionDisplayToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {RawTxV0}
+ * @returns {TransactionDisplay}
  */
-export function rawTxV0FromNoun(noun) {
-    const ret = wasm.rawTxV0FromNoun(noun);
+export function transactionDisplayFromNoun(noun) {
+    const ret = wasm.transactionDisplayFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1629,29 +1742,31 @@ export function rawTxV0FromNoun(noun) {
 }
 
 /**
- * @param {RawTxV0} v
- * @returns {Noun}
+ * @param {Note} v
+ * @returns {Digest}
  */
-export function rawTxV0ToNoun(v) {
-    const ret = wasm.rawTxV0ToNoun(v);
+export function noteHash(v) {
+    const ret = wasm.noteHash(v);
     return ret;
 }
 
 /**
- * @param {InputDisplay} v
+ * r" Convert into `Noun`.
+ * @param {Note} v
  * @returns {Noun}
  */
-export function inputDisplayToNoun(v) {
-    const ret = wasm.inputDisplayToNoun(v);
+export function noteToNoun(v) {
+    const ret = wasm.noteToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {InputDisplay}
+ * @returns {Note}
  */
-export function inputDisplayFromNoun(noun) {
-    const ret = wasm.inputDisplayFromNoun(noun);
+export function noteFromNoun(noun) {
+    const ret = wasm.noteFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1659,11 +1774,12 @@ export function inputDisplayFromNoun(noun) {
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendCondition}
+ * @returns {Source}
  */
-export function spendConditionFromNoun(noun) {
-    const ret = wasm.spendConditionFromNoun(noun);
+export function sourceFromNoun(noun) {
+    const ret = wasm.sourceFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1671,47 +1787,54 @@ export function spendConditionFromNoun(noun) {
 }
 
 /**
- * @param {SpendCondition} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Source} v
+ * @returns {Noun}
  */
-export function spendConditionHash(v) {
-    const ret = wasm.spendConditionHash(v);
+export function sourceToNoun(v) {
+    const ret = wasm.sourceToNoun(v);
     return ret;
 }
 
 /**
- * @param {SpendCondition} v
- * @returns {Noun}
+ * @param {Source} v
+ * @returns {Digest}
  */
-export function spendConditionToNoun(v) {
-    const ret = wasm.spendConditionToNoun(v);
+export function sourceHash(v) {
+    const ret = wasm.sourceHash(v);
     return ret;
 }
 
 /**
- * @param {LockMerkleProof} v
+ * r" Convert into `Noun`.
+ * @param {Balance} v
  * @returns {Noun}
  */
-export function lockMerkleProofToNoun(v) {
-    const ret = wasm.lockMerkleProofToNoun(v);
+export function balanceToNoun(v) {
+    const ret = wasm.balanceToNoun(v);
     return ret;
 }
 
 /**
- * @param {LockMerkleProof} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Balance}
  */
-export function lockMerkleProofHash(v) {
-    const ret = wasm.lockMerkleProofHash(v);
-    return ret;
+export function balanceFromNoun(noun) {
+    const ret = wasm.balanceFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockMerkleProof}
+ * @returns {BalanceUpdate}
  */
-export function lockMerkleProofFromNoun(noun) {
-    const ret = wasm.lockMerkleProofFromNoun(noun);
+export function balanceUpdateFromNoun(noun) {
+    const ret = wasm.balanceUpdateFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1719,41 +1842,32 @@ export function lockMerkleProofFromNoun(noun) {
 }
 
 /**
- * @param {TransactionDisplay} v
+ * r" Convert into `Noun`.
+ * @param {BalanceUpdate} v
  * @returns {Noun}
  */
-export function transactionDisplayToNoun(v) {
-    const ret = wasm.transactionDisplayToNoun(v);
+export function balanceUpdateToNoun(v) {
+    const ret = wasm.balanceUpdateToNoun(v);
     return ret;
 }
 
 /**
- * @param {Noun} noun
- * @returns {TransactionDisplay}
- */
-export function transactionDisplayFromNoun(noun) {
-    const ret = wasm.transactionDisplayFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * @param {Balance} v
+ * r" Convert into `Noun`.
+ * @param {NoteInner} v
  * @returns {Noun}
  */
-export function balanceToNoun(v) {
-    const ret = wasm.balanceToNoun(v);
+export function noteInnerToNoun(v) {
+    const ret = wasm.noteInnerToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Balance}
+ * @returns {NoteInner}
  */
-export function balanceFromNoun(noun) {
-    const ret = wasm.balanceFromNoun(noun);
+export function noteInnerFromNoun(noun) {
+    const ret = wasm.noteInnerFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1761,35 +1875,27 @@ export function balanceFromNoun(noun) {
 }
 
 /**
- * @param {BalanceUpdate} v
- * @returns {Noun}
+ * @param {NoteInner} v
+ * @returns {Digest}
  */
-export function balanceUpdateToNoun(v) {
-    const ret = wasm.balanceUpdateToNoun(v);
+export function noteInnerHash(v) {
+    const ret = wasm.noteInnerHash(v);
     return ret;
 }
 
 /**
+ * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {BalanceUpdate}
+ * @returns {Digest}
  */
-export function balanceUpdateFromNoun(noun) {
-    const ret = wasm.balanceUpdateFromNoun(noun);
+export function digestFromNoun(noun) {
+    const ret = wasm.digestFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {Digest} v
- * @returns {Noun}
- */
-export function digestToNoun(v) {
-    const ret = wasm.digestToNoun(v);
-    return ret;
-}
-
 /**
  * @param {Digest} v
  * @returns {Digest}
@@ -1800,15 +1906,13 @@ export function digestHash(v) {
 }
 
 /**
- * @param {Noun} noun
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Digest} v
+ * @returns {Noun}
  */
-export function digestFromNoun(noun) {
-    const ret = wasm.digestFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function digestToNoun(v) {
+    const ret = wasm.digestToNoun(v);
+    return ret;
 }
 
 function wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2) {
@@ -2461,32 +2565,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 +2572,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 +2581,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 +2651,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 +2679,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 +2687,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 +2695,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;
@@ -2727,10 +2729,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 +2753,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 +2781,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 +2838,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,26 +2867,11 @@ 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`.
+    imports.wbg.__wbindgen_cast_5ab4f7c847d67190 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 355, function: Function { arguments: [Externref], shim_idx: 356, 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;
-        return ret;
-    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_externrefs;
         const offset = table.grow(4);