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

package/iris_wasm.js

@@ -214,10 +214,15 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 
-function takeFromExternrefTable0(idx) {
-    const value = wasm.__wbindgen_externrefs.get(idx);
-    wasm.__externref_table_dealloc(idx);
-    return value;
+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) {
@@ -226,106 +231,86 @@ function passArray8ToWasm0(arg, malloc) {
     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}`);
+    }
+}
 /**
- * Hash a public key to get its digest (for use in PKH)
- * @param {Uint8Array} public_key_bytes
- * @returns {string}
+ * 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 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);
-    }
+export function spendConditionToProtobuf(value) {
+    const ret = wasm.spendConditionToProtobuf(value);
+    return ret;
 }
 
 /**
- * Hash a noun (jam as input)
- * @param {Uint8Array} noun
- * @returns {string}
+ * @param {Digest} d
+ * @returns {PbCom1Hash}
  */
-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 digestToProtobuf(d) {
+    const ret = wasm.digestToProtobuf(d);
+    return ret;
 }
 
 /**
- * Hash a u64 value
- * @param {bigint} value
- * @returns {string}
+ * @param {Note} note
+ * @returns {PbCom2Note}
  */
-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);
-    }
+export function noteToProtobuf(note) {
+    const ret = wasm.noteToProtobuf(note);
+    return ret;
 }
 
 /**
- * Derive master key from BIP39 mnemonic phrase
- * @param {string} mnemonic
- * @param {string | null} [passphrase]
- * @returns {ExtendedKey}
+ * @param {PbCom1Hash} value
+ * @returns {Digest}
  */
-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);
+export function digestFromProtobuf(value) {
+    const ret = wasm.digestFromProtobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ExtendedKey.__wrap(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * Sign a message string with a private key
- * @param {Uint8Array} private_key_bytes
- * @param {string} message
- * @returns {Signature}
+ * Return default transaction engine settings for V1 signing.
+ * @returns {TxEngineSettings}
  */
-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 txEngineSettingsV1Default() {
+    const ret = wasm.txEngineSettingsV1Default();
+    return ret;
+}
+
+/**
+ * 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 spendConditionFromProtobuf(value) {
+    const ret = wasm.spendConditionFromProtobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -333,51 +318,49 @@ export function signMessage(private_key_bytes, message) {
 }
 
 /**
- * Derive master key from seed bytes
- * @param {Uint8Array} seed
- * @returns {ExtendedKey}
+ * @param {PbCom2Note} value
+ * @returns {Note}
  */
-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 noteFromProtobuf(value) {
+    const ret = wasm.noteFromProtobuf(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * Verify a signature with a public key
- * @param {Uint8Array} public_key_bytes
- * @param {Signature} signature
- * @param {string} message
- * @returns {boolean}
+ * @param {PbCom2RawTransaction} tx
+ * @returns {RawTx}
  */
-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);
+export function rawTxFromProtobuf(tx) {
+    const ret = wasm.rawTxFromProtobuf(tx);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0] !== 0;
+    return takeFromExternrefTable0(ret[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.
+ * Convert raw transaction into protobuf format.
  *
- * If a transaction contains non-based (not-fitting) atoms, it will be rejected.
- * @param {string} s
- * @returns {Noun}
+ * 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 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 rawTxToProtobuf(tx) {
+    const ret = wasm.rawTxToProtobuf(tx);
+    return ret;
+}
+
+/**
+ * Return default transaction engine settings for V1 Bythos signing.
+ * @returns {TxEngineSettings}
+ */
+export function txEngineSettingsV1BythosDefault() {
+    const ret = wasm.txEngineSettingsV1BythosDefault();
     return ret;
 }
 
@@ -448,18 +431,6 @@ export function jam(noun) {
     return v1;
 }
 
-/**
- * Convert string to an Atom.
- * @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;
-}
-
 /**
  * Convert an Atom to belts.
  * @param {Noun} atom
@@ -473,90 +444,60 @@ export function atom_to_belts(atom) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-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}`);
-    }
-}
 /**
+ * Convert string to an Atom.
  * @param {string} s
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function hex_to_digest(s) {
+export function tas(s) {
     const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.hex_to_digest(ptr0, len0);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+    const ret = wasm.tas(ptr0, len0);
+    return ret;
 }
 
 /**
- * @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 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 create_note_v0(origin_page, sig_m, sig_pubkeys, source_hash, is_coinbase, timelock, assets) {
-    const ptr0 = passArrayJsValueToWasm0(sig_pubkeys, wasm.__wbindgen_malloc);
+export function tas_belts(s) {
+    const ptr0 = passStringToWasm0(s, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     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);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+    const ret = wasm.tas_belts(ptr0, len0);
+    return ret;
 }
 
 /**
- * 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}
+ * Derive master key from seed bytes
+ * @param {Uint8Array} seed
+ * @returns {ExtendedKey}
  */
-export function rawTxToProtobuf(tx) {
-    const ret = wasm.rawTxToProtobuf(tx);
-    return ret;
+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);
 }
 
 /**
- * @param {Version} version
- * @param {number} origin_page
- * @param {Name} name
- * @param {NoteData} note_data
- * @param {Nicks} assets
- * @returns {Note}
+ * Sign a message string with a private key
+ * @param {Uint8Array} private_key_bytes
+ * @param {string} message
+ * @returns {Signature}
  */
