@provablehq/wasm 0.8.4 → 0.8.6

package/dist/mainnet/index.js

@@ -234,6 +234,14 @@ function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
+
+let stack_pointer = 128;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
 /**
  * @param {number} receiver
  */
@@ -251,11 +259,11 @@ function initThreadPool$1(url, num_threads) {
     return takeObject(ret);
 }
 
-function __wbg_adapter_38(arg0, arg1, arg2) {
+function __wbg_adapter_40(arg0, arg1, arg2) {
     wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_417(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_491(arg0, arg1, arg2, arg3) {
     wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
@@ -383,586 +391,1927 @@ class Address {
     }
 }
 
-const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
+const BHP1024Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr >>> 0, 1));
-/**
- * SnarkVM Ciphertext object. A Ciphertext represents an symmetrically encrypted plaintext. This
- * object provides decryption methods to recover the plaintext from the ciphertext (given the
- * api consumer has the proper decryption materials).
- *
- * @example
- */
-class Ciphertext {
+    : new FinalizationRegistry(ptr => wasm.__wbg_bhp1024_free(ptr >>> 0, 1));
+
+class BHP1024 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Ciphertext.prototype);
+        const obj = Object.create(BHP1024.prototype);
         obj.__wbg_ptr = ptr;
-        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
+        BHP1024Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        CiphertextFinalization.unregister(this);
+        BHP1024Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ciphertext_free(ptr, 0);
+        wasm.__wbg_bhp1024_free(ptr, 0);
     }
     /**
-     * Decrypt the ciphertext using the given view key.
-     *
-     * @param {ViewKey} The view key of the account that encrypted the ciphertext.
-     * @param {Group} The nonce used to encrypt the ciphertext.
-     *
-     * @returns {Plaintext} The decrypted plaintext.
-     * @param {ViewKey} view_key
-     * @param {Group} nonce
-     * @returns {Plaintext}
+     * Create a BHP hasher with an input size of 1024 bits.
      */
