@nockbox/iris-wasm 0.2.0-alpha.0 → 0.2.0-alpha.1

package/iris_wasm.js

@@ -220,51 +220,91 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * Verify a signature with a public key
+ * @param {Uint8Array} public_key_bytes
+ * @param {Signature} signature
+ * @param {string} message
+ * @returns {boolean}
+ */
+export function verifySignature(public_key_bytes, signature, message) {
+    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.verifySignature(ptr0, len0, signature, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return ret[0] !== 0;
 }
 
-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;
+/**
+ * Derive master key from seed bytes
+ * @param {Uint8Array} seed
+ * @returns {ExtendedKey}
+ */
+export function deriveMasterKey(seed) {
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.deriveMasterKey(ptr0, len0);
+    return ExtendedKey.__wrap(ret);
 }
 
-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);
+/**
+ * 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);
     }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
+/**
+ * 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 noun (jam as input)
- * @param {Uint8Array} noun
+ * Hash a public key to get its digest (for use in PKH)
+ * @param {Uint8Array} public_key_bytes
  * @returns {string}
  */
-export function hashNoun(noun) {
+export function hashPublicKey(public_key_bytes) {
     let deferred3_0;
     let deferred3_1;
     try {
-        const ptr0 = passArray8ToWasm0(noun, wasm.__wbindgen_malloc);
+        const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hashNoun(ptr0, len0);
+        const ret = wasm.hashPublicKey(ptr0, len0);
         var ptr2 = ret[0];
         var len2 = ret[1];
         if (ret[3]) {
@@ -294,19 +334,130 @@ export function signMessage(private_key_bytes, message) {
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return Signature.__wrap(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * Hash a u64 value
- * @param {bigint} value
+ * Hash a noun (jam as input)
+ * @param {Uint8Array} noun
  * @returns {string}
  */
-export function hashU64(value) {
+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 {Uint8Array} jam
+ * @returns {Noun}
+ */
+export function cue(jam) {
+    const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cue(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @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;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+/**
+ * @param {string} s
+ * @returns {Digest}
+ */
+export function hex_to_digest(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]);
+}
+
+/**
+ * @param {Note} note
+ * @returns {Digest}
+ */
+export function note_hash(note) {
+    const ret = wasm.note_hash(note);
+    return ret;
+}
+
+/**
+ * @param {Note} note
+ * @returns {PbCom2Note}
+ */
+export function note_to_protobuf(note) {
+    const ret = wasm.note_to_protobuf(note);
+    return ret;
+}
+
+/**
+ * @param {Digest} d
+ * @returns {string}
+ */
+export function digest_to_hex(d) {
     let deferred1_0;
     let deferred1_1;
     try {
-        const ret = wasm.hashU64(value);
+        const ret = wasm.digest_to_hex(d);
         deferred1_0 = ret[0];
         deferred1_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -316,79 +467,72 @@ export function hashU64(value) {
 }
 
 /**
- * Derive master key from seed bytes
- * @param {Uint8Array} seed
- * @returns {ExtendedKey}
+ * @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}
  */
-export function deriveMasterKey(seed) {
-    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+export function create_note_v0(origin_page, sig_m, sig_pubkeys, source_hash, is_coinbase, timelock, assets) {
+    const ptr0 = passArrayJsValueToWasm0(sig_pubkeys, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.deriveMasterKey(ptr0, len0);
-    return ExtendedKey.__wrap(ret);
+    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]);
 }
 
 /**
- * Verify a signature with a public key
- * @param {Uint8Array} public_key_bytes
- * @param {Signature} signature
- * @param {string} message
- * @returns {boolean}
+ * @param {PbCom1Hash} value
+ * @returns {Digest}
  */
-export function verifySignature(public_key_bytes, signature, message) {
-    const ptr0 = passArray8ToWasm0(public_key_bytes, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    _assertClass(signature, Signature);
-    const ptr1 = passStringToWasm0(message, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.verifySignature(ptr0, len0, signature.__wbg_ptr, ptr1, len1);
+export function digest_from_protobuf(value) {
+    const ret = wasm.digest_from_protobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ret[0] !== 0;
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * Derive master key from BIP39 mnemonic phrase
- * @param {string} mnemonic
- * @param {string | null} [passphrase]
- * @returns {ExtendedKey}
+ * @param {Digest} d
+ * @returns {PbCom1Hash}
  */
-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 digest_to_protobuf(d) {
+    const ret = wasm.digest_to_protobuf(d);
+    return ret;
+}
+
+/**
+ * @param {PbCom2Note} value
+ * @returns {Note}
+ */
+export function note_from_protobuf(value) {
+    const ret = wasm.note_from_protobuf(value);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return ExtendedKey.__wrap(ret[0]);
+    return takeFromExternrefTable0(ret[0]);
 }
 
 /**
- * Hash a public key to get its digest (for use in PKH)
- * @param {Uint8Array} public_key_bytes
- * @returns {string}
+ * @param {Version} version
+ * @param {number} origin_page
+ * @param {Name} name
+ * @param {NoteData} note_data
+ * @param {Nicks} assets
+ * @returns {Note}
  */
-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 create_note_v1(version, origin_page, name, note_data, assets) {
+    const ret = wasm.create_note_v1(version, origin_page, name, note_data, assets);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
+    return takeFromExternrefTable0(ret[0]);
 }
 
 function wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b(arg0, arg1, arg2) {
@@ -407,1727 +551,281 @@ const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache
 
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
 
-const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
-
-const __wbindgen_enum_RequestRedirect = ["follow", "error", "manual"];
-
-const DigestFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_digest_free(ptr >>> 0, 1));
-
-export class Digest {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Digest.prototype);
-        obj.__wbg_ptr = ptr;
-        DigestFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof Digest)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        DigestFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_digest_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.digest_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {Digest}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.digest_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Digest.__wrap(ret[0]);
-    }
-    /**
-     * @param {string} value
-     */
-    constructor(value) {
-        const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.digest_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        DigestFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {string}
-     */
-    get value() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.digest_value(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) Digest.prototype[Symbol.dispose] = Digest.prototype.free;
-
-const ExtendedKeyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_extendedkey_free(ptr >>> 0, 1));
-
-export class ExtendedKey {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ExtendedKey.prototype);
-        obj.__wbg_ptr = ptr;
-        ExtendedKeyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ExtendedKeyFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_extendedkey_free(ptr, 0);
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get chainCode() {
-        const ret = wasm.extendedkey_chainCode(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get publicKey() {
-        const ret = wasm.extendedkey_publicKey(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @returns {Uint8Array | undefined}
-     */
-    get privateKey() {
-        const ret = wasm.extendedkey_privateKey(this.__wbg_ptr);
-        let v1;
-        if (ret[0] !== 0) {
-            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        }
-        return v1;
-    }
-    /**
-     * Derive a child key at the given index
-     * @param {number} index
-     * @returns {ExtendedKey}
-     */
-    deriveChild(index) {
-        const ret = wasm.extendedkey_deriveChild(this.__wbg_ptr, index);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ExtendedKey.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) ExtendedKey.prototype[Symbol.dispose] = ExtendedKey.prototype.free;
-
-const GrpcClientFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_grpcclient_free(ptr >>> 0, 1));
-
-export class GrpcClient {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GrpcClientFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_grpcclient_free(ptr, 0);
-    }
-    /**
-     * Send a transaction
-     * @param {any} raw_tx
-     * @returns {Promise<any>}
-     */
-    sendTransaction(raw_tx) {
-        const ret = wasm.grpcclient_sendTransaction(this.__wbg_ptr, raw_tx);
-        return ret;
-    }
-    /**
-     * Check if a transaction was accepted
-     * @param {string} tx_id
-     * @returns {Promise<boolean>}
-     */
-    transactionAccepted(tx_id) {
-        const ptr0 = passStringToWasm0(tx_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_transactionAccepted(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Get balance for a wallet address
-     * @param {string} address
-     * @returns {Promise<any>}
-     */
-    getBalanceByAddress(address) {
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_getBalanceByAddress(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * Get balance for a first name
-     * @param {string} first_name
-     * @returns {Promise<any>}
-     */
-    getBalanceByFirstName(first_name) {
-        const ptr0 = passStringToWasm0(first_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_getBalanceByFirstName(this.__wbg_ptr, ptr0, len0);
-        return ret;
-    }
-    /**
-     * @param {string} endpoint
-     */
-    constructor(endpoint) {
-        const ptr0 = passStringToWasm0(endpoint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.grpcclient_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        GrpcClientFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) GrpcClient.prototype[Symbol.dispose] = GrpcClient.prototype.free;
-
-const HaxFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_hax_free(ptr >>> 0, 1));
-
-export class Hax {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        HaxFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_hax_free(ptr, 0);
-    }
-    /**
-     * @param {Digest[]} digests
-     */
-    constructor(digests) {
-        const ptr0 = passArrayJsValueToWasm0(digests, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.hax_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        HaxFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {Digest[]}
-     */
-    get digests() {
-        const ret = wasm.hax_digests(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-}
-if (Symbol.dispose) Hax.prototype[Symbol.dispose] = Hax.prototype.free;
-
-const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
-
-export class IntoUnderlyingByteSource {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        IntoUnderlyingByteSourceFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get autoAllocateChunkSize() {
-        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @param {ReadableByteStreamController} controller
-     * @returns {Promise<any>}
-     */
-    pull(controller) {
-        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
-        return ret;
-    }
-    /**
-     * @param {ReadableByteStreamController} controller
-     */
-    start(controller) {
-        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
-    }
-    /**
-     * @returns {ReadableStreamType}
-     */
-    get type() {
-        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
-        return __wbindgen_enum_ReadableStreamType[ret];
-    }
-    cancel() {
-        const ptr = this.__destroy_into_raw();
-        wasm.intounderlyingbytesource_cancel(ptr);
-    }
-}
-if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
-
-const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
-
-export class IntoUnderlyingSink {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        IntoUnderlyingSinkFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_intounderlyingsink_free(ptr, 0);
-    }
-    /**
-     * @param {any} reason
-     * @returns {Promise<any>}
-     */
-    abort(reason) {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.intounderlyingsink_abort(ptr, reason);
-        return ret;
-    }
-    /**
-     * @returns {Promise<any>}
-     */
-    close() {
-        const ptr = this.__destroy_into_raw();
-        const ret = wasm.intounderlyingsink_close(ptr);
-        return ret;
-    }
-    /**
-     * @param {any} chunk
-     * @returns {Promise<any>}
-     */
-    write(chunk) {
-        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
-        return ret;
-    }
-}
-if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
-
-const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
-
-export class IntoUnderlyingSource {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        IntoUnderlyingSourceFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_intounderlyingsource_free(ptr, 0);
-    }
-    /**
-     * @param {ReadableStreamDefaultController} controller
-     * @returns {Promise<any>}
-     */
-    pull(controller) {
-        const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
-        return ret;
-    }
-    cancel() {
-        const ptr = this.__destroy_into_raw();
-        wasm.intounderlyingsource_cancel(ptr);
-    }
-}
-if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
-
-const LockPrimitiveFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_lockprimitive_free(ptr >>> 0, 1));
-
-export class LockPrimitive {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(LockPrimitive.prototype);
-        obj.__wbg_ptr = ptr;
-        LockPrimitiveFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof LockPrimitive)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        LockPrimitiveFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_lockprimitive_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.lockprimitive_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {LockPrimitive}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.lockprimitive_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return LockPrimitive.__wrap(ret[0]);
-    }
-    /**
-     * @returns {LockPrimitive}
-     */
-    static newBrn() {
-        const ret = wasm.lockprimitive_newBrn();
-        return LockPrimitive.__wrap(ret);
-    }
-    /**
-     * @param {Hax} hax
-     * @returns {LockPrimitive}
-     */
-    static newHax(hax) {
-        _assertClass(hax, Hax);
-        var ptr0 = hax.__destroy_into_raw();
-        const ret = wasm.lockprimitive_newHax(ptr0);
-        return LockPrimitive.__wrap(ret);
-    }
-    /**
-     * @param {Pkh} pkh
-     * @returns {LockPrimitive}
-     */
-    static newPkh(pkh) {
-        _assertClass(pkh, Pkh);
-        var ptr0 = pkh.__destroy_into_raw();
-        const ret = wasm.lockprimitive_newPkh(ptr0);
-        return LockPrimitive.__wrap(ret);
-    }
-    /**
-     * @param {LockTim} tim
-     * @returns {LockPrimitive}
-     */
-    static newTim(tim) {
-        _assertClass(tim, LockTim);
-        var ptr0 = tim.__destroy_into_raw();
-        const ret = wasm.lockprimitive_newTim(ptr0);
-        return LockPrimitive.__wrap(ret);
-    }
-}
-if (Symbol.dispose) LockPrimitive.prototype[Symbol.dispose] = LockPrimitive.prototype.free;
-
-const LockRootFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_lockroot_free(ptr >>> 0, 1));
-
-export class LockRoot {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(LockRoot.prototype);
-        obj.__wbg_ptr = ptr;
-        LockRootFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        LockRootFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_lockroot_free(ptr, 0);
-    }
-    /**
-     * @param {SpendCondition} cond
-     * @returns {LockRoot}
-     */
-    static fromSpendCondition(cond) {
-        _assertClass(cond, SpendCondition);
-        var ptr0 = cond.__destroy_into_raw();
-        const ret = wasm.lockroot_fromSpendCondition(ptr0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return LockRoot.__wrap(ret[0]);
-    }
-    /**
-     * @returns {Digest}
-     */
-    get hash() {
-        const ret = wasm.lockroot_hash(this.__wbg_ptr);
-        return Digest.__wrap(ret);
-    }
-    /**
-     * @returns {SpendCondition | undefined}
-     */
-    get lock() {
-        const ret = wasm.lockroot_lock(this.__wbg_ptr);
-        return ret === 0 ? undefined : SpendCondition.__wrap(ret);
-    }
-    /**
-     * @param {Digest} hash
-     * @returns {LockRoot}
-     */
-    static fromHash(hash) {
-        _assertClass(hash, Digest);
-        var ptr0 = hash.__destroy_into_raw();
-        const ret = wasm.lockroot_fromHash(ptr0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return LockRoot.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) LockRoot.prototype[Symbol.dispose] = LockRoot.prototype.free;
-
-const LockTimFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_locktim_free(ptr >>> 0, 1));
-
-export class LockTim {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(LockTim.prototype);
-        obj.__wbg_ptr = ptr;
-        LockTimFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        LockTimFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_locktim_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.locktim_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {LockTim}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.locktim_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return LockTim.__wrap(ret[0]);
-    }
-    /**
-     * @returns {TimelockRange}
-     */
-    get abs() {
-        const ret = wasm.locktim_abs(this.__wbg_ptr);
-        return TimelockRange.__wrap(ret);
-    }
-    /**
-     * @param {TimelockRange} rel
-     * @param {TimelockRange} abs
-     */
-    constructor(rel, abs) {
-        _assertClass(rel, TimelockRange);
-        var ptr0 = rel.__destroy_into_raw();
-        _assertClass(abs, TimelockRange);
-        var ptr1 = abs.__destroy_into_raw();
-        const ret = wasm.locktim_new(ptr0, ptr1);
-        this.__wbg_ptr = ret >>> 0;
-        LockTimFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {TimelockRange}
-     */
-    get rel() {
-        const ret = wasm.locktim_rel(this.__wbg_ptr);
-        return TimelockRange.__wrap(ret);
-    }
-    /**
-     * @returns {LockTim}
-     */
-    static coinbase() {
-        const ret = wasm.locktim_coinbase();
-        return LockTim.__wrap(ret);
-    }
-}
-if (Symbol.dispose) LockTim.prototype[Symbol.dispose] = LockTim.prototype.free;
-
-const NameFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_name_free(ptr >>> 0, 1));
-
-export class Name {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Name.prototype);
-        obj.__wbg_ptr = ptr;
-        NameFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NameFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_name_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.name_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {Name}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.name_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Name.__wrap(ret[0]);
-    }
-    /**
-     * @param {string} first
-     * @param {string} last
-     */
-    constructor(first, last) {
-        const ptr0 = passStringToWasm0(first, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(last, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.name_new(ptr0, len0, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        NameFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {string}
-     */
-    get last() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.name_last(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);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    get first() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.name_first(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) Name.prototype[Symbol.dispose] = Name.prototype.free;
-
-const NockchainTxFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_nockchaintx_free(ptr >>> 0, 1));
-
-export class NockchainTx {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(NockchainTx.prototype);
-        obj.__wbg_ptr = ptr;
-        NockchainTxFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NockchainTxFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_nockchaintx_free(ptr, 0);
-    }
-    /**
-     * @returns {Digest}
-     */
-    get id() {
-        const ret = wasm.nockchaintx_id(this.__wbg_ptr);
-        return Digest.__wrap(ret);
-    }
-    /**
-     * @returns {string}
-     */
-    get name() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.nockchaintx_name(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);
-        }
-    }
-    /**
-     * Convert to jammed transaction file for inspecting through CLI
-     * @returns {Uint8Array}
-     */
-    toJam() {
-        const ret = wasm.nockchaintx_toJam(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {Note[]}
-     */
-    outputs() {
-        const ret = wasm.nockchaintx_outputs(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * @returns {Version}
-     */
-    get version() {
-        const ret = wasm.nockchaintx_version(this.__wbg_ptr);
-        return Version.__wrap(ret);
-    }
-    /**
-     * Convert from CLI-compatible jammed transaction file
-     * @param {Uint8Array} jam
-     * @returns {NockchainTx}
-     */
-    static fromJam(jam) {
-        const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.nockchaintx_fromJam(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NockchainTx.__wrap(ret[0]);
-    }
-    /**
-     * @returns {RawTx}
-     */
-    toRawTx() {
-        const ret = wasm.nockchaintx_toRawTx(this.__wbg_ptr);
-        return RawTx.__wrap(ret);
-    }
-}
-if (Symbol.dispose) NockchainTx.prototype[Symbol.dispose] = NockchainTx.prototype.free;
-
-const NoteFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_note_free(ptr >>> 0, 1));
-
-export class Note {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Note.prototype);
-        obj.__wbg_ptr = ptr;
-        NoteFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof Note)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NoteFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_note_free(ptr, 0);
-    }
-    /**
-     * @returns {bigint}
-     */
-    get originPage() {
-        const ret = wasm.note_originPage(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.note_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * Create a WasmNote from a protobuf Note object (from get_balance response)
-     * Expects response.notes[i].note (handles version internally)
-     * @param {any} pb_note
-     * @returns {Note}
-     */
-    static fromProtobuf(pb_note) {
-        const ret = wasm.note_fromProtobuf(pb_note);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Note.__wrap(ret[0]);
-    }
-    /**
-     * Create a new V1 note (the default for new notes)
-     * @param {Version} version
-     * @param {bigint} origin_page
-     * @param {Name} name
-     * @param {NoteData} note_data
-     * @param {bigint} assets
-     */
-    constructor(version, origin_page, name, note_data, assets) {
-        _assertClass(version, Version);
-        var ptr0 = version.__destroy_into_raw();
-        _assertClass(name, Name);
-        var ptr1 = name.__destroy_into_raw();
-        _assertClass(note_data, NoteData);
-        var ptr2 = note_data.__destroy_into_raw();
-        const ret = wasm.note_new(ptr0, origin_page, ptr1, ptr2, assets);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        NoteFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {Digest}
-     */
-    hash() {
-        const ret = wasm.note_hash(this.__wbg_ptr);
-        return Digest.__wrap(ret);
-    }
-    /**
-     * @returns {Name}
-     */
-    get name() {
-        const ret = wasm.note_name(this.__wbg_ptr);
-        return Name.__wrap(ret);
-    }
-    /**
-     * Check if this is a V0 (legacy) note
-     * @returns {boolean}
-     */
-    get isV0() {
-        const ret = wasm.note_isV0(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Check if this is a V1 note
-     * @returns {boolean}
-     */
-    get isV1() {
-        const ret = wasm.note_isV1(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * @returns {bigint}
-     */
-    get assets() {
-        const ret = wasm.note_assets(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * Create a new V0 (legacy) note
-     *
-     * V0 notes are legacy notes that use public keys directly instead of spend conditions.
-     * - `origin_page`: Block height where the note originated
-     * - `sig_m`: Number of required signatures (m-of-n)
-     * - `sig_pubkeys`: Public keys as 97-byte arrays (big-endian format)
-     * - `source_hash`: Hash of the source (seeds that created this note)
-     * - `is_coinbase`: Whether this is a coinbase note
-     * - `timelock`: Optional timelock constraints (must have at least one constraint if provided)
-     * - `assets`: Amount of nicks in this note
-     * @param {bigint} origin_page
-     * @param {bigint} sig_m
-     * @param {Uint8Array[]} sig_pubkeys
-     * @param {Digest} source_hash
-     * @param {boolean} is_coinbase
-     * @param {Timelock | null | undefined} timelock
-     * @param {bigint} assets
-     * @returns {Note}
-     */
-    static newV0(origin_page, sig_m, sig_pubkeys, source_hash, is_coinbase, timelock, assets) {
-        const ptr0 = passArrayJsValueToWasm0(sig_pubkeys, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(source_hash, Digest);
-        var ptr1 = source_hash.__destroy_into_raw();
-        let ptr2 = 0;
-        if (!isLikeNone(timelock)) {
-            _assertClass(timelock, Timelock);
-            ptr2 = timelock.__destroy_into_raw();
-        }
-        const ret = wasm.note_newV0(origin_page, sig_m, ptr0, len0, ptr1, is_coinbase, ptr2, assets);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Note.__wrap(ret[0]);
-    }
-    /**
-     * @returns {Version}
-     */
-    get version() {
-        const ret = wasm.note_version(this.__wbg_ptr);
-        return Version.__wrap(ret);
-    }
-    /**
-     * Returns note data. For V0 notes this returns empty NoteData since V0 doesn't have this field.
-     * @returns {NoteData}
-     */
-    get noteData() {
-        const ret = wasm.note_noteData(this.__wbg_ptr);
-        return NoteData.__wrap(ret);
-    }
-}
-if (Symbol.dispose) Note.prototype[Symbol.dispose] = Note.prototype.free;
-
-const NoteDataFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_notedata_free(ptr >>> 0, 1));
-
-export class NoteData {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(NoteData.prototype);
-        obj.__wbg_ptr = ptr;
-        NoteDataFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NoteDataFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_notedata_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.notedata_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {NoteData}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.notedata_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NoteData.__wrap(ret[0]);
-    }
-    /**
-     * @param {NoteDataEntry[]} entries
-     */
-    constructor(entries) {
-        const ptr0 = passArrayJsValueToWasm0(entries, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.notedata_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        NoteDataFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {NoteData}
-     */
-    static empty() {
-        const ret = wasm.notedata_empty();
-        return NoteData.__wrap(ret);
-    }
-    /**
-     * @returns {NoteDataEntry[]}
-     */
-    get entries() {
-        const ret = wasm.notedata_entries(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * @param {Pkh} pkh
-     * @returns {NoteData}
-     */
-    static fromPkh(pkh) {
-        _assertClass(pkh, Pkh);
-        var ptr0 = pkh.__destroy_into_raw();
-        const ret = wasm.notedata_fromPkh(ptr0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NoteData.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) NoteData.prototype[Symbol.dispose] = NoteData.prototype.free;
-
-const NoteDataEntryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_notedataentry_free(ptr >>> 0, 1));
-
-export class NoteDataEntry {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(NoteDataEntry.prototype);
-        obj.__wbg_ptr = ptr;
-        NoteDataEntryFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof NoteDataEntry)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NoteDataEntryFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_notedataentry_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.notedataentry_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {NoteDataEntry}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.notedataentry_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NoteDataEntry.__wrap(ret[0]);
-    }
-    /**
-     * @returns {string}
-     */
-    get key() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.notedataentry_key(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);
-        }
-    }
-    /**
-     * @param {string} key
-     * @param {Uint8Array} blob
-     */
-    constructor(key, blob) {
-        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(blob, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.notedataentry_new(ptr0, len0, ptr1, len1);
-        this.__wbg_ptr = ret >>> 0;
-        NoteDataEntryFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    get blob() {
-        const ret = wasm.notedataentry_blob(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-}
-if (Symbol.dispose) NoteDataEntry.prototype[Symbol.dispose] = NoteDataEntry.prototype.free;
-
-const NounFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_noun_free(ptr >>> 0, 1));
-
-export class Noun {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Noun.prototype);
-        obj.__wbg_ptr = ptr;
-        NounFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        NounFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_noun_free(ptr, 0);
-    }
-    /**
-     * @param {Uint8Array} jam
-     * @returns {Noun}
-     */
-    static cue(jam) {
-        const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.noun_cue(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Noun.__wrap(ret[0]);
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    jam() {
-        const ret = wasm.noun_jam(this.__wbg_ptr);
-        if (ret[3]) {
-            throw takeFromExternrefTable0(ret[2]);
-        }
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
-    }
-    /**
-     * @param {any} value
-     * @returns {Noun}
-     */
-    static fromJs(value) {
-        const ret = wasm.noun_fromJs(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Noun.__wrap(ret[0]);
-    }
-    /**
-     * @returns {any}
-     */
-    toJs() {
-        const ret = wasm.noun_toJs(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-}
-if (Symbol.dispose) Noun.prototype[Symbol.dispose] = Noun.prototype.free;
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+
+const __wbindgen_enum_RequestRedirect = ["follow", "error", "manual"];
 
-const PkhFinalization = (typeof FinalizationRegistry === 'undefined')
+const ExtendedKeyFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pkh_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_extendedkey_free(ptr >>> 0, 1));
 
-export class Pkh {
+export class ExtendedKey {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Pkh.prototype);
+        const obj = Object.create(ExtendedKey.prototype);
         obj.__wbg_ptr = ptr;
-        PkhFinalization.register(obj, obj.__wbg_ptr, obj);
+        ExtendedKeyFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PkhFinalization.unregister(this);
+        ExtendedKeyFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_pkh_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.pkh_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {Pkh}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.pkh_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Pkh.__wrap(ret[0]);
+        wasm.__wbg_extendedkey_free(ptr, 0);
     }
     /**
-     * @returns {bigint}
+     * @returns {Uint8Array}
      */
-    get m() {
-        const ret = wasm.pkh_m(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    get chainCode() {
+        const ret = wasm.extendedkey_chainCode(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
     }
     /**
-     * @param {bigint} m
-     * @param {string[]} hashes
+     * @returns {Uint8Array}
      */
-    constructor(m, hashes) {
-        const ptr0 = passArrayJsValueToWasm0(hashes, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.pkh_new(m, ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        PkhFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    get publicKey() {
+        const ret = wasm.extendedkey_publicKey(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
     }
     /**
-     * @returns {string[]}
+     * @returns {Uint8Array | undefined}
      */
-    get hashes() {
-        const ret = wasm.pkh_hashes(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    get privateKey() {
+        const ret = wasm.extendedkey_privateKey(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
         return v1;
     }
     /**
-     * @param {string} hash
-     * @returns {Pkh}
+     * Derive a child key at the given index
+     * @param {number} index
+     * @returns {ExtendedKey}
      */
-    static single(hash) {
-        const ptr0 = passStringToWasm0(hash, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.pkh_single(ptr0, len0);
-        return Pkh.__wrap(ret);
+    deriveChild(index) {
+        const ret = wasm.extendedkey_deriveChild(this.__wbg_ptr, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ExtendedKey.__wrap(ret[0]);
     }
 }
-if (Symbol.dispose) Pkh.prototype[Symbol.dispose] = Pkh.prototype.free;
+if (Symbol.dispose) ExtendedKey.prototype[Symbol.dispose] = ExtendedKey.prototype.free;
 
-const RawTxFinalization = (typeof FinalizationRegistry === 'undefined')
+const GrpcClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_rawtx_free(ptr >>> 0, 1));
-
-export class RawTx {
+    : new FinalizationRegistry(ptr => wasm.__wbg_grpcclient_free(ptr >>> 0, 1));
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(RawTx.prototype);
-        obj.__wbg_ptr = ptr;
-        RawTxFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class GrpcClient {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        RawTxFinalization.unregister(this);
+        GrpcClientFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rawtx_free(ptr, 0);
-    }
-    /**
-     * Convert to protobuf RawTransaction for sending via gRPC
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.rawtx_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {RawTx}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.rawtx_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return RawTx.__wrap(ret[0]);
-    }
-    /**
-     * @returns {NockchainTx}
-     */
-    toNockchainTx() {
-        const ret = wasm.rawtx_toNockchainTx(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return NockchainTx.__wrap(ret[0]);
-    }
-    /**
-     * @returns {Digest}
-     */
-    get id() {
-        const ret = wasm.rawtx_id(this.__wbg_ptr);
-        return Digest.__wrap(ret);
+        wasm.__wbg_grpcclient_free(ptr, 0);
     }
     /**
-     * @returns {string}
+     * Send a transaction
+     * @param {PbCom2RawTransaction} raw_tx
+     * @returns {Promise<string>}
      */
-    get name() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.rawtx_name(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);
-        }
+    sendTransaction(raw_tx) {
+        const ret = wasm.grpcclient_sendTransaction(this.__wbg_ptr, raw_tx);
+        return ret;
     }
     /**
-     * Convert to jammed transaction file for inspecting through CLI
-     * @returns {Uint8Array}
+     * Check if a transaction was accepted
+     * @param {string} tx_id
+     * @returns {Promise<boolean>}
      */
-    toJam() {
-        const ret = wasm.rawtx_toJam(this.__wbg_ptr);
+    transactionAccepted(tx_id) {
+        const ptr0 = passStringToWasm0(tx_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_transactionAccepted(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
     /**
-     * Calculate output notes from the transaction spends.
-     * @returns {Note[]}
+     * Get balance for a wallet address
+     * @param {string} address
+     * @returns {Promise<PbCom2Balance>}
      */
-    outputs() {
-        const ret = wasm.rawtx_outputs(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
+    getBalanceByAddress(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_getBalanceByAddress(this.__wbg_ptr, ptr0, len0);
+        return ret;
     }
     /**
-     * @returns {Version}
+     * Get balance for a first name
+     * @param {string} first_name
+     * @returns {Promise<PbCom2Balance>}
      */
-    get version() {
-        const ret = wasm.rawtx_version(this.__wbg_ptr);
-        return Version.__wrap(ret);
+    getBalanceByFirstName(first_name) {
+        const ptr0 = passStringToWasm0(first_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.grpcclient_getBalanceByFirstName(this.__wbg_ptr, ptr0, len0);
+        return ret;
     }
     /**
-     * @param {Uint8Array} jam
-     * @returns {RawTx}
+     * @param {string} endpoint
      */
-    static fromJam(jam) {
-        const ptr0 = passArray8ToWasm0(jam, wasm.__wbindgen_malloc);
+    constructor(endpoint) {
+        const ptr0 = passStringToWasm0(endpoint, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.rawtx_fromJam(ptr0, len0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return RawTx.__wrap(ret[0]);
+        const ret = wasm.grpcclient_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        GrpcClientFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
 }
-if (Symbol.dispose) RawTx.prototype[Symbol.dispose] = RawTx.prototype.free;
+if (Symbol.dispose) GrpcClient.prototype[Symbol.dispose] = GrpcClient.prototype.free;
 
-const SeedFinalization = (typeof FinalizationRegistry === 'undefined')
+const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_seed_free(ptr >>> 0, 1));
-
-export class Seed {
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Seed.prototype);
-        obj.__wbg_ptr = ptr;
-        SeedFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class IntoUnderlyingByteSource {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SeedFinalization.unregister(this);
+        IntoUnderlyingByteSourceFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_seed_free(ptr, 0);
-    }
-    /**
-     * @returns {Digest}
-     */
-    get parentHash() {
-        const ret = wasm.seed_parentHash(this.__wbg_ptr);
-        return Digest.__wrap(ret);
-    }
-    /**
-     * @returns {Source | undefined}
-     */
-    get outputSource() {
-        const ret = wasm.seed_outputSource(this.__wbg_ptr);
-        return ret === 0 ? undefined : Source.__wrap(ret);
-    }
-    /**
-     * @param {LockRoot} lock_root
-     */
-    set lockRoot(lock_root) {
-        _assertClass(lock_root, LockRoot);
-        var ptr0 = lock_root.__destroy_into_raw();
-        wasm.seed_set_lockRoot(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * @param {NoteData} note_data
-     */
-    set noteData(note_data) {
-        _assertClass(note_data, NoteData);
-        var ptr0 = note_data.__destroy_into_raw();
-        wasm.seed_set_noteData(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * @param {Digest} pkh
-     * @param {bigint} gift
-     * @param {Digest} parent_hash
-     * @param {boolean} include_lock_data
-     * @returns {Seed}
-     */
-    static newSinglePkh(pkh, gift, parent_hash, include_lock_data) {
-        _assertClass(pkh, Digest);
-        var ptr0 = pkh.__destroy_into_raw();
-        _assertClass(parent_hash, Digest);
-        var ptr1 = parent_hash.__destroy_into_raw();
-        const ret = wasm.seed_newSinglePkh(ptr0, gift, ptr1, include_lock_data);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Seed.__wrap(ret[0]);
-    }
-    /**
-     * @param {Digest} parent_hash
-     */
-    set parentHash(parent_hash) {
-        _assertClass(parent_hash, Digest);
-        var ptr0 = parent_hash.__destroy_into_raw();
-        wasm.seed_set_parentHash(this.__wbg_ptr, ptr0);
-    }
-    /**
-     * @param {Source | null} [output_source]
-     */
-    set outputSource(output_source) {
-        let ptr0 = 0;
-        if (!isLikeNone(output_source)) {
-            _assertClass(output_source, Source);
-            ptr0 = output_source.__destroy_into_raw();
-        }
-        wasm.seed_set_outputSource(this.__wbg_ptr, ptr0);
+        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
     }
     /**
-     * @param {Source | null | undefined} output_source
-     * @param {LockRoot} lock_root
-     * @param {bigint} gift
-     * @param {NoteData} note_data
-     * @param {Digest} parent_hash
+     * @returns {number}
      */
-    constructor(output_source, lock_root, gift, note_data, parent_hash) {
-        let ptr0 = 0;
-        if (!isLikeNone(output_source)) {
-            _assertClass(output_source, Source);
-            ptr0 = output_source.__destroy_into_raw();
-        }
-        _assertClass(lock_root, LockRoot);
-        var ptr1 = lock_root.__destroy_into_raw();
-        _assertClass(note_data, NoteData);
-        var ptr2 = note_data.__destroy_into_raw();
-        _assertClass(parent_hash, Digest);
-        var ptr3 = parent_hash.__destroy_into_raw();
-        const ret = wasm.seed_new(ptr0, ptr1, gift, ptr2, ptr3);
-        this.__wbg_ptr = ret >>> 0;
-        SeedFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    get autoAllocateChunkSize() {
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * @returns {bigint}
+     * @param {ReadableByteStreamController} controller
+     * @returns {Promise<any>}
      */
-    get gift() {
-        const ret = wasm.seed_gift(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+    pull(controller) {
+        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+        return ret;
     }
     /**
-     * @param {bigint} gift
+     * @param {ReadableByteStreamController} controller
      */
-    set gift(gift) {
-        wasm.seed_set_gift(this.__wbg_ptr, gift);
+    start(controller) {
+        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
     }
     /**
-     * @returns {LockRoot}
+     * @returns {ReadableStreamType}
      */
-    get lockRoot() {
-        const ret = wasm.seed_lockRoot(this.__wbg_ptr);
-        return LockRoot.__wrap(ret);
+    get type() {
+        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+        return __wbindgen_enum_ReadableStreamType[ret];
     }
-    /**
-     * @returns {NoteData}
-     */
-    get noteData() {
-        const ret = wasm.seed_noteData(this.__wbg_ptr);
-        return NoteData.__wrap(ret);
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingbytesource_cancel(ptr);
     }
 }
-if (Symbol.dispose) Seed.prototype[Symbol.dispose] = Seed.prototype.free;
+if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
 
-const SignatureFinalization = (typeof FinalizationRegistry === 'undefined')
+const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_signature_free(ptr >>> 0, 1));
-
-export class Signature {
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Signature.prototype);
-        obj.__wbg_ptr = ptr;
-        SignatureFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class IntoUnderlyingSink {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SignatureFinalization.unregister(this);
+        IntoUnderlyingSinkFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_signature_free(ptr, 0);
+        wasm.__wbg_intounderlyingsink_free(ptr, 0);
     }
     /**
-     * @returns {Uint8Array}
+     * @param {any} reason
+     * @returns {Promise<any>}
      */
-    get c() {
-        const ret = wasm.signature_c(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+    abort(reason) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_abort(ptr, reason);
+        return ret;
     }
     /**
-     * @returns {Uint8Array}
+     * @returns {Promise<any>}
      */
-    get s() {
-        const ret = wasm.signature_s(this.__wbg_ptr);
-        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-        return v1;
+    close() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_close(ptr);
+        return ret;
     }
     /**
-     * @param {Uint8Array} c
-     * @param {Uint8Array} s
+     * @param {any} chunk
+     * @returns {Promise<any>}
      */
-    constructor(c, s) {
-        const ptr0 = passArray8ToWasm0(c, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray8ToWasm0(s, wasm.__wbindgen_malloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.signature_new(ptr0, len0, ptr1, len1);
-        this.__wbg_ptr = ret >>> 0;
-        SignatureFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    write(chunk) {
+        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+        return ret;
     }
 }
-if (Symbol.dispose) Signature.prototype[Symbol.dispose] = Signature.prototype.free;
+if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
 
-const SourceFinalization = (typeof FinalizationRegistry === 'undefined')
+const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_source_free(ptr >>> 0, 1));
-
-export class Source {
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
 
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Source.prototype);
-        obj.__wbg_ptr = ptr;
-        SourceFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
+export class IntoUnderlyingSource {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        SourceFinalization.unregister(this);
+        IntoUnderlyingSourceFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_source_free(ptr, 0);
+        wasm.__wbg_intounderlyingsource_free(ptr, 0);
     }
     /**
-     * @returns {boolean}
+     * @param {ReadableStreamDefaultController} controller
+     * @returns {Promise<any>}
      */
-    get isCoinbase() {
-        const ret = wasm.source_isCoinbase(this.__wbg_ptr);
-        return ret !== 0;
+    pull(controller) {
+        const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+        return ret;
     }
-    /**
-     * @returns {Digest}
-     */
-    get hash() {
-        const ret = wasm.source_hash(this.__wbg_ptr);
-        return Digest.__wrap(ret);
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingsource_cancel(ptr);
     }
 }
-if (Symbol.dispose) Source.prototype[Symbol.dispose] = Source.prototype.free;
+if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
 
 const SpendBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
@@ -2155,17 +853,13 @@ export class SpendBuilder {
         wasm.__wbg_spendbuilder_free(ptr, 0);
     }
     /**
-     * Get current refund
-     * @returns {Seed | undefined}
+     * @returns {SeedV1 | undefined}
      */
     curRefund() {
         const ret = wasm.spendbuilder_curRefund(this.__wbg_ptr);
-        return ret === 0 ? undefined : Seed.__wrap(ret);
+        return ret;
     }
     /**
-     * Checks whether note.assets = seeds + fee
-     *
-     * This function needs to return true for `TxBuilder::validate` to pass
      * @returns {boolean}
      */
     isBalanced() {
@@ -2173,7 +867,6 @@ export class SpendBuilder {
         return ret !== 0;
     }
     /**
-     * Attatch a preimage to this spend
      * @param {Uint8Array} preimage_jam
      * @returns {Digest | undefined}
      */
@@ -2184,35 +877,19 @@ export class SpendBuilder {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0] === 0 ? undefined : Digest.__wrap(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Compute refund from any spare assets, given `refund_lock` was passed
      * @param {boolean} include_lock_data
      */
     computeRefund(include_lock_data) {
         wasm.spendbuilder_computeRefund(this.__wbg_ptr, include_lock_data);
     }
-    /**
-     * Manually invalidate signatures
-     *
-     * Each spend's fee+seeds are bound to one or more signatures. If they get changed, the
-     * signature becomes invalid. This builder automatically invalidates signatures upon relevant
-     * modifications, but this functionality is provided nonetheless.
-     */
     invalidateSigs() {
         wasm.spendbuilder_invalidateSigs(this.__wbg_ptr);
     }
     /**
-     * Get the list of missing "unlocks"
-     *
-     * An unlock is a spend condition to be satisfied. For instance, for a `Pkh` spend condition,
-     * if the transaction is unsigned, this function will return a Pkh type missing unlock, with
-     * the list of valid PKH's and number of signatures needed. This will not return PKHs that are
-     * already attatched to the spend (relevant for multisigs). For `Hax` spend condition, this
-     * will return any missing preimages. This function will return a list of not-yet-validated
-     * spend conditions.
-     * @returns {any[]}
+     * @returns {MissingUnlocks[]}
      */
     missingUnlocks() {
         const ret = wasm.spendbuilder_missingUnlocks(this.__wbg_ptr);
@@ -2224,8 +901,7 @@ export class SpendBuilder {
         return v1;
     }
     /**
-     * Set the fee of this spend
-     * @param {bigint} fee
+     * @param {Nicks} fee
      */
     fee(fee) {
         wasm.spendbuilder_fee(this.__wbg_ptr, fee);
@@ -2237,19 +913,7 @@ export class SpendBuilder {
      * @param {SpendCondition | null} [refund_lock]
      */
     constructor(note, spend_condition, refund_lock) {
-        _assertClass(note, Note);
-        var ptr0 = note.__destroy_into_raw();
-        let ptr1 = 0;
-        if (!isLikeNone(spend_condition)) {
-            _assertClass(spend_condition, SpendCondition);
-            ptr1 = spend_condition.__destroy_into_raw();
-        }
-        let ptr2 = 0;
-        if (!isLikeNone(refund_lock)) {
-            _assertClass(refund_lock, SpendCondition);
-            ptr2 = refund_lock.__destroy_into_raw();
-        }
-        const ret = wasm.spendbuilder_new(ptr0, ptr1, ptr2);
+        const ret = wasm.spendbuilder_new(note, isLikeNone(spend_condition) ? 0 : addToExternrefTable0(spend_condition), isLikeNone(refund_lock) ? 0 : addToExternrefTable0(refund_lock));
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -2258,24 +922,15 @@ export class SpendBuilder {
         return this;
     }
     /**
-     * Add seed to this spend
-     *
-     * Seed is an output with a recipient (as defined by the spend condition).
-     *
-     * Nockchain transaction engine will take all seeds with matching lock from all spends in the
-     * transaction, and merge them into one output note.
-     * @param {Seed} seed
+     * @param {SeedV1} seed
      */
     seed(seed) {
-        _assertClass(seed, Seed);
-        var ptr0 = seed.__destroy_into_raw();
-        const ret = wasm.spendbuilder_seed(this.__wbg_ptr, ptr0);
+        const ret = wasm.spendbuilder_seed(this.__wbg_ptr, seed);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * Sign the transaction with a given private key
      * @param {Uint8Array} signing_key_bytes
      * @returns {boolean}
      */
@@ -2291,211 +946,6 @@ export class SpendBuilder {
 }
 if (Symbol.dispose) SpendBuilder.prototype[Symbol.dispose] = SpendBuilder.prototype.free;
 
-const SpendConditionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_spendcondition_free(ptr >>> 0, 1));
-
-export class SpendCondition {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(SpendCondition.prototype);
-        obj.__wbg_ptr = ptr;
-        SpendConditionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    static __unwrap(jsValue) {
-        if (!(jsValue instanceof SpendCondition)) {
-            return 0;
-        }
-        return jsValue.__destroy_into_raw();
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        SpendConditionFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_spendcondition_free(ptr, 0);
-    }
-    /**
-     * @returns {Digest}
-     */
-    firstName() {
-        const ret = wasm.spendcondition_firstName(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Digest.__wrap(ret[0]);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.spendcondition_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {any} value
-     * @returns {SpendCondition}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.spendcondition_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return SpendCondition.__wrap(ret[0]);
-    }
-    /**
-     * @param {LockPrimitive[]} primitives
-     */
-    constructor(primitives) {
-        const ptr0 = passArrayJsValueToWasm0(primitives, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.spendcondition_new(ptr0, len0);
-        this.__wbg_ptr = ret >>> 0;
-        SpendConditionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {Digest}
-     */
-    hash() {
-        const ret = wasm.spendcondition_hash(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Digest.__wrap(ret[0]);
-    }
-    /**
-     * @param {Pkh} pkh
-     * @returns {SpendCondition}
-     */
-    static newPkh(pkh) {
-        _assertClass(pkh, Pkh);
-        var ptr0 = pkh.__destroy_into_raw();
-        const ret = wasm.spendcondition_newPkh(ptr0);
-        return SpendCondition.__wrap(ret);
-    }
-}
-if (Symbol.dispose) SpendCondition.prototype[Symbol.dispose] = SpendCondition.prototype.free;
-
-const TimelockFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_timelock_free(ptr >>> 0, 1));
-/**
- * Timelock for V0 (legacy) notes
- *
- * This is similar to LockTim but used for v0 notes' timelock constraints.
- * At least one constraint (min or max in either rel or abs) must be set.
- */
-export class Timelock {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TimelockFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_timelock_free(ptr, 0);
-    }
-    /**
-     * @returns {TimelockRange}
-     */
-    get abs() {
-        const ret = wasm.locktim_abs(this.__wbg_ptr);
-        return TimelockRange.__wrap(ret);
-    }
-    /**
-     * @param {TimelockRange} rel
-     * @param {TimelockRange} abs
-     */
-    constructor(rel, abs) {
-        _assertClass(rel, TimelockRange);
-        var ptr0 = rel.__destroy_into_raw();
-        _assertClass(abs, TimelockRange);
-        var ptr1 = abs.__destroy_into_raw();
-        const ret = wasm.timelock_new(ptr0, ptr1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        TimelockFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {TimelockRange}
-     */
-    get rel() {
-        const ret = wasm.locktim_rel(this.__wbg_ptr);
-        return TimelockRange.__wrap(ret);
-    }
-}
-if (Symbol.dispose) Timelock.prototype[Symbol.dispose] = Timelock.prototype.free;
-
-const TimelockRangeFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_timelockrange_free(ptr >>> 0, 1));
-
-export class TimelockRange {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(TimelockRange.prototype);
-        obj.__wbg_ptr = ptr;
-        TimelockRangeFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TimelockRangeFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_timelockrange_free(ptr, 0);
-    }
-    /**
-     * @returns {bigint | undefined}
-     */
-    get max() {
-        const ret = wasm.timelockrange_max(this.__wbg_ptr);
-        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
-    }
-    /**
-     * @returns {bigint | undefined}
-     */
-    get min() {
-        const ret = wasm.timelockrange_min(this.__wbg_ptr);
-        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
-    }
-    /**
-     * @param {bigint | null} [min]
-     * @param {bigint | null} [max]
-     */
-    constructor(min, max) {
-        const ret = wasm.timelockrange_new(!isLikeNone(min), isLikeNone(min) ? BigInt(0) : min, !isLikeNone(max), isLikeNone(max) ? BigInt(0) : max);
-        this.__wbg_ptr = ret >>> 0;
-        TimelockRangeFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) TimelockRange.prototype[Symbol.dispose] = TimelockRange.prototype.free;
-
 const TxBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_txbuilder_free(ptr >>> 0, 1));
@@ -2531,7 +981,6 @@ export class TxBuilder {
         return v1;
     }
     /**
-     * Appends `preimage_jam` to all spend conditions that expect this preimage.
      * @param {Uint8Array} preimage_jam
      * @returns {Digest | undefined}
      */
@@ -2542,47 +991,14 @@ export class TxBuilder {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return ret[0] === 0 ? undefined : Digest.__wrap(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
-     * Perform a simple-spend on this builder.
-     *
-     * It is HIGHLY recommended to not mix `simpleSpend` with other types of spends.
-     *
-     * This performs a fairly complex set of operations, in order to mimic behavior of nockchain
-     * CLI wallet's create-tx option. Note that we do not do 1-1 mapping of that functionality,
-     * most notably - if `recipient` is the same as `refund_pkh`, we will create 1 seed, while the
-     * CLI wallet will create 2.
-     *
-     * Another difference is that you should call `sign` and `validate` after calling this method.
-     *
-     * Internally, the transaction builder takes ALL of the `notes` provided, and stores them for
-     * fee adjustments. If there are multiple notes being used, our fee setup also differs from
-     * the CLI, because we first greedily spend the notes out, and then take fees from any
-     * remaining refunds.
-     *
-     * This function prioritizes using the least number of notes possible, because that lowers the
-     * fee used.
-     *
-     * You may choose to override the fee with `fee_override`, but do note that `validate` will
-     * fail, in case this fee is too small.
-     *
-     * `include_lock_data` can be used to include `%lock` key in note-data, with the
-     * `SpendCondition` used. However, note-data costs 1 << 15 nicks, which means, it can get
-     * expensive.
-     *
-     * Optional parameter `remove_unused_notes`, if set to false, will keep the notes in the
-     * transaction builder. This is meant to be used whenever additional operations are performed
-     * on the builder, such as additional spends, or `addPreimage` calls. All of these increase
-     * the required fee (which can be checked with `calcFee`), and unused notes can then be used
-     * to adjust fees with `setFeeAndBalanceRefund` or `recalcAndSetFee`. Once all operations are
-     * done, one should call `removeUnusedNotes` to ensure these notes are not used within the
-     * transaction.
      * @param {Note[]} notes
      * @param {SpendCondition[]} spend_conditions
      * @param {Digest} recipient
-     * @param {bigint} gift
-     * @param {bigint | null | undefined} fee_override
+     * @param {Nicks} gift
+     * @param {Nicks | null | undefined} fee_override
      * @param {Digest} refund_pkh
      * @param {boolean} include_lock_data
      */
@@ -2591,17 +1007,12 @@ export class TxBuilder {
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayJsValueToWasm0(spend_conditions, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        _assertClass(recipient, Digest);
-        var ptr2 = recipient.__destroy_into_raw();
-        _assertClass(refund_pkh, Digest);
-        var ptr3 = refund_pkh.__destroy_into_raw();
-        const ret = wasm.txbuilder_simpleSpend(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, gift, !isLikeNone(fee_override), isLikeNone(fee_override) ? BigInt(0) : fee_override, ptr3, include_lock_data);
+        const ret = wasm.txbuilder_simpleSpend(this.__wbg_ptr, ptr0, len0, ptr1, len1, recipient, gift, isLikeNone(fee_override) ? 0 : addToExternrefTable0(fee_override), refund_pkh, include_lock_data);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * Recalculate fee and set it, balancing things out with refunds
      * @param {boolean} include_lock_data
      */
     recalcAndSetFee(include_lock_data) {
@@ -2611,14 +1022,7 @@ export class TxBuilder {
         }
     }
     /**
-     * Distributes `fee` across builder's spends, and balances refunds out
-     *
-     * `adjust_fee` parameter allows the fee to be slightly tweaked, whenever notes are added or
-     * removed to/from the builder's fee note pool. This is because using more or less notes
-     * impacts the exact fee being required. If the caller estimates fee and sets it, adding more
-     * notes will change the exact fee needed, and setting this parameter to true will allow one
-     * to not have to call this function multiple times.
-     * @param {bigint} fee
+     * @param {Nicks} fee
      * @param {boolean} adjust_fee
      * @param {boolean} include_lock_data
      */
@@ -2630,7 +1034,7 @@ export class TxBuilder {
     }
     /**
      * Create an empty transaction builder
-     * @param {bigint} fee_per_word
+     * @param {Nicks} fee_per_word
      */
     constructor(fee_per_word) {
         const ret = wasm.txbuilder_new(fee_per_word);
@@ -2639,9 +1043,6 @@ export class TxBuilder {
         return this;
     }
     /**
-     * Sign the transaction with a private key.
-     *
-     * This will sign all spends that are still missing signature from
      * @param {Uint8Array} signing_key_bytes
      */
     sign(signing_key_bytes) {
@@ -2660,7 +1061,7 @@ export class TxBuilder {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return NockchainTx.__wrap(ret[0]);
+        return takeFromExternrefTable0(ret[0]);
     }
     /**
      * Append a `SpendBuilder` to this transaction
@@ -2674,54 +1075,37 @@ export class TxBuilder {
         return ret === 0 ? undefined : SpendBuilder.__wrap(ret);
     }
     /**
-     * Gets the current fee set on all spends.
-     * @returns {bigint}
+     * @returns {Nicks}
      */
     curFee() {
         const ret = wasm.txbuilder_curFee(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+        return ret;
     }
     /**
      * Reconstruct a builder from raw transaction and its input notes.
-     *
-     * To get the builder back, you must pass the notes and their corresponding spend conditions.
-     * If serializing the builder, call `WasmTxBuilder::all_notes`.
      * @param {RawTx} tx
      * @param {Note[]} notes
      * @param {SpendCondition[]} spend_conditions
      * @returns {TxBuilder}
      */
     static fromTx(tx, notes, spend_conditions) {
-        _assertClass(tx, RawTx);
-        var ptr0 = tx.__destroy_into_raw();
-        const ptr1 = passArrayJsValueToWasm0(notes, wasm.__wbindgen_malloc);
+        const ptr0 = passArrayJsValueToWasm0(notes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayJsValueToWasm0(spend_conditions, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArrayJsValueToWasm0(spend_conditions, wasm.__wbindgen_malloc);
-        const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.txbuilder_fromTx(ptr0, ptr1, len1, ptr2, len2);
+        const ret = wasm.txbuilder_fromTx(tx, ptr0, len0, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return TxBuilder.__wrap(ret[0]);
     }
     /**
-     * Calculates the fee needed for the transaction.
-     *
-     * NOTE: if the transaction is unsigned, this function will estimate the fee needed, supposing
-     * all signatures are added. However, this heuristic is only accurate for one signature. In
-     * addition, this fee calculation does not estimate the size of missing preimages.
-     *
-     * So, first, add missing preimages, and only then calc the fee. If you're building a multisig
-     * transaction, this value might be incorrect.
-     * @returns {bigint}
+     * @returns {Nicks}
      */
     calcFee() {
         const ret = wasm.txbuilder_calcFee(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
+        return ret;
     }
-    /**
-     * Validate the transaction.
-     */
     validate() {
         const ret = wasm.txbuilder_validate(this.__wbg_ptr);
         if (ret[1]) {
@@ -2736,155 +1120,10 @@ export class TxBuilder {
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return TxNotes.__wrap(ret[0]);
-    }
-}
-if (Symbol.dispose) TxBuilder.prototype[Symbol.dispose] = TxBuilder.prototype.free;
-
-const TxNotesFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_txnotes_free(ptr >>> 0, 1));
-
-export class TxNotes {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(TxNotes.prototype);
-        obj.__wbg_ptr = ptr;
-        TxNotesFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        TxNotesFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_txnotes_free(ptr, 0);
-    }
-    /**
-     * @returns {SpendCondition[]}
-     */
-    get spendConditions() {
-        const ret = wasm.txnotes_spendConditions(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-    /**
-     * @returns {Note[]}
-     */
-    get notes() {
-        const ret = wasm.txnotes_notes(this.__wbg_ptr);
-        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
-        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
-        return v1;
-    }
-}
-if (Symbol.dispose) TxNotes.prototype[Symbol.dispose] = TxNotes.prototype.free;
-
-const VersionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_version_free(ptr >>> 0, 1));
-
-export class Version {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(Version.prototype);
-        obj.__wbg_ptr = ptr;
-        VersionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        VersionFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_version_free(ptr, 0);
-    }
-    /**
-     * @returns {Version}
-     */
-    static V0() {
-        const ret = wasm.version_V0();
-        return Version.__wrap(ret);
-    }
-    /**
-     * @returns {Version}
-     */
-    static V1() {
-        const ret = wasm.version_V1();
-        return Version.__wrap(ret);
-    }
-    /**
-     * @returns {Version}
-     */
-    static V2() {
-        const ret = wasm.version_V2();
-        return Version.__wrap(ret);
-    }
-    /**
-     * @param {number} version
-     */
-    constructor(version) {
-        const ret = wasm.version_new(version);
-        this.__wbg_ptr = ret >>> 0;
-        VersionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) Version.prototype[Symbol.dispose] = Version.prototype.free;
-
-const WasmSeedFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wasmseed_free(ptr >>> 0, 1));
-
-export class WasmSeed {
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        WasmSeedFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmseed_free(ptr, 0);
-    }
-    /**
-     * @returns {any}
-     */
-    toProtobuf() {
-        const ret = wasm.wasmseed_toProtobuf(this.__wbg_ptr);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
         return takeFromExternrefTable0(ret[0]);
     }
-    /**
-     * @param {any} value
-     * @returns {Seed}
-     */
-    static fromProtobuf(value) {
-        const ret = wasm.wasmseed_fromProtobuf(value);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return Seed.__wrap(ret[0]);
-    }
 }
-if (Symbol.dispose) WasmSeed.prototype[Symbol.dispose] = WasmSeed.prototype.free;
+if (Symbol.dispose) TxBuilder.prototype[Symbol.dispose] = TxBuilder.prototype.free;
 
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
@@ -3055,14 +1294,6 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_close_6956df845478561a = function() { return handleError(function (arg0) {
         arg0.close();
     }, arguments) };
-    imports.wbg.__wbg_digest_new = function(arg0) {
-        const ret = Digest.__wrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_digest_unwrap = function(arg0) {
-        const ret = Digest.__unwrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_done_2042aa2670fb1db1 = function(arg0) {
         const ret = arg0.done;
         return ret;
@@ -3164,10 +1395,6 @@ function __wbg_get_imports() {
         const ret = arg0.length;
         return ret;
     };
-    imports.wbg.__wbg_lockprimitive_unwrap = function(arg0) {
-        const ret = LockPrimitive.__unwrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_new_1acc0b6eea89d040 = function() {
         const ret = new Object();
         return ret;
@@ -3230,22 +1457,6 @@ function __wbg_get_imports() {
         const ret = arg0.next;
         return ret;
     };
-    imports.wbg.__wbg_note_new = function(arg0) {
-        const ret = Note.__wrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_note_unwrap = function(arg0) {
-        const ret = Note.__unwrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_notedataentry_new = function(arg0) {
-        const ret = NoteDataEntry.__wrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_notedataentry_unwrap = function(arg0) {
-        const ret = NoteDataEntry.__unwrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
         Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
     };
@@ -3313,14 +1524,6 @@ function __wbg_get_imports() {
         const ret = SpendBuilder.__wrap(arg0);
         return ret;
     };
-    imports.wbg.__wbg_spendcondition_new = function(arg0) {
-        const ret = SpendCondition.__wrap(arg0);
-        return ret;
-    };
-    imports.wbg.__wbg_spendcondition_unwrap = function(arg0) {
-        const ret = SpendCondition.__unwrap(arg0);
-        return ret;
-    };
     imports.wbg.__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e = function() {
         const ret = typeof global === 'undefined' ? null : global;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -3361,6 +1564,11 @@ function __wbg_get_imports() {
         const ret = arg0.view;
         return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
+    imports.wbg.__wbindgen_cast_08298b8ed11def05 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 335, function: Function { arguments: [Externref], shim_idx: 336, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h20e54f17b0de8c43, wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b);
+        return ret;
+    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -3371,11 +1579,6 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return ret;
     };
-    imports.wbg.__wbindgen_cast_8b855ba391b91225 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 285, function: Function { arguments: [Externref], shim_idx: 286, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h20e54f17b0de8c43, wasm_bindgen__convert__closures_____invoke__hbf186e27576c509b);
-        return ret;
-    };
     imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
         // Cast intrinsic for `I64 -> Externref`.
         const ret = arg0;