-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 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);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -564,36 +505,60 @@ export function create_note_v1(version, origin_page, name, note_data, assets) {
 }
 
 /**
- * @param {PbCom1Hash} value
- * @returns {Digest}
+ * Verify a signature with a public key
+ * @param {Uint8Array} public_key_bytes
+ * @param {Signature} signature
+ * @param {string} message
+ * @returns {boolean}
  */
-export function digest_from_protobuf(value) {
-    const ret = wasm.digest_from_protobuf(value);
+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;
 }
 
 /**
- * Lossily convert raw transaction into a nockchain transaction, splitting witness away.
- * @param {RawTxV1} tx
- * @returns {NockchainTx}
+ * Hash a noun (jam as input)
+ * @param {Uint8Array} noun
+ * @returns {string}
  */
-export function rawTxToNockchainTx(tx) {
-    const ret = wasm.rawTxToNockchainTx(tx);
-    return ret;
+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);
+    }
 }
 
 /**
- * @param {Digest} d
+ * Hash a u64 value
+ * @param {bigint} value
  * @returns {string}
  */
-export function digest_to_hex(d) {
+export function hashU64(value) {
     let deferred1_0;
     let deferred1_1;
     try {
-        const ret = wasm.digest_to_hex(d);
+        const ret = wasm.hashU64(value);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -603,49 +568,130 @@ export function digest_to_hex(d) {
 }
 
 /**
- * @param {Note} note
- * @returns {PbCom2Note}
+ * Derive master key from BIP39 mnemonic phrase
+ * @param {string} mnemonic
+ * @param {string | null} [passphrase]
+ * @returns {ExtendedKey}
  */
-export function note_to_protobuf(note) {
-    const ret = wasm.note_to_protobuf(note);
+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);
+    }
+}
+
+/**
+ * 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 seedV0Hash(v) {
+    const ret = wasm.seedV0Hash(v);
     return ret;
 }
 
 /**
- * @param {RawTx} tx
- * @returns {Note[]}
+ * r" Convert into `Noun`.
+ * @param {SeedV0} v
+ * @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 seedV0ToNoun(v) {
+    const ret = wasm.seedV0ToNoun(v);
+    return ret;
 }
 
 /**
- * @param {Digest} d
- * @returns {PbCom1Hash}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {RawTxV0}
+ */
+export function rawTxV0FromNoun(noun) {
+    const ret = wasm.rawTxV0FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {RawTxV0} v
+ * @returns {Noun}
  */
-export function digest_to_protobuf(d) {
-    const ret = wasm.digest_to_protobuf(d);
+export function rawTxV0ToNoun(v) {
+    const ret = wasm.rawTxV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {Note} note
+ * r" Convert into `Noun`.
+ * @param {TimelockIntent} v
+ * @returns {Noun}
+ */
+export function timelockIntentToNoun(v) {
+    const ret = wasm.timelockIntentToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {TimelockIntent} v
  * @returns {Digest}
  */
-export function note_hash(note) {
-    const ret = wasm.note_hash(note);
+export function timelockIntentHash(v) {
+    const ret = wasm.timelockIntentHash(v);
     return ret;
 }
 
 /**
- * @param {PbCom2Note} value
- * @returns {Note}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {TimelockIntent}
  */
-export function note_from_protobuf(value) {
-    const ret = wasm.note_from_protobuf(value);
+export function timelockIntentFromNoun(noun) {
+    const ret = wasm.timelockIntentFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -653,11 +699,66 @@ export function note_from_protobuf(value) {
 }
 
 /**
- * @param {PbCom2RawTransaction} tx
- * @returns {RawTx}
+ * @param {Pkh} pkh
+ * @returns {NoteData}
  */
-export function rawTxFromProtobuf(tx) {
-    const ret = wasm.rawTxFromProtobuf(tx);
+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 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 {LockMetadata}
+ */
+export function lockMetadataFromNoun(noun) {
+    const ret = wasm.lockMetadataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -665,33 +766,44 @@ export function rawTxFromProtobuf(tx) {
 }
 
 /**
- * Convert NockchainTx into RawTx by recombining witness_data with the transaction, and
- * recalculating the transaction ID.
- * @param {NockchainTx} tx
- * @returns {RawTx}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {LockPrimitive}
  */
-export function nockchainTxToRaw(tx) {
-    const ret = wasm.nockchainTxToRaw(tx);
-    return ret;
+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 {WitnessData} v
+ * @param {LockPrimitive} v
  * @returns {Noun}
  */
-export function witnessDataToNoun(v) {
-    const ret = wasm.witnessDataToNoun(v);
+export function lockPrimitiveToNoun(v) {
+    const ret = wasm.lockPrimitiveToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {LockPrimitive} v
+ * @returns {Digest}
+ */
+export function lockPrimitiveHash(v) {
+    const ret = wasm.lockPrimitiveHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {WitnessData}
+ * @returns {Name}
  */
-export function witnessDataFromNoun(noun) {
-    const ret = wasm.witnessDataFromNoun(noun);
+export function nameFromNoun(noun) {
+    const ret = wasm.nameFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -699,44 +811,82 @@ export function witnessDataFromNoun(noun) {
 }
 
 /**
- * @param {LockMetadata} v
+ * r" Convert into `Noun`.
+ * @param {Name} v
+ * @returns {Noun}
+ */
+export function nameToNoun(v) {
+    const ret = wasm.nameToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {Name} v
  * @returns {Digest}
  */
-export function lockMetadataHash(v) {
-    const ret = wasm.lockMetadataHash(v);
+export function nameHash(v) {
+    const ret = wasm.nameHash(v);
+    return ret;
+}
+
+/**
+ * @param {Hax} v
+ * @returns {Digest}
+ */
+export function haxHash(v) {
+    const ret = wasm.haxHash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {LockMetadata} v
+ * @param {Hax} v
+ * @returns {Noun}
+ */
+export function haxToNoun(v) {
+    const ret = wasm.haxToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Hax}
+ */
+export function haxFromNoun(noun) {
+    const ret = wasm.haxFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {Pkh} v
  * @returns {Noun}
  */
-export function lockMetadataToNoun(v) {
-    const ret = wasm.lockMetadataToNoun(v);
+export function pkhToNoun(v) {
+    const ret = wasm.pkhToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {LockMetadata}
+ * @param {Pkh} v
+ * @returns {Digest}
  */
-export function lockMetadataFromNoun(noun) {
-    const ret = wasm.lockMetadataFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function pkhHash(v) {
+    const ret = wasm.pkhHash(v);
+    return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Version}
+ * @returns {Pkh}
  */
-export function versionFromNoun(noun) {
-    const ret = wasm.versionFromNoun(noun);
+export function pkhFromNoun(noun) {
+    const ret = wasm.pkhFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -744,41 +894,52 @@ export function versionFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {Version} v
- * @returns {Noun}
+ * @param {Digest} hash
+ * @returns {Pkh}
  */
-export function versionToNoun(v) {
-    const ret = wasm.versionToNoun(v);
+export function pkhSingle(hash) {
+    const ret = wasm.pkhSingle(hash);
     return ret;
 }
 
 /**
- * @param {Version} v
+ * @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 versionHash(v) {
-    const ret = wasm.versionHash(v);
+export function spendConditionHash(v) {
+    const ret = wasm.spendConditionHash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {TimelockIntent} v
+ * @param {SpendCondition} v
  * @returns {Noun}
  */
-export function timelockIntentToNoun(v) {
-    const ret = wasm.timelockIntentToNoun(v);
+export function spendConditionToNoun(v) {
+    const ret = wasm.spendConditionToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockIntent}
+ * @returns {SpendCondition}
  */
-export function timelockIntentFromNoun(noun) {
-    const ret = wasm.timelockIntentFromNoun(noun);
+export function spendConditionFromNoun(noun) {
+    const ret = wasm.spendConditionFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -786,40 +947,72 @@ export function timelockIntentFromNoun(noun) {
 }
 
 /**
- * @param {TimelockIntent} v
- * @returns {Digest}
+ * @param {Pkh} pkh
+ * @returns {SpendCondition}
  */
-export function timelockIntentHash(v) {
-    const ret = wasm.timelockIntentHash(v);
+export function spendConditionNewPkh(pkh) {
+    const ret = wasm.spendConditionNewPkh(pkh);
     return ret;
 }
 
 /**
- * @param {LegacySignature} v
+ * @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 legacySignatureHash(v) {
-    const ret = wasm.legacySignatureHash(v);
+export function spendConditionFirstName(obj) {
+    const ret = wasm.spendConditionFirstName(obj);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {LegacySignature} v
- * @returns {Noun}
+ * @param {SpendCondition} obj
+ * @returns {Pkh[]}
  */
-export function legacySignatureToNoun(v) {
-    const ret = wasm.legacySignatureToNoun(v);
-    return ret;
+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 {LegacySignature}
+ * @returns {Source}
  */
-export function legacySignatureFromNoun(noun) {
-    const ret = wasm.legacySignatureFromNoun(noun);
+export function sourceFromNoun(noun) {
+    const ret = wasm.sourceFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -827,54 +1020,50 @@ export function legacySignatureFromNoun(noun) {
 }
 
 /**
- * @param {Hax} v
+ * @param {Source} v
  * @returns {Digest}
  */
-export function haxHash(v) {
-    const ret = wasm.haxHash(v);
+export function sourceHash(v) {
+    const ret = wasm.sourceHash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {Hax} v
+ * @param {Source} v
  * @returns {Noun}
  */
-export function haxToNoun(v) {
-    const ret = wasm.haxToNoun(v);
+export function sourceToNoun(v) {
+    const ret = wasm.sourceToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Hax}
+ * @param {TimelockRange} v
+ * @returns {Digest}
  */
-export function haxFromNoun(noun) {
-    const ret = wasm.haxFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function timelockRangeHash(v) {
+    const ret = wasm.timelockRangeHash(v);
+    return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {Pkh} v
+ * @param {TimelockRange} v
  * @returns {Noun}
  */
-export function pkhToNoun(v) {
-    const ret = wasm.pkhToNoun(v);
+export function timelockRangeToNoun(v) {
+    const ret = wasm.timelockRangeToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Pkh}
+ * @returns {TimelockRange}
  */
-export function pkhFromNoun(noun) {
-    const ret = wasm.pkhFromNoun(noun);
+export function timelockRangeFromNoun(noun) {
+    const ret = wasm.timelockRangeFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -882,21 +1071,50 @@ export function pkhFromNoun(noun) {
 }
 
 /**
- * @param {Pkh} v
+ * @param {RawTx} obj
+ * @returns {Version}
+ */
+export function rawTxVersion(obj) {
+    const ret = wasm.rawTxVersion(obj);
+    return ret;
+}
+
+/**
+ * @param {RawTx} obj
  * @returns {Digest}
  */
-export function pkhHash(v) {
-    const ret = wasm.pkhHash(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 {NoteV1}
+ * @returns {Input}
  */
-export function noteV1FromNoun(noun) {
-    const ret = wasm.noteV1FromNoun(noun);
+export function inputFromNoun(noun) {
+    const ret = wasm.inputFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -905,62 +1123,53 @@ export function noteV1FromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {NoteV1} v
+ * @param {Input} v
  * @returns {Noun}
  */
-export function noteV1ToNoun(v) {
-    const ret = wasm.noteV1ToNoun(v);
+export function inputToNoun(v) {
+    const ret = wasm.inputToNoun(v);
     return ret;
 }
 
 /**
- * @param {NoteV1} v
+ * @param {Inputs} v
  * @returns {Digest}
  */
-export function noteV1Hash(v) {
-    const ret = wasm.noteV1Hash(v);
+export function inputsHash(v) {
+    const ret = wasm.inputsHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedV1}
+ * @returns {Inputs}
  */
-export function seedV1FromNoun(noun) {
-    const ret = wasm.seedV1FromNoun(noun);
+export function inputsFromNoun(noun) {
+    const ret = wasm.inputsFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {SeedV1} v
- * @returns {Digest}
- */
-export function seedV1Hash(v) {
-    const ret = wasm.seedV1Hash(v);
-    return ret;
-}
-
 /**
  * r" Convert into `Noun`.
- * @param {SeedV1} v
+ * @param {Inputs} v
  * @returns {Noun}
  */
-export function seedV1ToNoun(v) {
-    const ret = wasm.seedV1ToNoun(v);
+export function inputsToNoun(v) {
+    const ret = wasm.inputsToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedsV1}
+ * @returns {SeedsV0}
  */
-export function seedsV1FromNoun(noun) {
-    const ret = wasm.seedsV1FromNoun(noun);
+export function seedsV0FromNoun(noun) {
+    const ret = wasm.seedsV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -969,62 +1178,104 @@ export function seedsV1FromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {SeedsV1} v
+ * @param {SeedsV0} v
  * @returns {Noun}
  */
-export function seedsV1ToNoun(v) {
-    const ret = wasm.seedsV1ToNoun(v);
+export function seedsV0ToNoun(v) {
+    const ret = wasm.seedsV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {SeedsV1} v
+ * @param {SeedsV0} v
  * @returns {Digest}
  */
-export function seedsV1Hash(v) {
-    const ret = wasm.seedsV1Hash(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 into `Noun`.
- * @param {LockRoot} v
+ * @param {SpendV0} v
  * @returns {Noun}
  */
-export function lockRootToNoun(v) {
-    const ret = wasm.lockRootToNoun(v);
+export function spendV0ToNoun(v) {
+    const ret = wasm.spendV0ToNoun(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {SpendV0}
+ */
+export function spendV0FromNoun(noun) {
+    const ret = wasm.spendV0FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Timelock} v
+ * @returns {Digest}
+ */
+export function timelockHash(v) {
+    const ret = wasm.timelockHash(v);
     return ret;
 }
 
 /**
- * @param {LockRoot} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Timelock} v
+ * @returns {Noun}
  */
-export function lockRootHash(v) {
-    const ret = wasm.lockRootHash(v);
+export function timelockToNoun(v) {
+    const ret = wasm.timelockToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockRoot}
+ * @returns {Timelock}
  */
-export function lockRootFromNoun(noun) {
-    const ret = wasm.lockRootFromNoun(noun);
+export function timelockFromNoun(noun) {
+    const ret = wasm.timelockFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {LegacySignature} v
+ * @returns {Noun}
+ */
+export function legacySignatureToNoun(v) {
+    const ret = wasm.legacySignatureToNoun(v);
+    return ret;
+}
+
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockPrimitive}
+ * @returns {LegacySignature}
  */
-export function lockPrimitiveFromNoun(noun) {
-    const ret = wasm.lockPrimitiveFromNoun(noun);
+export function legacySignatureFromNoun(noun) {
+    const ret = wasm.legacySignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1032,40 +1283,40 @@ export function lockPrimitiveFromNoun(noun) {
 }
 
 /**
- * @param {LockPrimitive} v
+ * @param {LegacySignature} v
  * @returns {Digest}
  */
-export function lockPrimitiveHash(v) {
-    const ret = wasm.lockPrimitiveHash(v);
+export function legacySignatureHash(v) {
+    const ret = wasm.legacySignatureHash(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {LockPrimitive} v
- * @returns {Noun}
+ * @param {NoteData} v
+ * @returns {Digest}
  */
-export function lockPrimitiveToNoun(v) {
-    const ret = wasm.lockPrimitiveToNoun(v);
+export function noteDataHash(v) {
+    const ret = wasm.noteDataHash(v);
     return ret;
 }
 
 /**
- * @param {SpendCondition} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {NoteData} v
+ * @returns {Noun}
  */
-export function spendConditionHash(v) {
-    const ret = wasm.spendConditionHash(v);
+export function noteDataToNoun(v) {
+    const ret = wasm.noteDataToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendCondition}
+ * @returns {NoteData}
  */
-export function spendConditionFromNoun(noun) {
-    const ret = wasm.spendConditionFromNoun(noun);
+export function noteDataFromNoun(noun) {
+    const ret = wasm.noteDataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1074,40 +1325,44 @@ export function spendConditionFromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {SpendCondition} v
+ * @param {RawTxV1} v
  * @returns {Noun}
  */
-export function spendConditionToNoun(v) {
-    const ret = wasm.spendConditionToNoun(v);
+export function rawTxV1ToNoun(v) {
+    const ret = wasm.rawTxV1ToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {LockMerkleProof} v
- * @returns {Noun}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {RawTxV1}
  */
-export function lockMerkleProofToNoun(v) {
-    const ret = wasm.lockMerkleProofToNoun(v);
-    return ret;
+export function rawTxV1FromNoun(noun) {
+    const ret = wasm.rawTxV1FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * @param {LockMerkleProof} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {NockchainTx} v
+ * @returns {Noun}
  */
-export function lockMerkleProofHash(v) {
-    const ret = wasm.lockMerkleProofHash(v);
+export function nockchainTxToNoun(v) {
+    const ret = wasm.nockchainTxToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockMerkleProof}
+ * @returns {NockchainTx}
  */
-export function lockMerkleProofFromNoun(noun) {
-    const ret = wasm.lockMerkleProofFromNoun(noun);
+export function nockchainTxFromNoun(noun) {
+    const ret = wasm.nockchainTxFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1115,58 +1370,53 @@ export function lockMerkleProofFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {Name} v
- * @returns {Noun}
+ * @param {SpendsV1} spends
+ * @returns {RawTxV1}
  */
-export function nameToNoun(v) {
-    const ret = wasm.nameToNoun(v);
+export function rawTxV1New(spends) {
+    const ret = wasm.rawTxV1New(spends);
     return ret;
 }
 
 /**
- * @param {Name} v
+ * @param {RawTxV1} obj
  * @returns {Digest}
  */
-export function nameHash(v) {
-    const ret = wasm.nameHash(v);
+export function rawTxV1CalcId(obj) {
+    const ret = wasm.rawTxV1CalcId(obj);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Name}
+ * @param {RawTxV1} obj
+ * @returns {Version}
  */
-export function nameFromNoun(noun) {
-    const ret = wasm.nameFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function rawTxV1Version(obj) {
+    const ret = wasm.rawTxV1Version(obj);
+    return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {RawTxV0} v
- * @returns {Noun}
+ * @param {RawTxV1} obj
+ * @returns {NockchainTx}
  */
-export function rawTxV0ToNoun(v) {
-    const ret = wasm.rawTxV0ToNoun(v);
+export function rawTxV1ToNockchainTx(obj) {
+    const ret = wasm.rawTxV1ToNockchainTx(obj);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {RawTxV0}
+ * 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 rawTxV0FromNoun(noun) {
-    const ret = wasm.rawTxV0FromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+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;
 }
 
 /**
@@ -1192,13 +1442,32 @@ export function inputDisplayToNoun(v) {
     return ret;
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {PkhSignature} v
+ * @returns {Noun}
+ */
+export function pkhSignatureToNoun(v) {
+    const ret = wasm.pkhSignatureToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {PkhSignature} v
+ * @returns {Digest}
+ */
+export function pkhSignatureHash(v) {
+    const ret = wasm.pkhSignatureHash(v);
+    return ret;
+}
+
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockRange}
+ * @returns {PkhSignature}
  */
-export function timelockRangeFromNoun(noun) {
-    const ret = wasm.timelockRangeFromNoun(noun);
+export function pkhSignatureFromNoun(noun) {
+    const ret = wasm.pkhSignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1206,31 +1475,42 @@ export function timelockRangeFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {TimelockRange} v
- * @returns {Noun}
+ * @param {NockchainTx} obj
+ * @returns {RawTxV1}
  */
-export function timelockRangeToNoun(v) {
-    const ret = wasm.timelockRangeToNoun(v);
+export function nockchainTxToRawTx(obj) {
+    const ret = wasm.nockchainTxToRawTx(obj);
     return ret;
 }
 
 /**
- * @param {TimelockRange} v
- * @returns {Digest}
+ * @param {NockchainTx} obj
+ * @returns {NoteV1[]}
  */
-export function timelockRangeHash(v) {
-    const ret = wasm.timelockRangeHash(v);
+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;
+}
+
+/**
+ * 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 {Sig}
+ * @returns {TransactionDisplay}
  */
-export function sigFromNoun(noun) {
-    const ret = wasm.sigFromNoun(noun);
+export function transactionDisplayFromNoun(noun) {
+    const ret = wasm.transactionDisplayFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1239,30 +1519,21 @@ export function sigFromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {Sig} v
+ * @param {Balance} 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 balanceToNoun(v) {
+    const ret = wasm.balanceToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Input}
+ * @returns {Balance}
  */
-export function inputFromNoun(noun) {
-    const ret = wasm.inputFromNoun(noun);
+export function balanceFromNoun(noun) {
+    const ret = wasm.balanceFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1270,50 +1541,76 @@ export function inputFromNoun(noun) {
 }
 
 /**
- * @param {Input} v
+ * @param {Version} v
  * @returns {Digest}
  */
-export function inputHash(v) {
-    const ret = wasm.inputHash(v);
+export function versionHash(v) {
+    const ret = wasm.versionHash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {Input} v
+ * @param {Version} v
  * @returns {Noun}
  */
-export function inputToNoun(v) {
-    const ret = wasm.inputToNoun(v);
+export function versionToNoun(v) {
+    const ret = wasm.versionToNoun(v);
     return ret;
 }
 
 /**
- * @param {Inputs} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Version}
  */
-export function inputsHash(v) {
-    const ret = wasm.inputsHash(v);
+export function versionFromNoun(noun) {
+    const ret = wasm.versionFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {BalanceUpdate}
+ */
+export function balanceUpdateFromNoun(noun) {
+    const ret = wasm.balanceUpdateFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {BalanceUpdate} v
+ * @returns {Noun}
+ */
+export function balanceUpdateToNoun(v) {
+    const ret = wasm.balanceUpdateToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {Inputs} v
- * @returns {Noun}
+ * @param {Sig} v
+ * @returns {Digest}
  */
-export function inputsToNoun(v) {
-    const ret = wasm.inputsToNoun(v);
+export function sigHash(v) {
+    const ret = wasm.sigHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Inputs}
+ * @returns {Sig}
  */
-export function inputsFromNoun(noun) {
-    const ret = wasm.inputsFromNoun(noun);
+export function sigFromNoun(noun) {
+    const ret = wasm.sigFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1321,21 +1618,21 @@ export function inputsFromNoun(noun) {
 }
 
 /**
- * @param {NoteV0} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Sig} v
+ * @returns {Noun}
  */
-export function noteV0Hash(v) {
-    const ret = wasm.noteV0Hash(v);
+export function sigToNoun(v) {
+    const ret = wasm.sigToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
  * @param {NoteV0} v
- * @returns {Noun}
+ * @returns {Digest}
  */
-export function noteV0ToNoun(v) {
-    const ret = wasm.noteV0ToNoun(v);
+export function noteV0Hash(v) {
+    const ret = wasm.noteV0Hash(v);
     return ret;
 }
 
@@ -1353,85 +1650,54 @@ export function noteV0FromNoun(noun) {
 }
 
 /**
- * @param {SeedV0} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {NoteV0} v
+ * @returns {Noun}
  */
-export function seedV0Hash(v) {
-    const ret = wasm.seedV0Hash(v);
+export function noteV0ToNoun(v) {
+    const ret = wasm.noteV0ToNoun(v);
     return ret;
 }
 
-/**
- * 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]);
-}
-
 /**
  * r" Convert into `Noun`.
- * @param {SeedV0} v
+ * @param {NoteInner} v
  * @returns {Noun}
  */
-export function seedV0ToNoun(v) {
-    const ret = wasm.seedV0ToNoun(v);
+export function noteInnerToNoun(v) {
+    const ret = wasm.noteInnerToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {SeedsV0} v
- * @returns {Noun}
+ * @param {NoteInner} v
+ * @returns {Digest}
  */
-export function seedsV0ToNoun(v) {
-    const ret = wasm.seedsV0ToNoun(v);
+export function noteInnerHash(v) {
+    const ret = wasm.noteInnerHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedsV0}
+ * @returns {NoteInner}
  */
-export function seedsV0FromNoun(noun) {
-    const ret = wasm.seedsV0FromNoun(noun);
+export function noteInnerFromNoun(noun) {
+    const ret = wasm.noteInnerFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {SeedsV0} v
- * @returns {Digest}
- */
-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 {SpendV0}
+ * @returns {NoteV1}
  */
-export function spendV0FromNoun(noun) {
-    const ret = wasm.spendV0FromNoun(noun);
+export function noteV1FromNoun(noun) {
+    const ret = wasm.noteV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1440,40 +1706,40 @@ export function spendV0FromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {SpendV0} v
+ * @param {NoteV1} v
  * @returns {Noun}
  */
-export function spendV0ToNoun(v) {
-    const ret = wasm.spendV0ToNoun(v);
+export function noteV1ToNoun(v) {
+    const ret = wasm.noteV1ToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {Timelock} v
- * @returns {Noun}
+ * @param {NoteV1} v
+ * @returns {Digest}
  */
-export function timelockToNoun(v) {
-    const ret = wasm.timelockToNoun(v);
+export function noteV1Hash(v) {
+    const ret = wasm.noteV1Hash(v);
     return ret;
 }
 
 /**
- * @param {Timelock} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {SeedV1} v
+ * @returns {Noun}
  */
-export function timelockHash(v) {
-    const ret = wasm.timelockHash(v);
+export function seedV1ToNoun(v) {
+    const ret = wasm.seedV1ToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Timelock}
+ * @returns {SeedV1}
  */
-export function timelockFromNoun(noun) {
-    const ret = wasm.timelockFromNoun(noun);
+export function seedV1FromNoun(noun) {
+    const ret = wasm.seedV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1481,11 +1747,11 @@ export function timelockFromNoun(noun) {
 }
 
 /**
- * @param {Witness} v
+ * @param {SeedV1} v
  * @returns {Digest}
  */
-export function witnessHash(v) {
-    const ret = wasm.witnessHash(v);
+export function seedV1Hash(v) {
+    const ret = wasm.seedV1Hash(v);
     return ret;
 }
 
@@ -1513,53 +1779,30 @@ export function witnessToNoun(v) {
 }
 
 /**
- * r" Convert from `Noun`.
- * @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
+ * @param {Witness} v
  * @returns {Digest}
  */
-export function spendV1Hash(v) {
-    const ret = wasm.spendV1Hash(v);
-    return ret;
-}
-
-/**
- * r" Convert into `Noun`.
- * @param {SpendV1} v
- * @returns {Noun}
- */
-export function spendV1ToNoun(v) {
-    const ret = wasm.spendV1ToNoun(v);
+export function witnessHash(v) {
+    const ret = wasm.witnessHash(v);
     return ret;
 }
 
 /**
- * @param {NoteData} v
+ * @param {SeedsV1} v
  * @returns {Digest}
  */
-export function noteDataHash(v) {
-    const ret = wasm.noteDataHash(v);
+export function seedsV1Hash(v) {
+    const ret = wasm.seedsV1Hash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteData}
+ * @returns {SeedsV1}
  */
-export function noteDataFromNoun(noun) {
-    const ret = wasm.noteDataFromNoun(noun);
+export function seedsV1FromNoun(noun) {
+    const ret = wasm.seedsV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1568,53 +1811,53 @@ export function noteDataFromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {NoteData} v
+ * @param {SeedsV1} v
  * @returns {Noun}
  */
-export function noteDataToNoun(v) {
-    const ret = wasm.noteDataToNoun(v);
+export function seedsV1ToNoun(v) {
+    const ret = wasm.seedsV1ToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {SpendV1} v
+ * @returns {Digest}
+ */
+export function spendV1Hash(v) {
+    const ret = wasm.spendV1Hash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {RawTxV1} v
+ * @param {SpendV1} v
  * @returns {Noun}
  */
-export function rawTxV1ToNoun(v) {
-    const ret = wasm.rawTxV1ToNoun(v);
+export function spendV1ToNoun(v) {
+    const ret = wasm.spendV1ToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {RawTxV1}
+ * @returns {SpendV1}
  */
-export function rawTxV1FromNoun(noun) {
-    const ret = wasm.rawTxV1FromNoun(noun);
+export function spendV1FromNoun(noun) {
+    const ret = wasm.spendV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {SpendsV1} v
- * @returns {Digest}
- */
-export function spendsV1Hash(v) {
-    const ret = wasm.spendsV1Hash(v);
-    return ret;
-}
-
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SpendsV1}
+ * @returns {LockRoot}
  */
-export function spendsV1FromNoun(noun) {
-    const ret = wasm.spendsV1FromNoun(noun);
+export function lockRootFromNoun(noun) {
+    const ret = wasm.lockRootFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1623,40 +1866,49 @@ export function spendsV1FromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {SpendsV1} v
+ * @param {LockRoot} v
  * @returns {Noun}
  */
-export function spendsV1ToNoun(v) {
-    const ret = wasm.spendsV1ToNoun(v);
+export function lockRootToNoun(v) {
+    const ret = wasm.lockRootToNoun(v);
     return ret;
 }
 
 /**
- * @param {MerkleProof} v
+ * @param {LockRoot} v
  * @returns {Digest}
  */
-export function merkleProofHash(v) {
-    const ret = wasm.merkleProofHash(v);
+export function lockRootHash(v) {
+    const ret = wasm.lockRootHash(v);
+    return ret;
+}
+
+/**
+ * @param {SpendsV1} v
+ * @returns {Digest}
+ */
+export function spendsV1Hash(v) {
+    const ret = wasm.spendsV1Hash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {MerkleProof} v
+ * @param {SpendsV1} v
  * @returns {Noun}
  */
-export function merkleProofToNoun(v) {
-    const ret = wasm.merkleProofToNoun(v);
+export function spendsV1ToNoun(v) {
+    const ret = wasm.spendsV1ToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {MerkleProof}
+ * @returns {SpendsV1}
  */
-export function merkleProofFromNoun(noun) {
-    const ret = wasm.merkleProofFromNoun(noun);
+export function spendsV1FromNoun(noun) {
+    const ret = wasm.spendsV1FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1664,77 +1916,91 @@ export function merkleProofFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {NockchainTx} v
- * @returns {Noun}
+ * @param {SeedV1} obj
+ * @returns {bigint}
+ */
+export function seedV1NoteDataWords(obj) {
+    const ret = wasm.seedV1NoteDataWords(obj);
+    return BigInt.asUintN(64, ret);
+}
+
+/**
+ * @param {Digest} pkh
+ * @param {Nicks} gift
+ * @param {Digest} parent_hash
+ * @param {boolean} include_lock_data
+ * @returns {SeedV1}
  */
-export function nockchainTxToNoun(v) {
-    const ret = wasm.nockchainTxToNoun(v);
+export function seedV1NewSinglePkh(pkh, gift, parent_hash, include_lock_data) {
+    const ret = wasm.seedV1NewSinglePkh(pkh, gift, parent_hash, include_lock_data);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {NockchainTx}
+ * @param {SpendV1} obj
+ * @returns {Digest}
  */
-export function nockchainTxFromNoun(noun) {
-    const ret = wasm.nockchainTxFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1SigHash(obj) {
+    const ret = wasm.spendV1SigHash(obj);
+    return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {PkhSignature} v
- * @returns {Noun}
+ * @param {SeedsV1} seeds
+ * @param {Nicks} fee
+ * @returns {SpendV1}
  */
-export function pkhSignatureToNoun(v) {
-    const ret = wasm.pkhSignatureToNoun(v);
+export function spendV1NewLegacy(seeds, fee) {
+    const ret = wasm.spendV1NewLegacy(seeds, fee);
     return ret;
 }
 
 /**
- * @param {PkhSignature} v
- * @returns {Digest}
+ * @param {Witness} witness
+ * @param {SeedsV1} seeds
+ * @param {Nicks} fee
+ * @returns {SpendV1}
  */
-export function pkhSignatureHash(v) {
-    const ret = wasm.pkhSignatureHash(v);
+export function spendV1NewWitness(witness, seeds, fee) {
+    const ret = wasm.spendV1NewWitness(witness, seeds, fee);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {PkhSignature}
+ * @param {SpendV1} obj
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function pkhSignatureFromNoun(noun) {
-    const ret = wasm.pkhSignatureFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1UnclampedFee(obj, settings) {
+    const ret = wasm.spendV1UnclampedFee(obj, settings);
+    return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {TransactionDisplay} v
- * @returns {Noun}
+ * @param {SpendV1} obj
+ * @returns {Nicks}
  */
-export function transactionDisplayToNoun(v) {
-    const ret = wasm.transactionDisplayToNoun(v);
+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 {TransactionDisplay}
+ * @returns {MerkleProof}
  */
-export function transactionDisplayFromNoun(noun) {
-    const ret = wasm.transactionDisplayFromNoun(noun);
+export function merkleProofFromNoun(noun) {
+    const ret = wasm.merkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1742,44 +2008,41 @@ export function transactionDisplayFromNoun(noun) {
 }
 
 /**
- * @param {Note} v
+ * @param {MerkleProof} v
  * @returns {Digest}
  */
-export function noteHash(v) {
-    const ret = wasm.noteHash(v);
+export function merkleProofHash(v) {
+    const ret = wasm.merkleProofHash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {Note} v
+ * @param {MerkleProof} v
  * @returns {Noun}
  */
-export function noteToNoun(v) {
-    const ret = wasm.noteToNoun(v);
+export function merkleProofToNoun(v) {
+    const ret = wasm.merkleProofToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Note}
+ * r" Convert into `Noun`.
+ * @param {WitnessData} v
+ * @returns {Noun}
  */
-export function noteFromNoun(noun) {
-    const ret = wasm.noteFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function witnessDataToNoun(v) {
+    const ret = wasm.witnessDataToNoun(v);
+    return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Source}
+ * @returns {WitnessData}
  */
-export function sourceFromNoun(noun) {
-    const ret = wasm.sourceFromNoun(noun);
+export function witnessDataFromNoun(noun) {
+    const ret = wasm.witnessDataFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1787,54 +2050,42 @@ export function sourceFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {Source} v
- * @returns {Noun}
+ * @param {SpendsV1} obj
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function sourceToNoun(v) {
-    const ret = wasm.sourceToNoun(v);
+export function spendsV1Fee(obj, settings) {
+    const ret = wasm.spendsV1Fee(obj, settings);
     return ret;
 }
 
 /**
- * @param {Source} v
- * @returns {Digest}
+ * @param {SpendsV1} obj
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function sourceHash(v) {
-    const ret = wasm.sourceHash(v);
+export function spendsV1UnclampedFee(obj, settings) {
+    const ret = wasm.spendsV1UnclampedFee(obj, settings);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @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}
- */
-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 {BalanceUpdate}
+ * @returns {LockMerkleProof}
  */
-export function balanceUpdateFromNoun(noun) {
-    const ret = wasm.balanceUpdateFromNoun(noun);
+export function lockMerkleProofFromNoun(noun) {
+    const ret = wasm.lockMerkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1842,32 +2093,31 @@ export function balanceUpdateFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {BalanceUpdate} v
- * @returns {Noun}
+ * @param {LockMerkleProof} v
+ * @returns {Digest}
  */
-export function balanceUpdateToNoun(v) {
-    const ret = wasm.balanceUpdateToNoun(v);
+export function lockMerkleProofHash(v) {
+    const ret = wasm.lockMerkleProofHash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {NoteInner} v
+ * @param {LockMerkleProof} v
  * @returns {Noun}
  */
-export function noteInnerToNoun(v) {
-    const ret = wasm.noteInnerToNoun(v);
+export function lockMerkleProofToNoun(v) {
+    const ret = wasm.lockMerkleProofToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteInner}
+ * @returns {Note}
  */
-export function noteInnerFromNoun(noun) {
-    const ret = wasm.noteInnerFromNoun(noun);
+export function noteFromNoun(noun) {
+    const ret = wasm.noteFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1875,25 +2125,22 @@ export function noteInnerFromNoun(noun) {
 }
 
 /**
- * @param {NoteInner} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Note} v
+ * @returns {Noun}
  */
-export function noteInnerHash(v) {
-    const ret = wasm.noteInnerHash(v);
+export function noteToNoun(v) {
+    const ret = wasm.noteToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
+ * @param {Note} v
  * @returns {Digest}
  */
-export function digestFromNoun(noun) {
-    const ret = wasm.digestFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function noteHash(v) {
+    const ret = wasm.noteHash(v);
+    return ret;
 }
 
 /**
@@ -1915,12 +2162,25 @@ export function digestToNoun(v) {
     return ret;
 }
 
-function wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2);
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Digest}
+ */
+export function digestFromNoun(noun) {
+    const ret = wasm.digestFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+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"];
@@ -2228,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));
@@ -2332,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;
@@ -2444,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}
@@ -2706,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;
                 }
@@ -2867,9 +3239,9 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return ret;
     };
-    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);
+    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() {