-    decrypt(view_key, nonce) {
+    constructor() {
+        const ret = wasm.bhp1024_new();
+        this.__wbg_ptr = ret >>> 0;
+        BHP1024Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a BHP hasher with an input size of 1024 bits with a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {BHP1024}
+     */
+    static setup(domain_separator) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(view_key, ViewKey);
-            var ptr0 = view_key.__destroy_into_raw();
-            _assertClass(nonce, Group);
-            var ptr1 = nonce.__destroy_into_raw();
-            wasm.ciphertext_decrypt(retptr, this.__wbg_ptr, ptr0, ptr1);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bhp1024_setup(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Plaintext.__wrap(r0);
+            return BHP1024.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Decrypts a ciphertext into plaintext using the given transition view key.
-     *
-     * @param {Field} transition_view_key The transition view key that was used to encrypt the ciphertext.
-     *
-     * @returns {Plaintext} The decrypted plaintext.
-     * @param {Field} transition_view_key
-     * @returns {Plaintext}
+     * Returns the BHP hash with an input hasher of 1024 bits.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    decryptSymmetric(transition_view_key) {
+    hash(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(transition_view_key, Field);
-            var ptr0 = transition_view_key.__destroy_into_raw();
-            wasm.ciphertext_decryptSymmetric(retptr, this.__wbg_ptr, ptr0);
+            wasm.bhp1024_hash(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Plaintext.__wrap(r0);
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Deserialize a left endian byte array into a Ciphertext.
-     *
-     * @param {Uint8Array} bytes The byte array representing the Ciphertext.
-     *
-     * @returns {Ciphertext} The Ciphertext object.
-     * @param {Uint8Array} bytes
-     * @returns {Ciphertext}
+     * Returns a BHP hash with an input hasher of 1024 bits.
+     * @param {Array<any>} input
+     * @returns {Group}
      */
-    static fromBytesLe(bytes) {
+    hashToGroup(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.ciphertext_fromBytesLe(retptr, addHeapObject(bytes));
+            wasm.bhp1024_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Ciphertext.__wrap(r0);
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Deserialize a Ciphertext string into a Ciphertext object.
-     *
-     * @param {string} ciphertext A string representation of the ciphertext.
-     *
-     * @returns {Ciphertext} The Ciphertext object.
-     * @param {string} ciphertext
-     * @returns {Ciphertext}
+     * Returns a BHP commitment with an input hasher of 1024 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Field}
      */
-    static fromString(ciphertext) {
+    commit(input, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(ciphertext, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.ciphertext_fromString(retptr, ptr0, len0);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp1024_commit(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Ciphertext.__wrap(r0);
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Serialize a Ciphertext object into a byte array.
-     *
-     * @returns {Uint8Array} The serialized Ciphertext.
-     * @returns {Uint8Array}
+     * Returns a BHP commitment with an input hasher of 1024 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Group}
      */
-    toBytes() {
+    commitToGroup(input, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.ciphertext_toBytes(retptr, this.__wbg_ptr);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp1024_commitToGroup(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Serialize a Ciphertext into a js string.
-     *
-     * @returns {string} The serialized Ciphertext.
-     * @returns {string}
-     */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.ciphertext_toString(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
 }
 
-const ComputeKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+const BHP256Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_computekey_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_bhp256_free(ptr >>> 0, 1));
 
-class ComputeKey {
+class BHP256 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ComputeKey.prototype);
+        const obj = Object.create(BHP256.prototype);
         obj.__wbg_ptr = ptr;
-        ComputeKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        BHP256Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ComputeKeyFinalization.unregister(this);
+        BHP256Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_computekey_free(ptr, 0);
+        wasm.__wbg_bhp256_free(ptr, 0);
     }
     /**
-     * Create a new compute key from a private key.
-     *
-     * @param {PrivateKey} private_key Private key
-     *
-     * @returns {ComputeKey} Compute key
-     * @param {PrivateKey} private_key
-     * @returns {ComputeKey}
+     * Create a BHP hasher with an input size of 256 bits.
      */
-    static from_private_key(private_key) {
-        _assertClass(private_key, PrivateKey);
-        const ret = wasm.computekey_from_private_key(private_key.__wbg_ptr);
-        return ComputeKey.__wrap(ret);
+    constructor() {
+        const ret = wasm.bhp256_new();
+        this.__wbg_ptr = ret >>> 0;
+        BHP256Finalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Get the address from the compute key.
-     *
-     * @returns {Address}
-     * @returns {Address}
+     * Create a BHP hasher with an input size of 256 bits with a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {BHP256}
      */
-    address() {
-        const ret = wasm.address_from_compute_key(this.__wbg_ptr);
-        return Address.__wrap(ret);
+    static setup(domain_separator) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bhp256_setup(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return BHP256.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Get the sk_prf of the compute key.
-     *
-     * @returns {Scalar} sk_prf
-     * @returns {Scalar}
+     * Returns the BHP hash with an input hasher of 256 bits.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    sk_prf() {
-        const ret = wasm.computekey_sk_prf(this.__wbg_ptr);
-        return Scalar.__wrap(ret);
+    hash(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bhp256_hash(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Get the pr_tag of the compute key.
-     *
-     * @returns {Group} pr_tag
+     * Returns a BHP hash with an input hasher of 256 bits.
+     * @param {Array<any>} input
      * @returns {Group}
      */
-    pk_sig() {
-        const ret = wasm.computekey_pk_sig(this.__wbg_ptr);
-        return Group.__wrap(ret);
+    hashToGroup(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bhp256_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Get the pr_sig of the compute key.
-     *
-     * @returns {Group} pr_sig
+     * Returns a BHP commitment with an input hasher of 256 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Field}
+     */
+    commit(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp256_commit(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns a BHP commitment with an input hasher of 256 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
      * @returns {Group}
      */
-    pr_sig() {
-        const ret = wasm.computekey_pr_sig(this.__wbg_ptr);
-        return Group.__wrap(ret);
+    commitToGroup(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp256_commitToGroup(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 
-const ExecutionFinalization = (typeof FinalizationRegistry === 'undefined')
+const BHP512Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_execution_free(ptr >>> 0, 1));
-/**
- * Execution of an Aleo program.
- */
-class Execution {
+    : new FinalizationRegistry(ptr => wasm.__wbg_bhp512_free(ptr >>> 0, 1));
+
+class BHP512 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Execution.prototype);
+        const obj = Object.create(BHP512.prototype);
         obj.__wbg_ptr = ptr;
-        ExecutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        BHP512Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ExecutionFinalization.unregister(this);
+        BHP512Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_execution_free(ptr, 0);
+        wasm.__wbg_bhp512_free(ptr, 0);
     }
     /**
-     * Returns the string representation of the execution.
-     *
-     * @returns {string} The string representation of the execution.
-     * @returns {string}
+     * Create a BHP hasher with an input size of 512 bits.
      */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
+    constructor() {
+        const ret = wasm.bhp512_new();
+        this.__wbg_ptr = ret >>> 0;
+        BHP512Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a BHP hasher with an input size of 512 bits with a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {BHP512}
+     */
+    static setup(domain_separator) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.execution_toString(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bhp512_setup(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return BHP512.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Creates an execution object from a string representation of an execution.
-     *
-     * @returns {Execution | Error} The wasm representation of an execution object.
-     * @param {string} execution
-     * @returns {Execution}
+     * Returns the BHP hash with an input hasher of 512 bits.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    static fromString(execution) {
+    hash(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(execution, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.execution_fromString(retptr, ptr0, len0);
+            wasm.bhp512_hash(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Execution.__wrap(r0);
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Returns the global state root of the execution.
-     *
-     * @returns {Execution | Error} The global state root used in the execution.
-     * @returns {string}
+     * Returns a BHP hash with an input hasher of 512 bits.
+     * @param {Array<any>} input
+     * @returns {Group}
      */
-    globalStateRoot() {
-        let deferred1_0;
-        let deferred1_1;
+    hashToGroup(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.execution_globalStateRoot(retptr, this.__wbg_ptr);
+            wasm.bhp512_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Returns the proof of the execution.
-     *
-     * @returns {string} The execution proof.
-     * @returns {string}
+     * Returns a BHP commitment with an input hasher of 512 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Field}
      */
-    proof() {
-        let deferred1_0;
-        let deferred1_1;
+    commit(input, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.execution_proof(retptr, this.__wbg_ptr);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp512_commit(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Returns the transitions present in the execution.
-     *
-     * @returns Array<Transition> the array of transitions present in the execution.
-     * @returns {Array<any>}
+     * Returns a BHP commitment with an input hasher of 512 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Group}
      */
-    transitions() {
-        const ret = wasm.execution_transitions(this.__wbg_ptr);
-        return takeObject(ret);
+    commitToGroup(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp512_commitToGroup(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 
-const ExecutionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+const BHP768Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_executionresponse_free(ptr >>> 0, 1));
-/**
- * Webassembly Representation of an Aleo function execution response
- *
- * This object is returned by the execution of an Aleo function off-chain. It provides methods for
- * retrieving the outputs of the function execution.
- */
-class ExecutionResponse {
+    : new FinalizationRegistry(ptr => wasm.__wbg_bhp768_free(ptr >>> 0, 1));
+
+class BHP768 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(ExecutionResponse.prototype);
+        const obj = Object.create(BHP768.prototype);
         obj.__wbg_ptr = ptr;
-        ExecutionResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        BHP768Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        ExecutionResponseFinalization.unregister(this);
+        BHP768Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_executionresponse_free(ptr, 0);
-    }
-    /**
-     * Get the outputs of the executed function
-     *
-     * @returns {Array} Array of strings representing the outputs of the function
-     * @returns {Array<any>}
-     */
-    getOutputs() {
-        const ret = wasm.executionresponse_getOutputs(this.__wbg_ptr);
-        return takeObject(ret);
+        wasm.__wbg_bhp768_free(ptr, 0);
     }
     /**
-     * Returns the execution object if present, null if otherwise.
-     *
-     * @returns {Execution | undefined} The execution object if present, null if otherwise
-     * @returns {Execution | undefined}
+     * Create a BHP hasher with an input size of 768 bits.
      */
-    getExecution() {
-        const ret = wasm.executionresponse_getExecution(this.__wbg_ptr);
-        return ret === 0 ? undefined : Execution.__wrap(ret);
+    constructor() {
+        const ret = wasm.bhp768_new();
+        this.__wbg_ptr = ret >>> 0;
+        BHP768Finalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Returns the program keys if present
-     * @returns {KeyPair}
+     * Create a BHP hasher with an input size of 768 bits with a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {BHP768}
      */
-    getKeys() {
+    static setup(domain_separator) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.executionresponse_getKeys(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.bhp768_setup(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return KeyPair.__wrap(r0);
+            return BHP768.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Returns the proving_key if the proving key was cached in the Execution response.
-     * Note the proving key is removed from the response object after the first call to this
-     * function. Subsequent calls will return null.
-     *
-     * @returns {ProvingKey | undefined} The proving key
-     * @returns {ProvingKey | undefined}
+     * Returns the BHP hash with an input hasher of 768 bits.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    getProvingKey() {
-        const ret = wasm.executionresponse_getProvingKey(this.__wbg_ptr);
-        return ret === 0 ? undefined : ProvingKey.__wrap(ret);
+    hash(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bhp768_hash(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Returns the verifying_key associated with the program
-     *
-     * @returns {VerifyingKey} The verifying key
-     * @returns {VerifyingKey}
+     * Returns a BHP hash with an input hasher of 768 bits.
+     * @param {Array<any>} input
+     * @returns {Group}
      */
-    getVerifyingKey() {
-        const ret = wasm.executionresponse_getVerifyingKey(this.__wbg_ptr);
-        return VerifyingKey.__wrap(ret);
+    hashToGroup(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bhp768_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Returns the function identifier
-     * @returns {string}
+     * Returns a BHP commitment with an input hasher of 768 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Field}
      */
-    getFunctionId() {
-        let deferred1_0;
-        let deferred1_1;
+    commit(input, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.executionresponse_getFunctionId(retptr, this.__wbg_ptr);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp768_commit(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Returns the program
-     * @returns {Program}
+     * Returns a BHP commitment with an input hasher of 768 bits and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Group}
      */
-    getProgram() {
-        const ret = wasm.executionresponse_getProgram(this.__wbg_ptr);
-        return Program.__wrap(ret);
+    commitToGroup(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.bhp768_commitToGroup(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 
-const FieldFinalization = (typeof FinalizationRegistry === 'undefined')
+const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_field_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr >>> 0, 1));
 /**
- * Field element.
+ * SnarkVM Ciphertext object. A Ciphertext represents an symmetrically encrypted plaintext. This
+ * object provides decryption methods to recover the plaintext from the ciphertext (given the
+ * api consumer has the proper decryption materials).
+ *
+ * @example
  */
-class Field {
+class Ciphertext {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Field.prototype);
+        const obj = Object.create(Ciphertext.prototype);
         obj.__wbg_ptr = ptr;
-        FieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        FieldFinalization.unregister(this);
+        CiphertextFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_field_free(ptr, 0);
+        wasm.__wbg_ciphertext_free(ptr, 0);
     }
     /**
-     * Creates a field object from a string representation of a field.
-     * @param {string} field
-     * @returns {Field}
+     * Decrypt the ciphertext using the given view key.
+     *
+     * @param {ViewKey} The view key of the account that encrypted the ciphertext.
+     * @param {Group} The nonce used to encrypt the ciphertext.
+     *
+     * @returns {Plaintext} The decrypted plaintext.
+     * @param {ViewKey} view_key
+     * @param {Group} nonce
+     * @returns {Plaintext}
      */
-    static fromString(field) {
+    decrypt(view_key, nonce) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(field, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.field_fromString(retptr, ptr0, len0);
+            _assertClass(view_key, ViewKey);
+            var ptr0 = view_key.__destroy_into_raw();
+            _assertClass(nonce, Group);
+            var ptr1 = nonce.__destroy_into_raw();
+            wasm.ciphertext_decrypt(retptr, this.__wbg_ptr, ptr0, ptr1);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Field.__wrap(r0);
+            return Plaintext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Create a plaintext element from a group element.
+     * Decrypt a ciphertext using the view key of the transition signer, transition public key, and
+     * (program, function, index) tuple.
+     * @param {ViewKey} view_key
+     * @param {Group} transition_public_key
+     * @param {string} program
+     * @param {string} function_name
+     * @param {number} index
      * @returns {Plaintext}
      */
-    toPlaintext() {
-        const ret = wasm.field_toPlaintext(this.__wbg_ptr);
-        return Plaintext.__wrap(ret);
-    }
-    /**
-     * Returns the string representation of the field.
-     * @returns {string}
-     */
-    toString() {
+    decrypt_with_transition_info(view_key, transition_public_key, program, function_name, index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(view_key, ViewKey);
+            var ptr0 = view_key.__destroy_into_raw();
+            _assertClass(transition_public_key, Group);
+            var ptr1 = transition_public_key.__destroy_into_raw();
+            const ptr2 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.ciphertext_decrypt_with_transition_info(retptr, this.__wbg_ptr, ptr0, ptr1, ptr2, len2, ptr3, len3, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Decrypt a ciphertext using the transition view key and a (program, function, index) tuple.
+     * @param {Field} transition_view_key
+     * @param {string} program
+     * @param {string} function_name
+     * @param {number} index
+     * @returns {Plaintext}
+     */
+    decrypt_with_transition_view_key(transition_view_key, program, function_name, index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(transition_view_key, Field);
+            var ptr0 = transition_view_key.__destroy_into_raw();
+            const ptr1 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(function_name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ciphertext_decrypt_with_transition_view_key(retptr, this.__wbg_ptr, ptr0, ptr1, len1, ptr2, len2, index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Decrypts a ciphertext into plaintext using the given ciphertext view key.
+     *
+     * @param {Field} transition_view_key The transition view key that was used to encrypt the ciphertext.
+     *
+     * @returns {Plaintext} The decrypted plaintext.
+     * @param {Field} transition_view_key
+     * @returns {Plaintext}
+     */
+    decryptSymmetric(transition_view_key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(transition_view_key, Field);
+            var ptr0 = transition_view_key.__destroy_into_raw();
+            wasm.ciphertext_decryptSymmetric(retptr, this.__wbg_ptr, ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Deserialize a left endian byte array into a Ciphertext.
+     *
+     * @param {Uint8Array} bytes The byte array representing the Ciphertext.
+     *
+     * @returns {Ciphertext} The Ciphertext object.
+     * @param {Uint8Array} bytes
+     * @returns {Ciphertext}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ciphertext_fromBytesLe(retptr, addHeapObject(bytes));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Ciphertext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Deserialize a Ciphertext string into a Ciphertext object.
+     *
+     * @param {string} ciphertext A string representation of the ciphertext.
+     *
+     * @returns {Ciphertext} The Ciphertext object.
+     * @param {string} ciphertext
+     * @returns {Ciphertext}
+     */
+    static fromString(ciphertext) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(ciphertext, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ciphertext_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Ciphertext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serialize a Ciphertext object into a byte array.
+     *
+     * @returns {Uint8Array} The serialized Ciphertext.
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ciphertext_toBytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Serialize a Ciphertext into a js string.
+     *
+     * @returns {string} The serialized Ciphertext.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ciphertext_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const ComputeKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_computekey_free(ptr >>> 0, 1));
+
+class ComputeKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ComputeKey.prototype);
+        obj.__wbg_ptr = ptr;
+        ComputeKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ComputeKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_computekey_free(ptr, 0);
+    }
+    /**
+     * Create a new compute key from a private key.
+     *
+     * @param {PrivateKey} private_key Private key
+     *
+     * @returns {ComputeKey} Compute key
+     * @param {PrivateKey} private_key
+     * @returns {ComputeKey}
+     */
+    static from_private_key(private_key) {
+        _assertClass(private_key, PrivateKey);
+        const ret = wasm.computekey_from_private_key(private_key.__wbg_ptr);
+        return ComputeKey.__wrap(ret);
+    }
+    /**
+     * Get the address from the compute key.
+     *
+     * @returns {Address}
+     * @returns {Address}
+     */
+    address() {
+        const ret = wasm.address_from_compute_key(this.__wbg_ptr);
+        return Address.__wrap(ret);
+    }
+    /**
+     * Get the sk_prf of the compute key.
+     *
+     * @returns {Scalar} sk_prf
+     * @returns {Scalar}
+     */
+    sk_prf() {
+        const ret = wasm.computekey_sk_prf(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+     * Get the pr_tag of the compute key.
+     *
+     * @returns {Group} pr_tag
+     * @returns {Group}
+     */
+    pk_sig() {
+        const ret = wasm.computekey_pk_sig(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Get the pr_sig of the compute key.
+     *
+     * @returns {Group} pr_sig
+     * @returns {Group}
+     */
+    pr_sig() {
+        const ret = wasm.computekey_pr_sig(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+}
+
+const ExecutionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_execution_free(ptr >>> 0, 1));
+/**
+ * Execution of an Aleo program.
+ */
+class Execution {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Execution.prototype);
+        obj.__wbg_ptr = ptr;
+        ExecutionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExecutionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_execution_free(ptr, 0);
+    }
+    /**
+     * Returns the string representation of the execution.
+     *
+     * @returns {string} The string representation of the execution.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.execution_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Creates an execution object from a string representation of an execution.
+     *
+     * @returns {Execution | Error} The wasm representation of an execution object.
+     * @param {string} execution
+     * @returns {Execution}
+     */
+    static fromString(execution) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(execution, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.execution_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Execution.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the global state root of the execution.
+     *
+     * @returns {Execution | Error} The global state root used in the execution.
+     * @returns {string}
+     */
+    globalStateRoot() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.execution_globalStateRoot(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns the proof of the execution.
+     *
+     * @returns {string} The execution proof.
+     * @returns {string}
+     */
+    proof() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.execution_proof(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns the transitions present in the execution.
+     *
+     * @returns Array<Transition> the array of transitions present in the execution.
+     * @returns {Array<any>}
+     */
+    transitions() {
+        const ret = wasm.execution_transitions(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+
+const ExecutionResponseFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_executionresponse_free(ptr >>> 0, 1));
+/**
+ * Webassembly Representation of an Aleo function execution response
+ *
+ * This object is returned by the execution of an Aleo function off-chain. It provides methods for
+ * retrieving the outputs of the function execution.
+ */
+class ExecutionResponse {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ExecutionResponse.prototype);
+        obj.__wbg_ptr = ptr;
+        ExecutionResponseFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ExecutionResponseFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_executionresponse_free(ptr, 0);
+    }
+    /**
+     * Get the outputs of the executed function
+     *
+     * @returns {Array} Array of strings representing the outputs of the function
+     * @returns {Array<any>}
+     */
+    getOutputs() {
+        const ret = wasm.executionresponse_getOutputs(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Returns the execution object if present, null if otherwise.
+     *
+     * @returns {Execution | undefined} The execution object if present, null if otherwise
+     * @returns {Execution | undefined}
+     */
+    getExecution() {
+        const ret = wasm.executionresponse_getExecution(this.__wbg_ptr);
+        return ret === 0 ? undefined : Execution.__wrap(ret);
+    }
+    /**
+     * Returns the program keys if present
+     * @returns {KeyPair}
+     */
+    getKeys() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.executionresponse_getKeys(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return KeyPair.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the proving_key if the proving key was cached in the Execution response.
+     * Note the proving key is removed from the response object after the first call to this
+     * function. Subsequent calls will return null.
+     *
+     * @returns {ProvingKey | undefined} The proving key
+     * @returns {ProvingKey | undefined}
+     */
+    getProvingKey() {
+        const ret = wasm.executionresponse_getProvingKey(this.__wbg_ptr);
+        return ret === 0 ? undefined : ProvingKey.__wrap(ret);
+    }
+    /**
+     * Returns the verifying_key associated with the program
+     *
+     * @returns {VerifyingKey} The verifying key
+     * @returns {VerifyingKey}
+     */
+    getVerifyingKey() {
+        const ret = wasm.executionresponse_getVerifyingKey(this.__wbg_ptr);
+        return VerifyingKey.__wrap(ret);
+    }
+    /**
+     * Returns the function identifier
+     * @returns {string}
+     */
+    getFunctionId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.executionresponse_getFunctionId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Returns the program
+     * @returns {Program}
+     */
+    getProgram() {
+        const ret = wasm.executionresponse_getProgram(this.__wbg_ptr);
+        return Program.__wrap(ret);
+    }
+}
+
+const FieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_field_free(ptr >>> 0, 1));
+/**
+ * Field element.
+ */
+class Field {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Field.prototype);
+        obj.__wbg_ptr = ptr;
+        FieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    static __unwrap(jsValue) {
+        if (!(jsValue instanceof Field)) {
+            return 0;
+        }
+        return jsValue.__destroy_into_raw();
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_field_free(ptr, 0);
+    }
+    /**
+     * Creates a field object from a string representation of a field element.
+     * @param {string} field
+     * @returns {Field}
+     */
+    static fromString(field) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(field, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.field_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the string representation of the field element.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.field_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Create a field element from a Uint8Array of left endian bytes.
+     * @param {Uint8Array} bytes
+     * @returns {Field}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.field_fromBytesLe(retptr, addBorrowedObject(bytes));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Encode the field element as a Uint8Array of left endian bytes.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.field_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Reconstruct a field element from a boolean array representation.
+     * @param {Array<any>} bits
+     * @returns {Field}
+     */
+    static fromBitsLe(bits) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.field_fromBitsLe(retptr, addBorrowedObject(bits));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Get the left endian boolean array representation of the field element.
+     * @returns {Array<any>}
+     */
+    toBitsLe() {
+        const ret = wasm.field_toBitsLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a plaintext from the field element.
+     * @returns {Plaintext}
+     */
+    toPlaintext() {
+        const ret = wasm.field_toPlaintext(this.__wbg_ptr);
+        return Plaintext.__wrap(ret);
+    }
+    /**
+     * Clone the field element.
+     * @returns {Field}
+     */
+    clone() {
+        const ret = wasm.field_clone(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Generate a random field element.
+     * @returns {Field}
+     */
+    static random() {
+        const ret = wasm.field_random();
+        return Field.__wrap(ret);
+    }
+    /**
+     * Add two field elements.
+     * @param {Field} other
+     * @returns {Field}
+     */
+    add(other) {
+        _assertClass(other, Field);
+        const ret = wasm.field_add(this.__wbg_ptr, other.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Subtract two field elements.
+     * @param {Field} other
+     * @returns {Field}
+     */
+    subtract(other) {
+        _assertClass(other, Field);
+        const ret = wasm.field_subtract(this.__wbg_ptr, other.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Multiply two field elements.
+     * @param {Field} other
+     * @returns {Field}
+     */
+    multiply(other) {
+        _assertClass(other, Field);
+        const ret = wasm.field_multiply(this.__wbg_ptr, other.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Divide two field elements.
+     * @param {Field} other
+     * @returns {Field}
+     */
+    divide(other) {
+        _assertClass(other, Field);
+        const ret = wasm.field_divide(this.__wbg_ptr, other.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Power of a field element.
+     * @param {Field} other
+     * @returns {Field}
+     */
+    pow(other) {
+        _assertClass(other, Field);
+        const ret = wasm.field_pow(this.__wbg_ptr, other.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Invert the field element.
+     * @returns {Field}
+     */
+    inverse() {
+        const ret = wasm.field_inverse(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Get the additive identity element of the field.
+     * @returns {Field}
+     */
+    static zero() {
+        const ret = wasm.field_zero();
+        return Field.__wrap(ret);
+    }
+    /**
+     * Get the multiplicative identity of the field.
+     * @returns {Field}
+     */
+    static one() {
+        const ret = wasm.field_one();
+        return Field.__wrap(ret);
+    }
+    /**
+     * Double the field element.
+     * @returns {Field}
+     */
+    double() {
+        const ret = wasm.field_double(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Check if one field element equals another.
+     * @param {Field} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, Field);
+        const ret = wasm.field_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+
+const GraphKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_graphkey_free(ptr >>> 0, 1));
+
+class GraphKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GraphKey.prototype);
+        obj.__wbg_ptr = ptr;
+        GraphKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GraphKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_graphkey_free(ptr, 0);
+    }
+    /**
+     * Create a new graph key from a view key.
+     *
+     * @param {ViewKey} view_key View key
+     * @returns {GraphKey} Graph key
+     * @param {ViewKey} view_key
+     * @returns {GraphKey}
+     */
+    static from_view_key(view_key) {
+        _assertClass(view_key, ViewKey);
+        const ret = wasm.graphkey_from_view_key(view_key.__wbg_ptr);
+        return GraphKey.__wrap(ret);
+    }
+    /**
+     * Create a new graph key from a string representation of a graph key
+     *
+     * @param {string} graph_key String representation of a graph key
+     * @returns {GraphKey} Graph key
+     * @param {string} graph_key
+     * @returns {GraphKey}
+     */
+    static from_string(graph_key) {
+        const ptr0 = passStringToWasm0(graph_key, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.graphkey_from_string(ptr0, len0);
+        return GraphKey.__wrap(ret);
+    }
+    /**
+     * Get a string representation of a graph key
+     *
+     * @returns {string} String representation of a graph key
+     * @returns {string}
+     */
+    to_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.graphkey_to_string(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the sk_tag of the graph key. Used to determine ownership of records.
+     * @returns {Field}
+     */
+    sk_tag() {
+        const ret = wasm.field_clone(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+}
+
+const GroupFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_group_free(ptr >>> 0, 1));
+/**
+ * Elliptic curve element.
+ */
+class Group {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Group.prototype);
+        obj.__wbg_ptr = ptr;
+        GroupFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GroupFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_group_free(ptr, 0);
+    }
+    /**
+     * Creates a group object from a string representation of a group element.
+     * @param {string} group
+     * @returns {Group}
+     */
+    static fromString(group) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(group, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.group_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the string representation of the group element.
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.group_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Create a group element from a Uint8Array of left endian bytes.
+     * @param {Uint8Array} bytes
+     * @returns {Group}
+     */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.group_fromBytesLe(retptr, addBorrowedObject(bytes));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Encode the group element as a Uint8Array of left endian bytes.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.group_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Reconstruct a group element from a boolean array representation.
+     * @param {Array<any>} bits
+     * @returns {Group}
+     */
+    static fromBitsLe(bits) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.group_fromBitsLe(retptr, addBorrowedObject(bits));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
+    /**
+     * Get the left endian boolean array representation of the group element.
+     * @returns {Array<any>}
+     */
+    toBitsLe() {
+        const ret = wasm.group_toBitsLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the x-coordinate of the group element.
+     * @returns {Field}
+     */
+    toXCoordinate() {
+        const ret = wasm.group_toXCoordinate(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+     * Create a plaintext element from a group element.
+     * @returns {Plaintext}
+     */
+    toPlaintext() {
+        const ret = wasm.group_toPlaintext(this.__wbg_ptr);
+        return Plaintext.__wrap(ret);
+    }
+    /**
+     * Clone the group element.
+     * @returns {Group}
+     */
+    clone() {
+        const ret = wasm.group_clone(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Generate a random group element.
+     * @returns {Group}
+     */
+    static random() {
+        const ret = wasm.group_random();
+        return Group.__wrap(ret);
+    }
+    /**
+     * Add two group elements.
+     * @param {Group} other
+     * @returns {Group}
+     */
+    add(other) {
+        _assertClass(other, Group);
+        const ret = wasm.group_add(this.__wbg_ptr, other.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Subtract two group elements (equivalently: add the inverse of an element).
+     * @param {Group} other
+     * @returns {Group}
+     */
+    subtract(other) {
+        _assertClass(other, Group);
+        const ret = wasm.group_subtract(this.__wbg_ptr, other.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Multiply a group element by a scalar element.
+     * @param {Scalar} scalar
+     * @returns {Group}
+     */
+    scalarMultiply(scalar) {
+        _assertClass(scalar, Scalar);
+        const ret = wasm.group_scalarMultiply(this.__wbg_ptr, scalar.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Double the group element.
+     * @returns {Group}
+     */
+    double() {
+        const ret = wasm.group_double(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Get the inverse of the group element. This is the reflection of the point about the axis
+     * of symmetry i.e. (x,y) -> (x, -y).
+     * @returns {Group}
+     */
+    inverse() {
+        const ret = wasm.group_inverse(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+     * Check if one group element equals another.
+     * @param {Group} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, Group);
+        const ret = wasm.group_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Get the group identity element under the group operation (i.e. the point at infinity.)
+     * @returns {Group}
+     */
+    static zero() {
+        const ret = wasm.group_zero();
+        return Group.__wrap(ret);
+    }
+    /**
+     * Get the generator of the group.
+     * @returns {Group}
+     */
+    static generator() {
+        const ret = wasm.group_generator();
+        return Group.__wrap(ret);
+    }
+}
+
+const KeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr >>> 0, 1));
+/**
+ * Key pair object containing both the function proving and verifying keys
+ */
+class KeyPair {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(KeyPair.prototype);
+        obj.__wbg_ptr = ptr;
+        KeyPairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KeyPairFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_keypair_free(ptr, 0);
+    }
+    /**
+     * Create new key pair from proving and verifying keys
+     *
+     * @param {ProvingKey} proving_key Proving key corresponding to a function in an Aleo program
+     * @param {VerifyingKey} verifying_key Verifying key corresponding to a function in an Aleo program
+     * @returns {KeyPair} Key pair object containing both the function proving and verifying keys
+     * @param {ProvingKey} proving_key
+     * @param {VerifyingKey} verifying_key
+     */
+    constructor(proving_key, verifying_key) {
+        _assertClass(proving_key, ProvingKey);
+        var ptr0 = proving_key.__destroy_into_raw();
+        _assertClass(verifying_key, VerifyingKey);
+        var ptr1 = verifying_key.__destroy_into_raw();
+        const ret = wasm.keypair_new(ptr0, ptr1);
+        this.__wbg_ptr = ret >>> 0;
+        KeyPairFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get the proving key. This method will remove the proving key from the key pair
+     *
+     * @returns {ProvingKey}
+     * @returns {ProvingKey}
+     */
+    provingKey() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.keypair_provingKey(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return ProvingKey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the verifying key. This method will remove the verifying key from the key pair
+     *
+     * @returns {VerifyingKey}
+     * @returns {VerifyingKey}
+     */
+    verifyingKey() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.keypair_verifyingKey(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return VerifyingKey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
+const MetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_metadata_free(ptr >>> 0, 1));
+
+class Metadata {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Metadata.prototype);
+        obj.__wbg_ptr = ptr;
+        MetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MetadataFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_metadata_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get name() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_metadata_name(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set name(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_metadata_name(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get locator() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_metadata_locator(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} arg0
+     */
+    set locator(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_metadata_locator(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get prover() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.field_toString(retptr, this.__wbg_ptr);
+            wasm.__wbg_get_metadata_prover(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -974,242 +2323,279 @@ class Field {
         }
     }
     /**
-     * Generate a random field element.
-     * @returns {Field}
+     * @param {string} arg0
      */
-    static random() {
-        const ret = wasm.field_random();
-        return Field.__wrap(ret);
+    set prover(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_metadata_prover(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Add two field elements.
-     * @param {Field} other
-     * @returns {Field}
+     * @returns {string}
      */
-    add(other) {
-        _assertClass(other, Field);
-        const ret = wasm.field_add(this.__wbg_ptr, other.__wbg_ptr);
-        return Field.__wrap(ret);
+    get verifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_metadata_verifier(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * Subtract two field elements.
-     * @param {Field} other
-     * @returns {Field}
+     * @param {string} arg0
      */
-    subtract(other) {
-        _assertClass(other, Field);
-        const ret = wasm.field_subtract(this.__wbg_ptr, other.__wbg_ptr);
-        return Field.__wrap(ret);
+    set verifier(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_metadata_verifier(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Multiply two field elements.
-     * @param {Field} other
-     * @returns {Field}
+     * @returns {string}
      */
-    multiply(other) {
-        _assertClass(other, Field);
-        const ret = wasm.field_multiply(this.__wbg_ptr, other.__wbg_ptr);
-        return Field.__wrap(ret);
+    get verifyingKey() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_metadata_verifyingKey(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * Divide two field elements.
-     * @param {Field} other
-     * @returns {Field}
+     * @param {string} arg0
      */
-    divide(other) {
-        _assertClass(other, Field);
-        const ret = wasm.field_divide(this.__wbg_ptr, other.__wbg_ptr);
-        return Field.__wrap(ret);
+    set verifyingKey(arg0) {
+        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_metadata_verifyingKey(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * Power of a field element.
-     * @param {Field} other
-     * @returns {Field}
+     * @returns {string}
      */
-    pow(other) {
-        _assertClass(other, Field);
-        const ret = wasm.field_pow(this.__wbg_ptr, other.__wbg_ptr);
-        return Field.__wrap(ret);
+    static baseUrl() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.metadata_baseUrl(retptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-     * Invert the field element.
-     * @returns {Field}
+     * @returns {Metadata}
      */
-    inverse() {
-        const ret = wasm.field_inverse(this.__wbg_ptr);
-        return Field.__wrap(ret);
+    static bond_public() {
+        const ret = wasm.metadata_bond_public();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Get the zero element of the field.
-     * @returns {Field}
+     * @returns {Metadata}
      */
-    static zero() {
-        const ret = wasm.field_zero();
-        return Field.__wrap(ret);
+    static bond_validator() {
+        const ret = wasm.metadata_bond_validator();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Get the one element of the field.
-     * @returns {Field}
+     * @returns {Metadata}
      */
-    static one() {
-        const ret = wasm.field_one();
-        return Field.__wrap(ret);
+    static claim_unbond_public() {
+        const ret = wasm.metadata_claim_unbond_public();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Double the field element.
-     * @returns {Field}
+     * @returns {Metadata}
      */
-    double() {
-        const ret = wasm.field_double(this.__wbg_ptr);
-        return Field.__wrap(ret);
+    static fee_private() {
+        const ret = wasm.metadata_fee_private();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Check if one field element equals another.
-     * @param {Field} other
-     * @returns {boolean}
+     * @returns {Metadata}
      */
-    equals(other) {
-        _assertClass(other, Field);
-        const ret = wasm.field_equals(this.__wbg_ptr, other.__wbg_ptr);
-        return ret !== 0;
+    static fee_public() {
+        const ret = wasm.metadata_fee_public();
+        return Metadata.__wrap(ret);
     }
-}
-
-const GraphKeyFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_graphkey_free(ptr >>> 0, 1));
-
-class GraphKey {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GraphKey.prototype);
-        obj.__wbg_ptr = ptr;
-        GraphKeyFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+    /**
+     * @returns {Metadata}
+     */
+    static inclusion() {
+        const ret = wasm.metadata_inclusion();
+        return Metadata.__wrap(ret);
     }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GraphKeyFinalization.unregister(this);
-        return ptr;
+    /**
+     * @returns {Metadata}
+     */
+    static join() {
+        const ret = wasm.metadata_join();
+        return Metadata.__wrap(ret);
     }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_graphkey_free(ptr, 0);
+    /**
+     * @returns {Metadata}
+     */
+    static set_validator_state() {
+        const ret = wasm.metadata_set_validator_state();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Create a new graph key from a view key.
-     *
-     * @param {ViewKey} view_key View key
-     * @returns {GraphKey} Graph key
-     * @param {ViewKey} view_key
-     * @returns {GraphKey}
+     * @returns {Metadata}
      */
-    static from_view_key(view_key) {
-        _assertClass(view_key, ViewKey);
-        const ret = wasm.graphkey_from_view_key(view_key.__wbg_ptr);
-        return GraphKey.__wrap(ret);
+    static split() {
+        const ret = wasm.metadata_split();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Create a new graph key from a string representation of a graph key
-     *
-     * @param {string} graph_key String representation of a graph key
-     * @returns {GraphKey} Graph key
-     * @param {string} graph_key
-     * @returns {GraphKey}
+     * @returns {Metadata}
      */
-    static from_string(graph_key) {
-        const ptr0 = passStringToWasm0(graph_key, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.graphkey_from_string(ptr0, len0);
-        return GraphKey.__wrap(ret);
+    static transfer_private() {
+        const ret = wasm.metadata_transfer_private();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Get a string representation of a graph key
-     *
-     * @returns {string} String representation of a graph key
-     * @returns {string}
+     * @returns {Metadata}
      */
-    to_string() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.graphkey_to_string(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
-        }
+    static transfer_private_to_public() {
+        const ret = wasm.metadata_transfer_private_to_public();
+        return Metadata.__wrap(ret);
+    }
+    /**
+     * @returns {Metadata}
+     */
+    static transfer_public() {
+        const ret = wasm.metadata_transfer_public();
+        return Metadata.__wrap(ret);
     }
     /**
-     * Get the sk_tag of the graph key. Used to determine ownership of records.
-     * @returns {Field}
+     * @returns {Metadata}
      */
-    sk_tag() {
-        const ret = wasm.graphkey_sk_tag(this.__wbg_ptr);
-        return Field.__wrap(ret);
+    static transfer_public_as_signer() {
+        const ret = wasm.metadata_transfer_public_as_signer();
+        return Metadata.__wrap(ret);
+    }
+    /**
+     * @returns {Metadata}
+     */
+    static transfer_public_to_private() {
+        const ret = wasm.metadata_transfer_public_to_private();
+        return Metadata.__wrap(ret);
+    }
+    /**
+     * @returns {Metadata}
+     */
+    static unbond_public() {
+        const ret = wasm.metadata_unbond_public();
+        return Metadata.__wrap(ret);
     }
 }
 
-const GroupFinalization = (typeof FinalizationRegistry === 'undefined')
+const OfflineQueryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_group_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_offlinequery_free(ptr >>> 0, 1));
 /**
- * Elliptic curve element.
+ * An offline query object used to insert the global state root and state paths needed to create
+ * a valid inclusion proof offline.
  */
-class Group {
+class OfflineQuery {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Group.prototype);
+        const obj = Object.create(OfflineQuery.prototype);
         obj.__wbg_ptr = ptr;
-        GroupFinalization.register(obj, obj.__wbg_ptr, obj);
+        OfflineQueryFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        GroupFinalization.unregister(this);
+        OfflineQueryFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_group_free(ptr, 0);
+        wasm.__wbg_offlinequery_free(ptr, 0);
     }
     /**
-     * Creates a group object from a string representation of a group.
-     * @param {string} group
-     * @returns {Group}
+     * Creates a new offline query object. The state root is required to be passed in as a string
+     * @param {number} block_height
+     * @param {string} state_root
      */
-    static fromString(group) {
+    constructor(block_height, state_root) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(group, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const ptr0 = passStringToWasm0(state_root, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len0 = WASM_VECTOR_LEN;
-            wasm.group_fromString(retptr, ptr0, len0);
+            wasm.offlinequery_new(retptr, block_height, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Group.__wrap(r0);
+            this.__wbg_ptr = r0 >>> 0;
+            OfflineQueryFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Add a new block height to the offline query object.
+     * @param {number} block_height
+     */
+    addBlockHeight(block_height) {
+        wasm.offlinequery_addBlockHeight(this.__wbg_ptr, block_height);
+    }
+    /**
+     * Add a new state path to the offline query object.
+     *
+     * @param {string} commitment: The commitment corresponding to a record inpout
+     * @param {string} state_path: The state path corresponding to the commitment
+     * @param {string} commitment
+     * @param {string} state_path
+     */
+    addStatePath(commitment, state_path) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(commitment, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(state_path, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.offlinequery_addStatePath(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Returns the string representation of the group.
+     * Get a json string representation of the offline query object
      * @returns {string}
      */
     toString() {
@@ -1217,7 +2603,7 @@ class Group {
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.group_toString(retptr, this.__wbg_ptr);
+            wasm.offlinequery_toString(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1229,336 +2615,453 @@ class Group {
         }
     }
     /**
-     * Get the x-coordinate of the group element.
-     * @returns {Field}
-     */
-    toXCoordinate() {
-        const ret = wasm.group_toXCoordinate(this.__wbg_ptr);
-        return Field.__wrap(ret);
-    }
-    /**
-     * Create a plaintext element from a group element.
-     * @returns {Plaintext}
-     */
-    toPlaintext() {
-        const ret = wasm.group_toPlaintext(this.__wbg_ptr);
-        return Plaintext.__wrap(ret);
-    }
-    /**
-     * Generate a random group element.
-     * @returns {Group}
+     * Create an offline query object from a json string representation
+     * @param {string} s
+     * @returns {OfflineQuery}
      */
-    static random() {
-        const ret = wasm.group_random();
-        return Group.__wrap(ret);
+    static fromString(s) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.offlinequery_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return OfflineQuery.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
-    /**
-     * Add two group elements.
-     * @param {Group} other
-     * @returns {Group}
-     */
-    add(other) {
-        _assertClass(other, Group);
-        const ret = wasm.group_add(this.__wbg_ptr, other.__wbg_ptr);
-        return Group.__wrap(ret);
+}
+
+const Pedersen128Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pedersen128_free(ptr >>> 0, 1));
+
+class Pedersen128 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Pedersen128.prototype);
+        obj.__wbg_ptr = ptr;
+        Pedersen128Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
     }
-    /**
-     * Subtract two group elements (equivalently: add the inverse of an element).
-     * @param {Group} other
-     * @returns {Group}
-     */
-    subtract(other) {
-        _assertClass(other, Group);
-        const ret = wasm.group_subtract(this.__wbg_ptr, other.__wbg_ptr);
-        return Group.__wrap(ret);
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Pedersen128Finalization.unregister(this);
+        return ptr;
     }
-    /**
-     * Multiply a group element by a scalar element.
-     * @param {Scalar} scalar
-     * @returns {Group}
-     */
-    scalarMultiply(scalar) {
-        _assertClass(scalar, Scalar);
-        const ret = wasm.group_scalarMultiply(this.__wbg_ptr, scalar.__wbg_ptr);
-        return Group.__wrap(ret);
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pedersen128_free(ptr, 0);
     }
     /**
-     * Double the group element.
-     * @returns {Group}
+     * Create a Pedersen hasher for a given (up to) 128-bit input.
      */
-    double() {
-        const ret = wasm.group_double(this.__wbg_ptr);
-        return Group.__wrap(ret);
+    constructor() {
+        const ret = wasm.pedersen128_new();
+        this.__wbg_ptr = ret >>> 0;
+        Pedersen128Finalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * Get the inverse of the group element. This is the reflection of the point about the axis
-     * of symmetry i.e. (x,y) -> (x, -y).
-     * @returns {Group}
+     * Create a Pedersen hasher for a given (up to) 128-bit input with a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {Pedersen128}
      */
-    inverse() {
-        const ret = wasm.group_inverse(this.__wbg_ptr);
-        return Group.__wrap(ret);
+    static setup(domain_separator) {
+        const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pedersen128_setup(ptr0, len0);
+        return Pedersen128.__wrap(ret);
     }
     /**
-     * Check if one group element equals another.
-     * @param {Group} other
-     * @returns {boolean}
+     * Returns the Pedersen hash for a given (up to) 128-bit input.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    equals(other) {
-        _assertClass(other, Group);
-        const ret = wasm.group_equals(this.__wbg_ptr, other.__wbg_ptr);
-        return ret !== 0;
+    hash(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pedersen128_hash(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Get the group identity element under the group operation (i.e. the point at infinity.)
-     * @returns {Group}
+     * Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Field}
      */
-    static zero() {
-        const ret = wasm.group_zero();
-        return Group.__wrap(ret);
+    commit(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.pedersen128_commit(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Get the generator of the group.
+     * Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
      * @returns {Group}
      */
-    static generator() {
-        const ret = wasm.group_generator();
-        return Group.__wrap(ret);
+    commitToGroup(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.pedersen128_commitToGroup(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
-}
-
-const KeyPairFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr >>> 0, 1));
-/**
- * Key pair object containing both the function proving and verifying keys
- */
-class KeyPair {
+}
+
+const Pedersen64Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pedersen64_free(ptr >>> 0, 1));
+
+class Pedersen64 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(KeyPair.prototype);
+        const obj = Object.create(Pedersen64.prototype);
         obj.__wbg_ptr = ptr;
-        KeyPairFinalization.register(obj, obj.__wbg_ptr, obj);
+        Pedersen64Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        KeyPairFinalization.unregister(this);
+        Pedersen64Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_keypair_free(ptr, 0);
+        wasm.__wbg_pedersen64_free(ptr, 0);
     }
     /**
-     * Create new key pair from proving and verifying keys
-     *
-     * @param {ProvingKey} proving_key Proving key corresponding to a function in an Aleo program
-     * @param {VerifyingKey} verifying_key Verifying key corresponding to a function in an Aleo program
-     * @returns {KeyPair} Key pair object containing both the function proving and verifying keys
-     * @param {ProvingKey} proving_key
-     * @param {VerifyingKey} verifying_key
+     * Create a Pedersen hasher for a given (up to) 64-bit input.
      */
-    constructor(proving_key, verifying_key) {
-        _assertClass(proving_key, ProvingKey);
-        var ptr0 = proving_key.__destroy_into_raw();
-        _assertClass(verifying_key, VerifyingKey);
-        var ptr1 = verifying_key.__destroy_into_raw();
-        const ret = wasm.keypair_new(ptr0, ptr1);
+    constructor() {
+        const ret = wasm.pedersen64_new();
         this.__wbg_ptr = ret >>> 0;
-        KeyPairFinalization.register(this, this.__wbg_ptr, this);
+        Pedersen64Finalization.register(this, this.__wbg_ptr, this);
         return this;
     }
     /**
-     * Get the proving key. This method will remove the proving key from the key pair
-     *
-     * @returns {ProvingKey}
-     * @returns {ProvingKey}
+     * Create a Pedersen64 hasher for a given (up to) 64-bit input with a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {Pedersen64}
      */
-    provingKey() {
+    static setup(domain_separator) {
+        const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.pedersen64_setup(ptr0, len0);
+        return Pedersen64.__wrap(ret);
+    }
+    /**
+     * Returns the Pedersen hash for a given (up to) 64-bit input.
+     * @param {Array<any>} input
+     * @returns {Field}
+     */
+    hash(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.keypair_provingKey(retptr, this.__wbg_ptr);
+            wasm.pedersen64_hash(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return ProvingKey.__wrap(r0);
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Get the verifying key. This method will remove the verifying key from the key pair
-     *
-     * @returns {VerifyingKey}
-     * @returns {VerifyingKey}
+     * Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Field}
      */
-    verifyingKey() {
+    commit(input, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.keypair_verifyingKey(retptr, this.__wbg_ptr);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.pedersen64_commit(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return VerifyingKey.__wrap(r0);
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer.
+     * @param {Array<any>} input
+     * @param {Scalar} randomizer
+     * @returns {Group}
+     */
+    commitToGroup(input, randomizer) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(randomizer, Scalar);
+            var ptr0 = randomizer.__destroy_into_raw();
+            wasm.pedersen64_commitToGroup(retptr, this.__wbg_ptr, addHeapObject(input), ptr0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
 }
 
-const MetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+const PlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_metadata_free(ptr >>> 0, 1));
-
-class Metadata {
+    : new FinalizationRegistry(ptr => wasm.__wbg_plaintext_free(ptr >>> 0, 1));
+/**
+ * SnarkVM Plaintext object. Plaintext is a fundamental monadic type used to represent Aleo
+ * primitive types (boolean, field, group, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128,
+ * scalar, and signature), struct types, and array types.
+ *
+ * In the context of a web or NodeJS application, this type is useful for turning an Aleo type into
+ * a JS value, object, or array that might be necessary for performing computations within the
+ * application.
+ *
+ * @example
+ * // Get the bond state of an existing address.
+ * const bondState = await fetch(https://api.explorer.provable.com/v1/mainnet/program/credits.aleo/mapping/bond_state/aleo12zlythl7htjdtjjjz3ahdj4vl6wk3zuzm37s80l86qpx8fyx95fqnxcn2f);
+ * // Convert the bond state to a Plaintext object.
+ * const bondStatePlaintext = Plaintext.fromString(bond_state);
+ * // Convert the Plaintext object to a JS object.
+ * const bondStateObject = bond_state_plaintext.toObject();
+ * // Check if the bond state matches the expected object.
+ * const expectedObject = { validator: "aleo12zlythl7htjdtjjjz3ahdj4vl6wk3zuzm37s80l86qpx8fyx95fqnxcn2f", microcredits: 100000000u64 };
+ * assert( JSON.stringify(bondStateObject) === JSON.stringify(expectedObject) );
+ */
+class Plaintext {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Metadata.prototype);
+        const obj = Object.create(Plaintext.prototype);
         obj.__wbg_ptr = ptr;
-        MetadataFinalization.register(obj, obj.__wbg_ptr, obj);
+        PlaintextFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        MetadataFinalization.unregister(this);
+        PlaintextFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_metadata_free(ptr, 0);
+        wasm.__wbg_plaintext_free(ptr, 0);
     }
     /**
-     * @returns {string}
+     * Find plaintext member if the plaintext is a struct. Returns `null` if the plaintext is not
+     * a struct or the member does not exist.
+     *
+     * @param {string} name The name of the plaintext member to find.
+     *
+     * @returns {Plaintext} The plaintext member.
+     * @param {string} name
+     * @returns {Plaintext}
      */
-    get name() {
-        let deferred1_0;
-        let deferred1_1;
+    find(name) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_name(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.plaintext_find(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * @param {string} arg0
-     */
-    set name(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_metadata_name(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @returns {string}
+     * Encrypt a plaintext with an address and randomizer.
+     * @param {Address} address
+     * @param {Scalar} randomizer
+     * @returns {Ciphertext}
      */
-    get locator() {
-        let deferred1_0;
-        let deferred1_1;
+    encrypt(address, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_locator(retptr, this.__wbg_ptr);
+            _assertClass(address, Address);
+            _assertClass(randomizer, Scalar);
+            wasm.plaintext_encrypt(retptr, this.__wbg_ptr, address.__wbg_ptr, randomizer.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Ciphertext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * @param {string} arg0
-     */
-    set locator(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_metadata_locator(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
-     * @returns {string}
+     * Encrypt a plaintext with a transition view key.
+     * @param {Field} transition_view_key
+     * @returns {Ciphertext}
      */
-    get prover() {
-        let deferred1_0;
-        let deferred1_1;
+    encryptSymmetric(transition_view_key) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_prover(retptr, this.__wbg_ptr);
+            _assertClass(transition_view_key, Field);
+            wasm.plaintext_encryptSymmetric(retptr, this.__wbg_ptr, transition_view_key.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Ciphertext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * @param {string} arg0
+     * Creates a plaintext object from a string representation of a plaintext.
+     *
+     * @param {string} plaintext The string representation of the plaintext.
+     *
+     * @returns {Plaintext} The plaintext object.
+     * @param {string} plaintext
+     * @returns {Plaintext}
      */
-    set prover(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_metadata_prover(this.__wbg_ptr, ptr0, len0);
+    static fromString(plaintext) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.plaintext_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * @returns {string}
+     * Get a plaintext object from a series of bytes.
+     *
+     * @param {Uint8Array} bytes A left endian byte array representing the plaintext.
+     *
+     * @returns {Plaintext} The plaintext object.
+     * @param {Uint8Array} bytes
+     * @returns {Plaintext}
      */
-    get verifier() {
-        let deferred1_0;
-        let deferred1_1;
+    static fromBytesLe(bytes) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_verifier(retptr, this.__wbg_ptr);
+            wasm.plaintext_fromBytesLe(retptr, addHeapObject(bytes));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * @param {string} arg0
+     * Generate a random plaintext element from a series of bytes.
+     *
+     * @param {Uint8Array} bytes A left endian byte array representing the plaintext.
+     * @returns {Uint8Array}
      */
-    set verifier(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_metadata_verifier(this.__wbg_ptr, ptr0, len0);
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
+     * Returns the string representation of the plaintext.
+     *
+     * @returns {string} The string representation of the plaintext.
      * @returns {string}
      */
-    get verifyingKey() {
+    toString() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.__wbg_get_metadata_verifyingKey(retptr, this.__wbg_ptr);
+            wasm.plaintext_toString(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1570,22 +3073,17 @@ class Metadata {
         }
     }
     /**
-     * @param {string} arg0
-     */
-    set verifyingKey(arg0) {
-        const ptr0 = passStringToWasm0(arg0, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.__wbg_set_metadata_verifyingKey(this.__wbg_ptr, ptr0, len0);
-    }
-    /**
+     * Gives the type of the plaintext.
+     *
+     * @returns {string} The type of the plaintext.
      * @returns {string}
      */
-    static baseUrl() {
+    plaintextType() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.metadata_baseUrl(retptr);
+            wasm.plaintext_plaintextType(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1597,487 +3095,439 @@ class Metadata {
         }
     }
     /**
-     * @returns {Metadata}
-     */
-    static bond_public() {
-        const ret = wasm.metadata_bond_public();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static bond_validator() {
-        const ret = wasm.metadata_bond_validator();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static claim_unbond_public() {
-        const ret = wasm.metadata_claim_unbond_public();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static fee_private() {
-        const ret = wasm.metadata_fee_private();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static fee_public() {
-        const ret = wasm.metadata_fee_public();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static inclusion() {
-        const ret = wasm.metadata_inclusion();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static join() {
-        const ret = wasm.metadata_join();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static set_validator_state() {
-        const ret = wasm.metadata_set_validator_state();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static split() {
-        const ret = wasm.metadata_split();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static transfer_private() {
-        const ret = wasm.metadata_transfer_private();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static transfer_private_to_public() {
-        const ret = wasm.metadata_transfer_private_to_public();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static transfer_public() {
-        const ret = wasm.metadata_transfer_public();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static transfer_public_as_signer() {
-        const ret = wasm.metadata_transfer_public_as_signer();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
-     */
-    static transfer_public_to_private() {
-        const ret = wasm.metadata_transfer_public_to_private();
-        return Metadata.__wrap(ret);
-    }
-    /**
-     * @returns {Metadata}
+     * Attempt to convert the plaintext to a JS object.
+     *
+     * @returns {Object} The JS object representation of the plaintext.
+     * @returns {any}
      */
-    static unbond_public() {
-        const ret = wasm.metadata_unbond_public();
-        return Metadata.__wrap(ret);
+    toObject() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toObject(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
 
-const OfflineQueryFinalization = (typeof FinalizationRegistry === 'undefined')
+const Poseidon2Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_offlinequery_free(ptr >>> 0, 1));
-/**
- * An offline query object used to insert the global state root and state paths needed to create
- * a valid inclusion proof offline.
- */
-class OfflineQuery {
+    : new FinalizationRegistry(ptr => wasm.__wbg_poseidon2_free(ptr >>> 0, 1));
+
+class Poseidon2 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(OfflineQuery.prototype);
+        const obj = Object.create(Poseidon2.prototype);
         obj.__wbg_ptr = ptr;
-        OfflineQueryFinalization.register(obj, obj.__wbg_ptr, obj);
+        Poseidon2Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        OfflineQueryFinalization.unregister(this);
+        Poseidon2Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_offlinequery_free(ptr, 0);
+        wasm.__wbg_poseidon2_free(ptr, 0);
     }
     /**
-     * Creates a new offline query object. The state root is required to be passed in as a string
-     * @param {number} block_height
-     * @param {string} state_root
+     * Create a Poseidon hasher with an input rate of 2.
      */
-    constructor(block_height, state_root) {
+    constructor() {
+        const ret = wasm.poseidon2_new();
+        this.__wbg_ptr = ret >>> 0;
+        Poseidon2Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a Poseidon hasher with an input rate of 2 and a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {Poseidon2}
+     */
+    static setup(domain_separator) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(state_root, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len0 = WASM_VECTOR_LEN;
-            wasm.offlinequery_new(retptr, block_height, ptr0, len0);
+            wasm.poseidon2_setup(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            this.__wbg_ptr = r0 >>> 0;
-            OfflineQueryFinalization.register(this, this.__wbg_ptr, this);
-            return this;
+            return Poseidon2.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Add a new block height to the offline query object.
-     * @param {number} block_height
+     * Returns the Poseidon hash with an input rate of 2.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    addBlockHeight(block_height) {
-        wasm.offlinequery_addBlockHeight(this.__wbg_ptr, block_height);
+    hash(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.poseidon2_hash(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Add a new state path to the offline query object.
-     *
-     * @param {string} commitment: The commitment corresponding to a record inpout
-     * @param {string} state_path: The state path corresponding to the commitment
-     * @param {string} commitment
-     * @param {string} state_path
+     * Returns the extended Poseidon hash with an input rate of 2.
+     * @param {Array<any>} input
+     * @param {number} num_outputs
+     * @returns {Array<any>}
      */
-    addStatePath(commitment, state_path) {
+    hashMany(input, num_outputs) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(commitment, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(state_path, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len1 = WASM_VECTOR_LEN;
-            wasm.offlinequery_addStatePath(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            wasm.poseidon2_hashMany(retptr, this.__wbg_ptr, addHeapObject(input), num_outputs);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            if (r1) {
-                throw takeObject(r0);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
             }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Get a json string representation of the offline query object
-     * @returns {string}
+     * Returns the Poseidon hash with an input rate of 2 on the scalar field.
+     * @param {Array<any>} input
+     * @returns {Scalar}
      */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
+    hashToScalar(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.offlinequery_toString(retptr, this.__wbg_ptr);
+            wasm.poseidon2_hashToScalar(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Scalar.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Create an offline query object from a json string representation
-     * @param {string} s
-     * @returns {OfflineQuery}
+     * Returns the Poseidon hash with an input rate of 2 on the affine curve.
+     * @param {Array<any>} input
+     * @returns {Group}
      */
-    static fromString(s) {
+    hashToGroup(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.offlinequery_fromString(retptr, ptr0, len0);
+            wasm.poseidon2_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return OfflineQuery.__wrap(r0);
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
 }
 
-const PlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
+const Poseidon4Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_plaintext_free(ptr >>> 0, 1));
-/**
- * SnarkVM Plaintext object. Plaintext is a fundamental monadic type used to represent Aleo
- * primitive types (boolean, field, group, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128,
- * scalar, and signature), struct types, and array types.
- *
- * In the context of a web or NodeJS application, this type is useful for turning an Aleo type into
- * a JS value, object, or array that might be necessary for performing computations within the
- * application.
- *
- * @example
- * // Get the bond state of an existing address.
- * const bondState = await fetch(https://api.explorer.provable.com/v1/mainnet/program/credits.aleo/mapping/bond_state/aleo12zlythl7htjdtjjjz3ahdj4vl6wk3zuzm37s80l86qpx8fyx95fqnxcn2f);
- * // Convert the bond state to a Plaintext object.
- * const bondStatePlaintext = Plaintext.fromString(bond_state);
- * // Convert the Plaintext object to a JS object.
- * const bondStateObject = bond_state_plaintext.toObject();
- * // Check if the bond state matches the expected object.
- * const expectedObject = { validator: "aleo12zlythl7htjdtjjjz3ahdj4vl6wk3zuzm37s80l86qpx8fyx95fqnxcn2f", microcredits: 100000000u64 };
- * assert( JSON.stringify(bondStateObject) === JSON.stringify(expectedObject) );
- */
-class Plaintext {
+    : new FinalizationRegistry(ptr => wasm.__wbg_poseidon4_free(ptr >>> 0, 1));
+
+class Poseidon4 {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Plaintext.prototype);
+        const obj = Object.create(Poseidon4.prototype);
         obj.__wbg_ptr = ptr;
-        PlaintextFinalization.register(obj, obj.__wbg_ptr, obj);
+        Poseidon4Finalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PlaintextFinalization.unregister(this);
+        Poseidon4Finalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_plaintext_free(ptr, 0);
+        wasm.__wbg_poseidon4_free(ptr, 0);
     }
     /**
-     * Find plaintext member if the plaintext is a struct. Returns `null` if the plaintext is not
-     * a struct or the member does not exist.
-     *
-     * @param {string} name The name of the plaintext member to find.
-     *
-     * @returns {Plaintext} The plaintext member.
-     * @param {string} name
-     * @returns {Plaintext}
+     * Create a Poseidon hasher with an input rate of 4.
      */
-    find(name) {
+    constructor() {
+        const ret = wasm.poseidon4_new();
+        this.__wbg_ptr = ret >>> 0;
+        Poseidon4Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a Poseidon hasher with an input rate of 4 and a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {Poseidon4}
+     */
+    static setup(domain_separator) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
             const len0 = WASM_VECTOR_LEN;
-            wasm.plaintext_find(retptr, this.__wbg_ptr, ptr0, len0);
+            wasm.poseidon4_setup(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Plaintext.__wrap(r0);
+            return Poseidon4.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Encrypt a plaintext with an address and randomizer.
-     * @param {Address} address
-     * @param {Scalar} randomizer
-     * @returns {Ciphertext}
+     * Returns the Poseidon hash with an input rate of 4.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    encrypt(address, randomizer) {
+    hash(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(address, Address);
-            _assertClass(randomizer, Scalar);
-            wasm.plaintext_encrypt(retptr, this.__wbg_ptr, address.__wbg_ptr, randomizer.__wbg_ptr);
+            wasm.poseidon4_hash(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Ciphertext.__wrap(r0);
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Encrypt a plaintext with a transition view key.
-     * @param {Field} transition_view_key
-     * @returns {Ciphertext}
+     * Returns the extended Poseidon hash with an input rate of 4.
+     * @param {Array<any>} input
+     * @param {number} num_outputs
+     * @returns {Array<any>}
      */
-    encryptSymmetric(transition_view_key) {
+    hashMany(input, num_outputs) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            _assertClass(transition_view_key, Field);
-            wasm.plaintext_encryptSymmetric(retptr, this.__wbg_ptr, transition_view_key.__wbg_ptr);
+            wasm.poseidon4_hashMany(retptr, this.__wbg_ptr, addHeapObject(input), num_outputs);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Ciphertext.__wrap(r0);
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Creates a plaintext object from a string representation of a plaintext.
-     *
-     * @param {string} plaintext The string representation of the plaintext.
-     *
-     * @returns {Plaintext} The plaintext object.
-     * @param {string} plaintext
-     * @returns {Plaintext}
+     * Returns the Poseidon hash with an input rate of 4 on the scalar field.
+     * @param {Array<any>} input
+     * @returns {Scalar}
      */
-    static fromString(plaintext) {
+    hashToScalar(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.plaintext_fromString(retptr, ptr0, len0);
+            wasm.poseidon4_hashToScalar(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Plaintext.__wrap(r0);
+            return Scalar.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Get a plaintext object from a series of bytes.
-     *
-     * @param {Uint8Array} bytes A left endian byte array representing the plaintext.
-     *
-     * @returns {Plaintext} The plaintext object.
-     * @param {Uint8Array} bytes
-     * @returns {Plaintext}
+     * Returns the Poseidon hash with an input rate of 4 on the affine curve.
+     * @param {Array<any>} input
+     * @returns {Group}
      */
-    static fromBytesLe(bytes) {
+    hashToGroup(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.plaintext_fromBytesLe(retptr, addHeapObject(bytes));
+            wasm.poseidon4_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return Plaintext.__wrap(r0);
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+}
+
+const Poseidon8Finalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_poseidon8_free(ptr >>> 0, 1));
+
+class Poseidon8 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Poseidon8.prototype);
+        obj.__wbg_ptr = ptr;
+        Poseidon8Finalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        Poseidon8Finalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_poseidon8_free(ptr, 0);
+    }
     /**
-     * Generate a random plaintext element from a series of bytes.
-     *
-     * @param {Uint8Array} bytes A left endian byte array representing the plaintext.
-     * @returns {Uint8Array}
+     * Create a Poseidon hasher with an input rate of 8.
      */
-    toBytesLe() {
+    constructor() {
+        const ret = wasm.poseidon8_new();
+        this.__wbg_ptr = ret >>> 0;
+        Poseidon8Finalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Create a Poseidon hasher with an input rate of 8 and a custom domain separator.
+     * @param {string} domain_separator
+     * @returns {Poseidon8}
+     */
+    static setup(domain_separator) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.plaintext_toBytesLe(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(domain_separator, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.poseidon8_setup(retptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            return Poseidon8.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * Returns the string representation of the plaintext.
-     *
-     * @returns {string} The string representation of the plaintext.
-     * @returns {string}
+     * Returns the Poseidon hash with an input rate of 8.
+     * @param {Array<any>} input
+     * @returns {Field}
      */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
+    hash(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.plaintext_toString(retptr, this.__wbg_ptr);
+            wasm.poseidon8_hash(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Gives the type of the plaintext.
-     *
-     * @returns {string} The type of the plaintext.
-     * @returns {string}
+     * Returns the extended Poseidon hash with an input rate of 8.
+     * @param {Array<any>} input
+     * @param {number} num_outputs
+     * @returns {Array<any>}
      */
-    plaintextType() {
-        let deferred1_0;
-        let deferred1_1;
+    hashMany(input, num_outputs) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.plaintext_plaintextType(retptr, this.__wbg_ptr);
+            wasm.poseidon8_hashMany(retptr, this.__wbg_ptr, addHeapObject(input), num_outputs);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-     * Attempt to convert the plaintext to a JS object.
-     *
-     * @returns {Object} The JS object representation of the plaintext.
-     * @returns {any}
+     * Returns the Poseidon hash with an input rate of 8 on the scalar field.
+     * @param {Array<any>} input
+     * @returns {Scalar}
      */
-    toObject() {
+    hashToScalar(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.plaintext_toObject(retptr, this.__wbg_ptr);
+            wasm.poseidon8_hashToScalar(retptr, this.__wbg_ptr, addHeapObject(input));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             if (r2) {
                 throw takeObject(r1);
             }
-            return takeObject(r0);
+            return Scalar.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the Poseidon hash with an input rate of 8 on the affine curve.
+     * @param {Array<any>} input
+     * @returns {Group}
+     */
+    hashToGroup(input) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.poseidon8_hashToGroup(retptr, this.__wbg_ptr, addHeapObject(input));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Group.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
@@ -4254,7 +5704,29 @@ class Scalar {
         wasm.__wbg_scalar_free(ptr, 0);
     }
     /**
-     * Returns the string representation of the group.
+     * Creates a scalar object from a string representation of a scalar element.
+     * @param {string} group
+     * @returns {Scalar}
+     */
+    static fromString(group) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(group, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.scalar_fromString(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Scalar.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Returns the string representation of the scalar element.
      * @returns {string}
      */
     toString() {
@@ -4274,24 +5746,54 @@ class Scalar {
         }
     }
     /**
-     * Create a plaintext element from a group element.
-     * @returns {Plaintext}
+     * Create a scalar element from a Uint8Array of left endian bytes.
+     * @param {Uint8Array} bytes
+     * @returns {Scalar}
      */
-    toPlaintext() {
-        const ret = wasm.scalar_toPlaintext(this.__wbg_ptr);
-        return Plaintext.__wrap(ret);
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.scalar_fromBytesLe(retptr, addBorrowedObject(bytes));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Scalar.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
     }
     /**
-     * Creates a group object from a string representation of a group.
-     * @param {string} group
+     * Encode the scalar element as a Uint8Array of left endian bytes.
+     * @returns {Uint8Array}
+     */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.scalar_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Reconstruct a scalar element from a boolean array representation.
+     * @param {Array<any>} bits
      * @returns {Scalar}
      */
-    static fromString(group) {
+    static fromBitsLe(bits) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(group, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.scalar_fromString(retptr, ptr0, len0);
+            wasm.scalar_fromBitsLe(retptr, addBorrowedObject(bits));
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -4301,10 +5803,35 @@ class Scalar {
             return Scalar.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
         }
     }
     /**
-     * Generate a random group element.
+     * Get the left endian boolean array representation of the scalar element.
+     * @returns {Array<any>}
+     */
+    toBitsLe() {
+        const ret = wasm.scalar_toBitsLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create a plaintext element from a scalar element.
+     * @returns {Plaintext}
+     */
+    toPlaintext() {
+        const ret = wasm.scalar_toPlaintext(this.__wbg_ptr);
+        return Plaintext.__wrap(ret);
+    }
+    /**
+     * Clone the scalar element.
+     * @returns {Scalar}
+     */
+    clone() {
+        const ret = wasm.field_clone(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+     * Generate a random scalar element.
      * @returns {Scalar}
      */
     static random() {
@@ -4378,7 +5905,7 @@ class Scalar {
         return Scalar.__wrap(ret);
     }
     /**
-     * Creates a one valued element of the scalar field.
+     * Get the multiplicative identity of the scalar field.
      * @returns {Scalar}
      */
     static one() {
@@ -4386,7 +5913,7 @@ class Scalar {
         return Scalar.__wrap(ret);
     }
     /**
-     * Creates a zero valued element of the scalar field
+     * Get the additive identity of the scalar field.
      * @returns {Scalar}
      */
     static zero() {
@@ -4464,7 +5991,7 @@ class Signature {
      * @returns {Scalar}
      */
     challenge() {
-        const ret = wasm.graphkey_sk_tag(this.__wbg_ptr);
+        const ret = wasm.field_clone(this.__wbg_ptr);
         return Scalar.__wrap(ret);
     }
     /**
@@ -5153,6 +6680,16 @@ class Transition {
         const ret = wasm.computekey_pk_sig(this.__wbg_ptr);
         return Group.__wrap(ret);
     }
+    /**
+     * Get the transition view key of the transition.
+     * @param {ViewKey} view_key
+     * @returns {Field}
+     */
+    tvk(view_key) {
+        _assertClass(view_key, ViewKey);
+        const ret = wasm.transition_tvk(this.__wbg_ptr, view_key.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
     /**
      * Get the transition commitment of the transition.
      * @returns {Field}
@@ -5717,7 +7254,7 @@ class ViewKey {
      * @returns {Scalar}
      */
     to_scalar() {
-        const ret = wasm.graphkey_sk_tag(this.__wbg_ptr);
+        const ret = wasm.field_clone(this.__wbg_ptr);
         return Scalar.__wrap(ret);
     }
     /**
@@ -5863,6 +7400,10 @@ function __wbg_get_imports() {
         const ret = Field.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_field_unwrap = function(arg0) {
+        const ret = Field.__unwrap(takeObject(arg0));
+        return ret;
+    };
     imports.wbg.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).getRandomValues(getObject(arg1));
     }, arguments) };
@@ -5912,7 +7453,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_9f90a4b62aac5c63 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_1af7ae7bd9c6ae19 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
@@ -5930,7 +7471,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_417(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_491(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -6109,7 +7650,7 @@ function __wbg_get_imports() {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_5909de4ce646c497 = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_a8e0ffb747e264de = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -6215,6 +7756,11 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_boolean_get = function(arg0) {
+        const v = getObject(arg0);
+        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+        return ret;
+    };
     imports.wbg.__wbindgen_cb_drop = function(arg0) {
         const obj = takeObject(arg0).original;
         if (obj.cnt-- == 1) {
@@ -6224,12 +7770,12 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper5894 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 519, __wbg_adapter_38);
+    imports.wbg.__wbindgen_closure_wrapper6041 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 519, __wbg_adapter_40);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper5900 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 519, __wbg_adapter_38);
+    imports.wbg.__wbindgen_closure_wrapper6047 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 519, __wbg_adapter_40);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_is_function = function(arg0) {
@@ -6384,5 +7930,5 @@ async function initThreadPool(threads) {
     await initThreadPool$1(new URL("worker.js", import.meta.url), threads);
 }
 
-export { Address, Ciphertext, ComputeKey, Execution, ExecutionResponse, Field, GraphKey, Group, KeyPair, Metadata, OfflineQuery, Plaintext, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, ProvingKey, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, VerifyingKey, ViewKey, initSync, initThreadPool, runRayonThread, verifyFunctionExecution };
+export { Address, BHP1024, BHP256, BHP512, BHP768, Ciphertext, ComputeKey, Execution, ExecutionResponse, Field, GraphKey, Group, KeyPair, Metadata, OfflineQuery, Pedersen128, Pedersen64, Plaintext, Poseidon2, Poseidon4, Poseidon8, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager, ProvingKey, RecordCiphertext, RecordPlaintext, Scalar, Signature, Transaction, Transition, VerifyingKey, ViewKey, initSync, initThreadPool, runRayonThread, verifyFunctionExecution };
 //# sourceMappingURL=index.js.map