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

package/iris_wasm.js

@@ -254,14 +254,15 @@ function _assertClass(instance, klass) {
     }
 }
 /**
- * Convert native SpendCondition to protobuf format.
- * Returns the protobuf format used by the Nockchain gRPC interface and external dApps.
- * @param {SpendCondition} value
- * @returns {PbCom2SpendCondition}
+ * @param {PbCom2Note} value
+ * @returns {Note}
  */
-export function spendConditionToProtobuf(value) {
-    const ret = wasm.spendConditionToProtobuf(value);
-    return ret;
+export function noteFromProtobuf(value) {
+    const ret = wasm.noteFromProtobuf(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -273,15 +274,6 @@ export function digestToProtobuf(d) {
     return ret;
 }
 
-/**
- * @param {Note} note
- * @returns {PbCom2Note}
- */
-export function noteToProtobuf(note) {
-    const ret = wasm.noteToProtobuf(note);
-    return ret;
-}
-
 /**
  * @param {PbCom1Hash} value
  * @returns {Digest}
@@ -295,11 +287,16 @@ export function digestFromProtobuf(value) {
 }
 
 /**
- * Return default transaction engine settings for V1 signing.
- * @returns {TxEngineSettings}
+ * Convert raw transaction into protobuf format.
+ *
+ * Protobuf format is the one used by the Nockchain's gRPC interface, and the initial iris
+ * extension format. The new iris transaction signing API moves away from this format to use
+ * `NockchainTx`, as it includes the necessary spend condition and note information.
+ * @param {RawTxV1} tx
+ * @returns {PbCom2RawTransaction}
  */
-export function txEngineSettingsV1Default() {
-    const ret = wasm.txEngineSettingsV1Default();
+export function rawTxToProtobuf(tx) {
+    const ret = wasm.rawTxToProtobuf(tx);
     return ret;
 }
 
@@ -318,15 +315,41 @@ export function spendConditionFromProtobuf(value) {
 }
 
 /**
- * @param {PbCom2Note} value
- * @returns {Note}
+ * Return default transaction engine settings for V1 Bythos signing.
+ * @returns {TxEngineSettings}
  */
-export function noteFromProtobuf(value) {
-    const ret = wasm.noteFromProtobuf(value);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function txEngineSettingsV1BythosDefault() {
+    const ret = wasm.txEngineSettingsV1BythosDefault();
+    return ret;
+}
+
+/**
+ * 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 spendConditionToProtobuf(value) {
+    const ret = wasm.spendConditionToProtobuf(value);
+    return ret;
+}
+
+/**
+ * @param {Note} note
+ * @returns {PbCom2Note}
+ */
+export function noteToProtobuf(note) {
+    const ret = wasm.noteToProtobuf(note);
+    return ret;
+}
+
+/**
+ * Return default transaction engine settings for V1 signing.
+ * @returns {TxEngineSettings}
+ */
+export function txEngineSettingsV1Default() {
+    const ret = wasm.txEngineSettingsV1Default();
+    return ret;
 }
 
 /**
@@ -342,25 +365,48 @@ export function rawTxFromProtobuf(tx) {
 }
 
 /**
- * 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}
+ * Encode a Noun as a Uint8Array of bytes.
+ * @param {Noun} noun
+ * @returns {Uint8Array}
  */
-export function rawTxToProtobuf(tx) {
-    const ret = wasm.rawTxToProtobuf(tx);
-    return ret;
+export function jam(noun) {
+    const ret = wasm.jam(noun);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
 }
 
 /**
- * Return default transaction engine settings for V1 Bythos signing.
- * @returns {TxEngineSettings}
+ * Convert a sequence of belts back into one atom.
+ * @param {Noun} noun
+ * @returns {Noun}
  */
-export function txEngineSettingsV1BythosDefault() {
-    const ret = wasm.txEngineSettingsV1BythosDefault();
+export function belts_to_atom(noun) {
+    const ret = wasm.belts_to_atom(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    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.
+ *
+ * If a transaction contains non-based (not-fitting) atoms, it will be rejected.
+ * @param {string} s
+ * @returns {Noun}
+ */
+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;
 }
 
@@ -403,34 +449,6 @@ export function cue(jam) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * Convert a sequence of belts back into one atom.
- * @param {Noun} noun
- * @returns {Noun}
- */
-export function belts_to_atom(noun) {
-    const ret = wasm.belts_to_atom(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * Encode a Noun as a Uint8Array of bytes.
- * @param {Noun} noun
- * @returns {Uint8Array}
- */
-export function jam(noun) {
-    const ret = wasm.jam(noun);
-    if (ret[3]) {
-        throw takeFromExternrefTable0(ret[2]);
-    }
-    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v1;
-}
-
 /**
  * Convert an Atom to belts.
  * @param {Noun} atom
@@ -457,21 +475,21 @@ export function tas(s) {
 }
 
 /**
- * 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}
+ * 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);
+    }
 }
 
 /**
@@ -487,21 +505,21 @@ export function deriveMasterKey(seed) {
 }
 
 /**
- * Sign a message string with a private key
- * @param {Uint8Array} private_key_bytes
- * @param {string} message
- * @returns {Signature}
+ * Derive master key from BIP39 mnemonic phrase
+ * @param {string} mnemonic
+ * @param {string | null} [passphrase]
+ * @returns {ExtendedKey}
  */
-export function signMessage(private_key_bytes, message) {
-    const ptr0 = passArray8ToWasm0(private_key_bytes, wasm.__wbindgen_malloc);
+export function deriveMasterKeyFromMnemonic(mnemonic, passphrase) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     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);
+    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]);
 }
 
 /**
@@ -523,6 +541,24 @@ export function verifySignature(public_key_bytes, signature, message) {
     return ret[0] !== 0;
 }
 
+/**
+ * Sign a message string with a private key
+ * @param {Uint8Array} private_key_bytes
+ * @param {string} message
+ * @returns {Signature}
+ */
+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]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * Hash a noun (jam as input)
  * @param {Uint8Array} noun
@@ -549,42 +585,6 @@ export function hashNoun(noun) {
     }
 }
 
-/**
- * Hash a u64 value
- * @param {bigint} value
- * @returns {string}
- */
-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);
-    }
-}
-
-/**
- * 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
@@ -624,15 +624,6 @@ export function seedV0FromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {SeedV0} v
- * @returns {Digest}
- */
-export function seedV0Hash(v) {
-    const ret = wasm.seedV0Hash(v);
-    return ret;
-}
-
 /**
  * r" Convert into `Noun`.
  * @param {SeedV0} v
@@ -644,16 +635,12 @@ export function seedV0ToNoun(v) {
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {RawTxV0}
+ * @param {SeedV0} v
+ * @returns {Digest}
  */
-export function rawTxV0FromNoun(noun) {
-    const ret = wasm.rawTxV0FromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function seedV0Hash(v) {
+    const ret = wasm.seedV0Hash(v);
+    return ret;
 }
 
 /**
@@ -666,32 +653,13 @@ export function rawTxV0ToNoun(v) {
     return ret;
 }
 
-/**
- * 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 timelockIntentHash(v) {
-    const ret = wasm.timelockIntentHash(v);
-    return ret;
-}
-
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockIntent}
+ * @returns {RawTxV0}
  */
-export function timelockIntentFromNoun(noun) {
-    const ret = wasm.timelockIntentFromNoun(noun);
+export function rawTxV0FromNoun(noun) {
+    const ret = wasm.rawTxV0FromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -707,14 +675,6 @@ export function noteDataFromPkh(pkh) {
     return ret;
 }
 
-/**
- * @returns {NoteData}
- */
-export function noteDataEmpty() {
-    const ret = wasm.noteDataEmpty();
-    return ret;
-}
-
 /**
  * @param {NoteData} obj
  * @returns {bigint}
@@ -724,6 +684,14 @@ export function noteDataFeeWords(obj) {
     return BigInt.asUintN(64, ret);
 }
 
+/**
+ * @returns {NoteData}
+ */
+export function noteDataEmpty() {
+    const ret = wasm.noteDataEmpty();
+    return ret;
+}
+
 /**
  * @param {Spend1V1} obj
  * @returns {Digest}
@@ -734,21 +702,21 @@ export function spend1V1SigHash(obj) {
 }
 
 /**
- * r" Convert into `Noun`.
  * @param {LockMetadata} v
- * @returns {Noun}
+ * @returns {Digest}
  */
-export function lockMetadataToNoun(v) {
-    const ret = wasm.lockMetadataToNoun(v);
+export function lockMetadataHash(v) {
+    const ret = wasm.lockMetadataHash(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {LockMetadata} v
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function lockMetadataHash(v) {
-    const ret = wasm.lockMetadataHash(v);
+export function lockMetadataToNoun(v) {
+    const ret = wasm.lockMetadataToNoun(v);
     return ret;
 }
 
@@ -765,6 +733,25 @@ export function lockMetadataFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {LockPrimitive} v
+ * @returns {Noun}
+ */
+export function lockPrimitiveToNoun(v) {
+    const ret = wasm.lockPrimitiveToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {LockPrimitive} v
+ * @returns {Digest}
+ */
+export function lockPrimitiveHash(v) {
+    const ret = wasm.lockPrimitiveHash(v);
+    return ret;
+}
+
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
@@ -779,21 +766,21 @@ export function lockPrimitiveFromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {LockPrimitive} v
- * @returns {Noun}
+ * @param {Name} v
+ * @returns {Digest}
  */
-export function lockPrimitiveToNoun(v) {
-    const ret = wasm.lockPrimitiveToNoun(v);
+export function nameHash(v) {
+    const ret = wasm.nameHash(v);
     return ret;
 }
 
 /**
- * @param {LockPrimitive} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {Name} v
+ * @returns {Noun}
  */
-export function lockPrimitiveHash(v) {
-    const ret = wasm.lockPrimitiveHash(v);
+export function nameToNoun(v) {
+    const ret = wasm.nameToNoun(v);
     return ret;
 }
 
@@ -812,21 +799,79 @@ export function nameFromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {Name} v
+ * @param {TimelockRange} v
  * @returns {Noun}
  */
-export function nameToNoun(v) {
-    const ret = wasm.nameToNoun(v);
+export function timelockRangeToNoun(v) {
+    const ret = wasm.timelockRangeToNoun(v);
     return ret;
 }
 
 /**
- * @param {Name} v
+ * @param {TimelockRange} v
  * @returns {Digest}
  */
-export function nameHash(v) {
-    const ret = wasm.nameHash(v);
-    return ret;
+export function timelockRangeHash(v) {
+    const ret = wasm.timelockRangeHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {TimelockRange}
+ */
+export function timelockRangeFromNoun(noun) {
+    const ret = wasm.timelockRangeFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {NoteInner}
+ */
+export function noteInnerFromNoun(noun) {
+    const ret = wasm.noteInnerFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {NoteInner} v
+ * @returns {Noun}
+ */
+export function noteInnerToNoun(v) {
+    const ret = wasm.noteInnerToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {NoteInner} v
+ * @returns {Digest}
+ */
+export function noteInnerHash(v) {
+    const ret = wasm.noteInnerHash(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]);
 }
 
 /**
@@ -849,16 +894,12 @@ export function haxToNoun(v) {
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Hax}
+ * @param {Pkh} 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 pkhHash(v) {
+    const ret = wasm.pkhHash(v);
+    return ret;
 }
 
 /**
@@ -871,15 +912,6 @@ export function pkhToNoun(v) {
     return ret;
 }
 
-/**
- * @param {Pkh} v
- * @returns {Digest}
- */
-export function pkhHash(v) {
-    const ret = wasm.pkhHash(v);
-    return ret;
-}
-
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
@@ -893,15 +925,6 @@ export function pkhFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {Digest} hash
- * @returns {Pkh}
- */
-export function pkhSingle(hash) {
-    const ret = wasm.pkhSingle(hash);
-    return ret;
-}
-
 /**
  * @param {bigint} m
  * @param {Digest[]} hashes
@@ -915,11 +938,11 @@ export function pkhNew(m, hashes) {
 }
 
 /**
- * @param {SpendCondition} v
- * @returns {Digest}
+ * @param {Digest} hash
+ * @returns {Pkh}
  */
-export function spendConditionHash(v) {
-    const ret = wasm.spendConditionHash(v);
+export function pkhSingle(hash) {
+    const ret = wasm.pkhSingle(hash);
     return ret;
 }
 
@@ -933,6 +956,15 @@ export function spendConditionToNoun(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
@@ -947,20 +979,22 @@ export function spendConditionFromNoun(noun) {
 }
 
 /**
- * @param {Pkh} pkh
- * @returns {SpendCondition}
+ * @param {SpendCondition} obj
+ * @returns {Hax[]}
  */
-export function spendConditionNewPkh(pkh) {
-    const ret = wasm.spendConditionNewPkh(pkh);
-    return ret;
+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 {Hax[]}
+ * @returns {Timelock[]}
  */
-export function spendConditionHax(obj) {
-    const ret = wasm.spendConditionHax(obj);
+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;
@@ -976,14 +1010,12 @@ export function spendConditionFirstName(obj) {
 }
 
 /**
- * @param {SpendCondition} obj
- * @returns {Pkh[]}
+ * @param {Pkh} pkh
+ * @returns {SpendCondition}
  */
-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;
+export function spendConditionNewPkh(pkh) {
+    const ret = wasm.spendConditionNewPkh(pkh);
+    return ret;
 }
 
 /**
@@ -997,37 +1029,15 @@ export function spendConditionBrn(obj) {
 
 /**
  * @param {SpendCondition} obj
- * @returns {Timelock[]}
+ * @returns {Pkh[]}
  */
-export function spendConditionTim(obj) {
-    const ret = wasm.spendConditionTim(obj);
+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;
 }
 
-/**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Source}
- */
-export function sourceFromNoun(noun) {
-    const ret = wasm.sourceFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
-/**
- * @param {Source} v
- * @returns {Digest}
- */
-export function sourceHash(v) {
-    const ret = wasm.sourceHash(v);
-    return ret;
-}
-
 /**
  * r" Convert into `Noun`.
  * @param {Source} v
@@ -1039,46 +1049,27 @@ export function sourceToNoun(v) {
 }
 
 /**
- * @param {TimelockRange} v
+ * @param {Source} v
  * @returns {Digest}
  */
-export function timelockRangeHash(v) {
-    const ret = wasm.timelockRangeHash(v);
-    return ret;
-}
-
-/**
- * r" Convert into `Noun`.
- * @param {TimelockRange} v
- * @returns {Noun}
- */
-export function timelockRangeToNoun(v) {
-    const ret = wasm.timelockRangeToNoun(v);
+export function sourceHash(v) {
+    const ret = wasm.sourceHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {TimelockRange}
+ * @returns {Source}
  */
-export function timelockRangeFromNoun(noun) {
-    const ret = wasm.timelockRangeFromNoun(noun);
+export function sourceFromNoun(noun) {
+    const ret = wasm.sourceFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {RawTx} obj
- * @returns {Version}
- */
-export function rawTxVersion(obj) {
-    const ret = wasm.rawTxVersion(obj);
-    return ret;
-}
-
 /**
  * @param {RawTx} obj
  * @returns {Digest}
@@ -1100,21 +1091,21 @@ export function rawTxOutputs(obj) {
 }
 
 /**
- * @param {Input} v
- * @returns {Digest}
+ * @param {RawTx} obj
+ * @returns {Version}
  */
-export function inputHash(v) {
-    const ret = wasm.inputHash(v);
+export function rawTxVersion(obj) {
+    const ret = wasm.rawTxVersion(obj);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Input}
+ * @returns {Sig}
  */
-export function inputFromNoun(noun) {
-    const ret = wasm.inputFromNoun(noun);
+export function sigFromNoun(noun) {
+    const ret = wasm.sigFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1123,36 +1114,64 @@ export function inputFromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {Input} v
+ * @param {Sig} v
  * @returns {Noun}
  */
-export function inputToNoun(v) {
-    const ret = wasm.inputToNoun(v);
+export function sigToNoun(v) {
+    const ret = wasm.sigToNoun(v);
     return ret;
 }
 
 /**
- * @param {Inputs} v
+ * @param {Sig} v
  * @returns {Digest}
  */
-export function inputsHash(v) {
-    const ret = wasm.inputsHash(v);
+export function sigHash(v) {
+    const ret = wasm.sigHash(v);
+    return ret;
+}
+
+/**
+ * r" Convert into `Noun`.
+ * @param {Input} v
+ * @returns {Noun}
+ */
+export function inputToNoun(v) {
+    const ret = wasm.inputToNoun(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Inputs}
+ * @returns {Input}
  */
-export function inputsFromNoun(noun) {
-    const ret = wasm.inputsFromNoun(noun);
+export function inputFromNoun(noun) {
+    const ret = wasm.inputFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {Input} v
+ * @returns {Digest}
+ */
+export function inputHash(v) {
+    const ret = wasm.inputHash(v);
+    return ret;
+}
+
+/**
+ * @param {Inputs} v
+ * @returns {Digest}
+ */
+export function inputsHash(v) {
+    const ret = wasm.inputsHash(v);
+    return ret;
+}
+
 /**
  * r" Convert into `Noun`.
  * @param {Inputs} v
@@ -1166,10 +1185,10 @@ export function inputsToNoun(v) {
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {SeedsV0}
+ * @returns {Inputs}
  */
-export function seedsV0FromNoun(noun) {
-    const ret = wasm.seedsV0FromNoun(noun);
+export function inputsFromNoun(noun) {
+    const ret = wasm.inputsFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1177,31 +1196,35 @@ export function seedsV0FromNoun(noun) {
 }
 
 /**
- * r" Convert into `Noun`.
  * @param {SeedsV0} v
- * @returns {Noun}
+ * @returns {Digest}
  */
-export function seedsV0ToNoun(v) {
-    const ret = wasm.seedsV0ToNoun(v);
+export function seedsV0Hash(v) {
+    const ret = wasm.seedsV0Hash(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {SeedsV0} v
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function seedsV0Hash(v) {
-    const ret = wasm.seedsV0Hash(v);
+export function seedsV0ToNoun(v) {
+    const ret = wasm.seedsV0ToNoun(v);
     return ret;
 }
 
 /**
- * @param {SpendV0} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {SeedsV0}
  */
-export function spendV0Hash(v) {
-    const ret = wasm.spendV0Hash(v);
-    return ret;
+export function seedsV0FromNoun(noun) {
+    const ret = wasm.seedsV0FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -1228,47 +1251,46 @@ export function spendV0FromNoun(noun) {
 }
 
 /**
- * @param {Timelock} v
+ * @param {SpendV0} v
  * @returns {Digest}
  */
-export function timelockHash(v) {
-    const ret = wasm.timelockHash(v);
+export function spendV0Hash(v) {
+    const ret = wasm.spendV0Hash(v);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {Timelock} v
+ * @param {TimelockIntent} v
  * @returns {Noun}
  */
-export function timelockToNoun(v) {
-    const ret = wasm.timelockToNoun(v);
+export function timelockIntentToNoun(v) {
+    const ret = wasm.timelockIntentToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {TimelockIntent} v
+ * @returns {Digest}
+ */
+export function timelockIntentHash(v) {
+    const ret = wasm.timelockIntentHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Timelock}
+ * @returns {TimelockIntent}
  */
-export function timelockFromNoun(noun) {
-    const ret = wasm.timelockFromNoun(noun);
+export function timelockIntentFromNoun(noun) {
+    const ret = wasm.timelockIntentFromNoun(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
@@ -1283,20 +1305,21 @@ export function legacySignatureFromNoun(noun) {
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {LegacySignature} v
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function legacySignatureHash(v) {
-    const ret = wasm.legacySignatureHash(v);
+export function legacySignatureToNoun(v) {
+    const ret = wasm.legacySignatureToNoun(v);
     return ret;
 }
 
 /**
- * @param {NoteData} v
+ * @param {LegacySignature} v
  * @returns {Digest}
  */
-export function noteDataHash(v) {
-    const ret = wasm.noteDataHash(v);
+export function legacySignatureHash(v) {
+    const ret = wasm.legacySignatureHash(v);
     return ret;
 }
 
@@ -1310,6 +1333,15 @@ export function noteDataToNoun(v) {
     return ret;
 }
 
+/**
+ * @param {NoteData} v
+ * @returns {Digest}
+ */
+export function noteDataHash(v) {
+    const ret = wasm.noteDataHash(v);
+    return ret;
+}
+
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
@@ -1323,16 +1355,6 @@ export function noteDataFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * r" Convert into `Noun`.
- * @param {RawTxV1} v
- * @returns {Noun}
- */
-export function rawTxV1ToNoun(v) {
-    const ret = wasm.rawTxV1ToNoun(v);
-    return ret;
-}
-
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
@@ -1346,6 +1368,16 @@ export function rawTxV1FromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {RawTxV1} v
+ * @returns {Noun}
+ */
+export function rawTxV1ToNoun(v) {
+    const ret = wasm.rawTxV1ToNoun(v);
+    return ret;
+}
+
 /**
  * r" Convert into `Noun`.
  * @param {NockchainTx} v
@@ -1369,15 +1401,6 @@ export function nockchainTxFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * @param {SpendsV1} spends
- * @returns {RawTxV1}
- */
-export function rawTxV1New(spends) {
-    const ret = wasm.rawTxV1New(spends);
-    return ret;
-}
-
 /**
  * @param {RawTxV1} obj
  * @returns {Digest}
@@ -1387,15 +1410,6 @@ export function rawTxV1CalcId(obj) {
     return ret;
 }
 
-/**
- * @param {RawTxV1} obj
- * @returns {Version}
- */
-export function rawTxV1Version(obj) {
-    const ret = wasm.rawTxV1Version(obj);
-    return ret;
-}
-
 /**
  * @param {RawTxV1} obj
  * @returns {NockchainTx}
@@ -1420,54 +1434,40 @@ export function rawTxV1Outputs(obj) {
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {InputDisplay}
+ * @param {RawTxV1} obj
+ * @returns {Version}
  */
-export function inputDisplayFromNoun(noun) {
-    const ret = wasm.inputDisplayFromNoun(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 {InputDisplay} v
- * @returns {Noun}
+ * @param {SpendsV1} spends
+ * @returns {RawTxV1}
  */
-export function inputDisplayToNoun(v) {
-    const ret = wasm.inputDisplayToNoun(v);
+export function rawTxV1New(spends) {
+    const ret = wasm.rawTxV1New(spends);
     return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {PkhSignature} v
+ * @param {InputDisplay} 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);
+export function inputDisplayToNoun(v) {
+    const ret = wasm.inputDisplayToNoun(v);
     return ret;
 }
 
 /**
  * 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]);
     }
@@ -1494,16 +1494,6 @@ export function nockchainTxOutputs(obj) {
     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
@@ -1519,11 +1509,11 @@ export function transactionDisplayFromNoun(noun) {
 
 /**
  * r" Convert into `Noun`.
- * @param {Balance} v
+ * @param {TransactionDisplay} v
  * @returns {Noun}
  */
-export function balanceToNoun(v) {
-    const ret = wasm.balanceToNoun(v);
+export function transactionDisplayToNoun(v) {
+    const ret = wasm.transactionDisplayToNoun(v);
     return ret;
 }
 
@@ -1540,6 +1530,16 @@ export function balanceFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {Balance} v
+ * @returns {Noun}
+ */
+export function balanceToNoun(v) {
+    const ret = wasm.balanceToNoun(v);
+    return ret;
+}
+
 /**
  * @param {Version} v
  * @returns {Digest}
@@ -1596,43 +1596,21 @@ export function balanceUpdateToNoun(v) {
 }
 
 /**
- * @param {Sig} v
+ * @param {NoteV0} v
  * @returns {Digest}
  */
-export function sigHash(v) {
-    const ret = wasm.sigHash(v);
+export function noteV0Hash(v) {
+    const ret = wasm.noteV0Hash(v);
     return ret;
 }
 
-/**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Sig}
- */
-export function sigFromNoun(noun) {
-    const ret = wasm.sigFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
-}
-
 /**
  * r" Convert into `Noun`.
- * @param {Sig} v
- * @returns {Noun}
- */
-export function sigToNoun(v) {
-    const ret = wasm.sigToNoun(v);
-    return ret;
-}
-
-/**
  * @param {NoteV0} v
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function noteV0Hash(v) {
-    const ret = wasm.noteV0Hash(v);
+export function noteV0ToNoun(v) {
+    const ret = wasm.noteV0ToNoun(v);
     return ret;
 }
 
@@ -1649,42 +1627,13 @@ export function noteV0FromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * r" Convert into `Noun`.
- * @param {NoteV0} v
- * @returns {Noun}
- */
-export function noteV0ToNoun(v) {
-    const ret = wasm.noteV0ToNoun(v);
-    return ret;
-}
-
-/**
- * r" Convert into `Noun`.
- * @param {NoteInner} v
- * @returns {Noun}
- */
-export function noteInnerToNoun(v) {
-    const ret = wasm.noteInnerToNoun(v);
-    return ret;
-}
-
-/**
- * @param {NoteInner} v
- * @returns {Digest}
- */
-export function noteInnerHash(v) {
-    const ret = wasm.noteInnerHash(v);
-    return ret;
-}
-
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {NoteInner}
+ * @returns {Timelock}
  */
-export function noteInnerFromNoun(noun) {
-    const ret = wasm.noteInnerFromNoun(noun);
+export function timelockFromNoun(noun) {
+    const ret = wasm.timelockFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -1692,47 +1641,56 @@ export function noteInnerFromNoun(noun) {
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {NoteV1}
+ * @param {Timelock} v
+ * @returns {Digest}
  */
-export function noteV1FromNoun(noun) {
-    const ret = wasm.noteV1FromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function timelockHash(v) {
+    const ret = wasm.timelockHash(v);
+    return ret;
 }
 
 /**
  * r" Convert into `Noun`.
- * @param {NoteV1} v
+ * @param {Timelock} v
  * @returns {Noun}
  */
-export function noteV1ToNoun(v) {
-    const ret = wasm.noteV1ToNoun(v);
+export function timelockToNoun(v) {
+    const ret = wasm.timelockToNoun(v);
     return ret;
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {NoteV1} v
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function noteV1Hash(v) {
-    const ret = wasm.noteV1Hash(v);
+export function noteV1ToNoun(v) {
+    const ret = wasm.noteV1ToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {SeedV1} v
- * @returns {Noun}
+ * @param {NoteV1} v
+ * @returns {Digest}
  */
-export function seedV1ToNoun(v) {
-    const ret = wasm.seedV1ToNoun(v);
+export function noteV1Hash(v) {
+    const ret = wasm.noteV1Hash(v);
     return ret;
 }
 
+/**
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {NoteV1}
+ */
+export function noteV1FromNoun(noun) {
+    const ret = wasm.noteV1FromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
@@ -1747,25 +1705,22 @@ export function seedV1FromNoun(noun) {
 }
 
 /**
+ * r" Convert into `Noun`.
  * @param {SeedV1} v
- * @returns {Digest}
+ * @returns {Noun}
  */
-export function seedV1Hash(v) {
-    const ret = wasm.seedV1Hash(v);
+export function seedV1ToNoun(v) {
+    const ret = wasm.seedV1ToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {Witness}
+ * @param {SeedV1} v
+ * @returns {Digest}
  */
-export function witnessFromNoun(noun) {
-    const ret = wasm.witnessFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function seedV1Hash(v) {
+    const ret = wasm.seedV1Hash(v);
+    return ret;
 }
 
 /**
@@ -1788,12 +1743,16 @@ export function witnessHash(v) {
 }
 
 /**
- * @param {SeedsV1} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Witness}
  */
-export function seedsV1Hash(v) {
-    const ret = wasm.seedsV1Hash(v);
-    return ret;
+export function witnessFromNoun(noun) {
+    const ret = wasm.witnessFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -1809,6 +1768,15 @@ export function seedsV1FromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {SeedsV1} v
+ * @returns {Digest}
+ */
+export function seedsV1Hash(v) {
+    const ret = wasm.seedsV1Hash(v);
+    return ret;
+}
+
 /**
  * r" Convert into `Noun`.
  * @param {SeedsV1} v
@@ -1851,6 +1819,16 @@ export function spendV1FromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {LockRoot} v
+ * @returns {Noun}
+ */
+export function lockRootToNoun(v) {
+    const ret = wasm.lockRootToNoun(v);
+    return ret;
+}
+
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
@@ -1864,16 +1842,6 @@ export function lockRootFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
-/**
- * r" Convert into `Noun`.
- * @param {LockRoot} v
- * @returns {Noun}
- */
-export function lockRootToNoun(v) {
-    const ret = wasm.lockRootToNoun(v);
-    return ret;
-}
-
 /**
  * @param {LockRoot} v
  * @returns {Digest}
@@ -1883,15 +1851,6 @@ export function 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 {SpendsV1} v
@@ -1915,6 +1874,15 @@ export function spendsV1FromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * @param {SpendsV1} v
+ * @returns {Digest}
+ */
+export function spendsV1Hash(v) {
+    const ret = wasm.spendsV1Hash(v);
+    return ret;
+}
+
 /**
  * @param {SeedV1} obj
  * @returns {bigint}
@@ -1938,20 +1906,11 @@ export function seedV1NewSinglePkh(pkh, gift, parent_hash, include_lock_data) {
 
 /**
  * @param {SpendV1} obj
- * @returns {Digest}
- */
-export function spendV1SigHash(obj) {
-    const ret = wasm.spendV1SigHash(obj);
-    return ret;
-}
-
-/**
- * @param {SeedsV1} seeds
- * @param {Nicks} fee
- * @returns {SpendV1}
+ * @param {TxEngineSettings} settings
+ * @returns {Nicks}
  */
-export function spendV1NewLegacy(seeds, fee) {
-    const ret = wasm.spendV1NewLegacy(seeds, fee);
+export function spendV1UnclampedFee(obj, settings) {
+    const ret = wasm.spendV1UnclampedFee(obj, settings);
     return ret;
 }
 
@@ -1967,21 +1926,21 @@ export function spendV1NewWitness(witness, seeds, fee) {
 }
 
 /**
- * @param {SpendV1} obj
- * @param {TxEngineSettings} settings
- * @returns {Nicks}
+ * @param {SeedsV1} seeds
+ * @param {Nicks} fee
+ * @returns {SpendV1}
  */
-export function spendV1UnclampedFee(obj, settings) {
-    const ret = wasm.spendV1UnclampedFee(obj, settings);
+export function spendV1NewLegacy(seeds, fee) {
+    const ret = wasm.spendV1NewLegacy(seeds, fee);
     return ret;
 }
 
 /**
  * @param {SpendV1} obj
- * @returns {Nicks}
+ * @returns {Digest}
  */
-export function spendV1Fee(obj) {
-    const ret = wasm.spendV1Fee(obj);
+export function spendV1SigHash(obj) {
+    const ret = wasm.spendV1SigHash(obj);
     return ret;
 }
 
@@ -1995,16 +1954,12 @@ export function spendV1Seeds(obj) {
 }
 
 /**
- * r" Convert from `Noun`.
- * @param {Noun} noun
- * @returns {MerkleProof}
+ * @param {SpendV1} obj
+ * @returns {Nicks}
  */
-export function merkleProofFromNoun(noun) {
-    const ret = wasm.merkleProofFromNoun(noun);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
-    }
-    return takeFromExternrefTable0(ret[0]);
+export function spendV1Fee(obj) {
+    const ret = wasm.spendV1Fee(obj);
+    return ret;
 }
 
 /**
@@ -2027,13 +1982,16 @@ export function merkleProofToNoun(v) {
 }
 
 /**
- * r" Convert into `Noun`.
- * @param {WitnessData} v
- * @returns {Noun}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {MerkleProof}
  */
-export function witnessDataToNoun(v) {
-    const ret = wasm.witnessDataToNoun(v);
-    return ret;
+export function merkleProofFromNoun(noun) {
+    const ret = wasm.merkleProofFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
@@ -2049,6 +2007,26 @@ export function witnessDataFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {WitnessData} v
+ * @returns {Noun}
+ */
+export function witnessDataToNoun(v) {
+    const ret = wasm.witnessDataToNoun(v);
+    return ret;
+}
+
+/**
+ * @param {SpendsV1} obj
+ * @param {WitnessData} witness_data
+ * @returns {SpendsV1}
+ */
+export function spendsV1ApplyWitness(obj, witness_data) {
+    const ret = wasm.spendsV1ApplyWitness(obj, witness_data);
+    return ret;
+}
+
 /**
  * @param {SpendsV1} obj
  * @param {TxEngineSettings} settings
@@ -2070,22 +2048,21 @@ export function spendsV1UnclampedFee(obj, settings) {
 }
 
 /**
- * @param {SpendsV1} obj
- * @param {WitnessData} witness_data
- * @returns {SpendsV1}
+ * @param {PkhSignature} v
+ * @returns {Digest}
  */
-export function spendsV1ApplyWitness(obj, witness_data) {
-    const ret = wasm.spendsV1ApplyWitness(obj, witness_data);
+export function pkhSignatureHash(v) {
+    const ret = wasm.pkhSignatureHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {LockMerkleProof}
+ * @returns {PkhSignature}
  */
-export function lockMerkleProofFromNoun(noun) {
-    const ret = wasm.lockMerkleProofFromNoun(noun);
+export function pkhSignatureFromNoun(noun) {
+    const ret = wasm.pkhSignatureFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
@@ -2093,37 +2070,47 @@ export function lockMerkleProofFromNoun(noun) {
 }
 
 /**
- * @param {LockMerkleProof} v
- * @returns {Digest}
+ * r" Convert into `Noun`.
+ * @param {PkhSignature} v
+ * @returns {Noun}
  */
-export function lockMerkleProofHash(v) {
-    const ret = wasm.lockMerkleProofHash(v);
+export function pkhSignatureToNoun(v) {
+    const ret = wasm.pkhSignatureToNoun(v);
     return ret;
 }
 
 /**
- * r" Convert into `Noun`.
  * @param {LockMerkleProof} v
- * @returns {Noun}
+ * @returns {Digest}
  */
-export function lockMerkleProofToNoun(v) {
-    const ret = wasm.lockMerkleProofToNoun(v);
+export function lockMerkleProofHash(v) {
+    const ret = wasm.lockMerkleProofHash(v);
     return ret;
 }
 
 /**
  * r" Convert from `Noun`.
  * @param {Noun} noun
- * @returns {Note}
+ * @returns {LockMerkleProof}
  */
-export function noteFromNoun(noun) {
-    const ret = wasm.noteFromNoun(noun);
+export function lockMerkleProofFromNoun(noun) {
+    const ret = wasm.lockMerkleProofFromNoun(noun);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {LockMerkleProof} v
+ * @returns {Noun}
+ */
+export function lockMerkleProofToNoun(v) {
+    const ret = wasm.lockMerkleProofToNoun(v);
+    return ret;
+}
+
 /**
  * r" Convert into `Noun`.
  * @param {Note} v
@@ -2144,21 +2131,24 @@ export function noteHash(v) {
 }
 
 /**
- * @param {Digest} v
- * @returns {Digest}
+ * r" Convert from `Noun`.
+ * @param {Noun} noun
+ * @returns {Note}
  */
-export function digestHash(v) {
-    const ret = wasm.digestHash(v);
-    return ret;
+export function noteFromNoun(noun) {
+    const ret = wasm.noteFromNoun(noun);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * r" Convert into `Noun`.
  * @param {Digest} v
- * @returns {Noun}
+ * @returns {Digest}
  */
-export function digestToNoun(v) {
-    const ret = wasm.digestToNoun(v);
+export function digestHash(v) {
+    const ret = wasm.digestHash(v);
     return ret;
 }
 
@@ -2175,6 +2165,16 @@ export function digestFromNoun(noun) {
     return takeFromExternrefTable0(ret[0]);
 }
 
+/**
+ * r" Convert into `Noun`.
+ * @param {Digest} v
+ * @returns {Noun}
+ */
+export function digestToNoun(v) {
+    const ret = wasm.digestToNoun(v);
+    return ret;
+}
+
 function wasm_bindgen__convert__closures_____invoke__h7f888ae473d7b77e(arg0, arg1, arg2) {
     wasm.wasm_bindgen__convert__closures_____invoke__h7f888ae473d7b77e(arg0, arg1, arg2);
 }