@provablehq/wasm 0.7.2 → 0.8.0

package/dist/mainnet/aleo_wasm.js

@@ -237,7 +237,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     CLOSURE_DTORS.register(real, state, state);
     return real;
 }
-function __wbg_adapter_34(arg0, arg1, arg2) {
+function __wbg_adapter_40(arg0, arg1, arg2) {
     wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h1503081f6025e61c(arg0, arg1, addHeapObject(arg2));
 }
 
@@ -328,7 +328,7 @@ function handleError(f, args) {
         wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
-function __wbg_adapter_282(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_419(arg0, arg1, arg2, arg3) {
     wasm.wasm_bindgen__convert__closures__invoke2_mut__hc5c49be524f0cde8(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
@@ -386,6 +386,18 @@ class Address {
         return Address.__wrap(ret);
     }
     /**
+    * Derive an Aleo address from a compute key.
+    *
+    * @param {ComputeKey} compute_key The compute key to derive the address from
+    * @param {ComputeKey} compute_key
+    * @returns {Address}
+    */
+    static from_compute_key(compute_key) {
+        _assertClass(compute_key, ComputeKey);
+        const ret = wasm.address_from_compute_key(compute_key.__wbg_ptr);
+        return Address.__wrap(ret);
+    }
+    /**
     * Create an aleo address object from a string representation of an address
     *
     * @param {string} address String representation of an addressm
@@ -440,6 +452,270 @@ class Address {
     }
 }
 
+const CiphertextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ciphertext_free(ptr >>> 0));
+/**
+* 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 {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Ciphertext.prototype);
+        obj.__wbg_ptr = ptr;
+        CiphertextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CiphertextFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ciphertext_free(ptr);
+    }
+    /**
+    * 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}
+    */
+    decrypt(view_key, nonce) {
+        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);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            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 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}
+    */
+    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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            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_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ciphertext_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const ComputeKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_computekey_free(ptr >>> 0));
+/**
+*/
+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);
+    }
+    /**
+    * 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));
@@ -469,6 +745,8 @@ class Execution {
     }
     /**
     * Returns the string representation of the execution.
+    *
+    * @returns {string} The string representation of the execution.
     * @returns {string}
     */
     toString() {
@@ -489,6 +767,8 @@ class Execution {
     }
     /**
     * 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}
     */
@@ -509,6 +789,60 @@ class Execution {
             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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(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')
@@ -636,6 +970,7 @@ const FieldFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_field_free(ptr >>> 0));
 /**
+* Field element.
 */
 class Field {
 
@@ -659,6 +994,37 @@ class Field {
         wasm.__wbg_field_free(ptr);
     }
     /**
+    * Creates a field object from a string representation of a field.
+    * @param {string} field
+    * @returns {Field}
+    */
+    static fromString(field) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.field_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Create a plaintext element from a group element.
+    * @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() {
@@ -678,26 +1044,358 @@ class Field {
         }
     }
     /**
-    * @param {string} field
+    * Generate a random field element.
     * @returns {Field}
     */
-    static fromString(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 zero element of the field.
+    * @returns {Field}
+    */
+    static zero() {
+        const ret = wasm.field_zero();
+        return Field.__wrap(ret);
+    }
+    /**
+    * Get the one element 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));
+/**
+*/
+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);
+    }
+    /**
+    * 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_malloc, wasm.__wbindgen_realloc);
+        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);
-            const ptr0 = passStringToWasm0(field, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            wasm.graphkey_to_string(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(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.graphkey_sk_tag(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+}
+
+const GroupFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_group_free(ptr >>> 0));
+/**
+* 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);
+    }
+    /**
+    * Creates a group object from a string representation of a group.
+    * @param {string} group
+    * @returns {Group}
+    */
+    static fromString(group) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(group, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len0 = WASM_VECTOR_LEN;
-            wasm.field_fromString(retptr, ptr0, len0);
+            wasm.group_fromString(retptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
             if (r2) {
                 throw takeObject(r1);
             }
-            return Field.__wrap(r0);
+            return Group.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Returns the string representation of the group.
+    * @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 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+    * 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}
+    */
+    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')
@@ -1203,113 +1901,366 @@ class OfflineQuery {
     }
 }
 
-const PrivateKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+const PlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_privatekey_free(ptr >>> 0));
+    : new FinalizationRegistry(ptr => wasm.__wbg_plaintext_free(ptr >>> 0));
 /**
-* Private key of an Aleo account
+* 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 PrivateKey {
+class Plaintext {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(PrivateKey.prototype);
+        const obj = Object.create(Plaintext.prototype);
         obj.__wbg_ptr = ptr;
-        PrivateKeyFinalization.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;
-        PrivateKeyFinalization.unregister(this);
+        PlaintextFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_privatekey_free(ptr);
+        wasm.__wbg_plaintext_free(ptr);
     }
     /**
-    * Generate a new private key using a cryptographically secure random number generator
+    * Find plaintext member if the plaintext is a struct. Returns `null` if the plaintext is not
+    * a struct or the member does not exist.
     *
-    * @returns {PrivateKey}
-    */
-    constructor() {
-        const ret = wasm.privatekey_new();
-        this.__wbg_ptr = ret >>> 0;
-        return this;
-    }
-    /**
-    * Get a private key from a series of unchecked bytes
+    * @param {string} name The name of the plaintext member to find.
     *
-    * @param {Uint8Array} seed Unchecked 32 byte long Uint8Array acting as the seed for the private key
-    * @returns {PrivateKey}
-    * @param {Uint8Array} seed
-    * @returns {PrivateKey}
+    * @returns {Plaintext} The plaintext member.
+    * @param {string} name
+    * @returns {Plaintext}
     */
-    static from_seed_unchecked(seed) {
-        const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.privatekey_from_seed_unchecked(ptr0, len0);
-        return PrivateKey.__wrap(ret);
+    find(name) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.plaintext_find(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-    * Get a private key from a string representation of a private key
-    *
-    * @param {string} seed String representation of a private key
-    * @returns {PrivateKey}
-    * @param {string} private_key
-    * @returns {PrivateKey}
+    * Encrypt a plaintext with an address and randomizer.
+    * @param {Address} address
+    * @param {Scalar} randomizer
+    * @returns {Ciphertext}
     */
-    static from_string(private_key) {
+    encrypt(address, randomizer) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(private_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.privatekey_from_string(retptr, ptr0, len0);
+            _assertClass(address, Address);
+            _assertClass(randomizer, Scalar);
+            wasm.plaintext_encrypt(retptr, this.__wbg_ptr, address.__wbg_ptr, randomizer.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
             if (r2) {
                 throw takeObject(r1);
             }
-            return PrivateKey.__wrap(r0);
+            return Ciphertext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-    * Get a string representation of the private key. This function should be used very carefully
-    * as it exposes the private key plaintext
-    *
-    * @returns {string} String representation of a private key
-    * @returns {string}
+    * Encrypt a plaintext with a transition view key.
+    * @param {Field} transition_view_key
+    * @returns {Ciphertext}
     */
-    to_string() {
-        let deferred1_0;
-        let deferred1_1;
+    encryptSymmetric(transition_view_key) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.privatekey_to_string(retptr, this.__wbg_ptr);
+            _assertClass(transition_view_key, Field);
+            wasm.plaintext_encryptSymmetric(retptr, this.__wbg_ptr, transition_view_key.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Ciphertext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * Get the view key corresponding to the private key
+    * Creates a plaintext object from a string representation of a plaintext.
     *
-    * @returns {ViewKey}
-    * @returns {ViewKey}
+    * @param {string} plaintext The string representation of the plaintext.
+    *
+    * @returns {Plaintext} The plaintext object.
+    * @param {string} plaintext
+    * @returns {Plaintext}
     */
-    to_view_key() {
-        const ret = wasm.privatekey_to_view_key(this.__wbg_ptr);
+    static fromString(plaintext) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.plaintext_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__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}
+    */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_fromBytesLe(retptr, addHeapObject(bytes));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Generate a random plaintext element from a series of bytes.
+    *
+    * @param {Uint8Array} bytes A left endian byte array representing the plaintext.
+    * @returns {Uint8Array}
+    */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            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}
+    */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toString(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Gives the type of the plaintext.
+    *
+    * @returns {string} The type of the plaintext.
+    * @returns {string}
+    */
+    plaintextType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_plaintextType(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(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}
+    */
+    toObject() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toObject(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
+const PrivateKeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_privatekey_free(ptr >>> 0));
+/**
+* Private key of an Aleo account
+*/
+class PrivateKey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PrivateKey.prototype);
+        obj.__wbg_ptr = ptr;
+        PrivateKeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PrivateKeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_privatekey_free(ptr);
+    }
+    /**
+    * Generate a new private key using a cryptographically secure random number generator
+    *
+    * @returns {PrivateKey}
+    */
+    constructor() {
+        const ret = wasm.privatekey_new();
+        this.__wbg_ptr = ret >>> 0;
+        return this;
+    }
+    /**
+    * Get a private key from a series of unchecked bytes
+    *
+    * @param {Uint8Array} seed Unchecked 32 byte long Uint8Array acting as the seed for the private key
+    * @returns {PrivateKey}
+    * @param {Uint8Array} seed
+    * @returns {PrivateKey}
+    */
+    static from_seed_unchecked(seed) {
+        const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.privatekey_from_seed_unchecked(ptr0, len0);
+        return PrivateKey.__wrap(ret);
+    }
+    /**
+    * Get a private key from a string representation of a private key
+    *
+    * @param {string} seed String representation of a private key
+    * @returns {PrivateKey}
+    * @param {string} private_key
+    * @returns {PrivateKey}
+    */
+    static from_string(private_key) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(private_key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.privatekey_from_string(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return PrivateKey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get a string representation of the private key. This function should be used very carefully
+    * as it exposes the private key plaintext
+    *
+    * @returns {string} String representation of a private key
+    * @returns {string}
+    */
+    to_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.privatekey_to_string(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Get the view key corresponding to the private key
+    *
+    * @returns {ViewKey}
+    * @returns {ViewKey}
+    */
+    to_view_key() {
+        const ret = wasm.privatekey_to_view_key(this.__wbg_ptr);
         return ViewKey.__wrap(ret);
     }
     /**
@@ -1511,7 +2462,7 @@ class PrivateKeyCiphertext {
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.privatekeyciphertext_toString(retptr, this.__wbg_ptr);
+            wasm.ciphertext_toString(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -3009,6 +3960,35 @@ class RecordCiphertext {
         const ret = wasm.recordciphertext_isOwner(this.__wbg_ptr, view_key.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+    * Get the tag of the record using the graph key.
+    *
+    * @param {GraphKey} graph key of the account associatd with the record.
+    * @param {Field} commitment of the record.
+    *
+    * @returns {Field} tag of the record.
+    * @param {GraphKey} graph_key
+    * @param {Field} commitment
+    * @returns {Field}
+    */
+    static tag(graph_key, commitment) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(graph_key, GraphKey);
+            _assertClass(commitment, Field);
+            var ptr0 = commitment.__destroy_into_raw();
+            wasm.recordciphertext_tag(retptr, graph_key.__wbg_ptr, ptr0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 
 const RecordPlaintextFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3088,40 +4068,147 @@ class RecordPlaintext {
         }
     }
     /**
-    * Returns the record plaintext string
-    *
-    * @returns {string} String representation of the record plaintext
-    * @returns {string}
+    * @param {string} input
+    * @returns {Plaintext}
     */
-    toString() {
-        let deferred1_0;
-        let deferred1_1;
+    getMember(input) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.recordplaintext_toString(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.recordplaintext_getMember(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Plaintext.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
     /**
-    * Returns the amount of microcredits in the record
-    *
-    * @returns {u64} Amount of microcredits in the record
-    * @returns {bigint}
+    * Get the owner of the record.
+    * @returns {Address}
     */
-    microcredits() {
-        const ret = wasm.recordplaintext_microcredits(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-    * Returns the nonce of the record. This can be used to uniquely identify a record.
-    *
+    owner() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.recordplaintext_owner(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Address.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get a representation of a record as a javascript object for usage in client side
+    * computations. Note that this is not a reversible operation and exists for the convenience
+    * of discovering and using properties of the record.
+    *
+    * The conversion guide is as follows:
+    * - u8, u16, u32, i8, i16 i32 --> Number
+    * - u64, u128, i64, i128 --> BigInt
+    * - Address, Field, Group, Scalar --> String.
+    *
+    * Address, Field, Group, and Scalar will all be converted to their bech32 string
+    * representation. These string representations can be converted back to their respective wasm
+    * types using the fromString method on the Address, Field, Group, and Scalar objects in this
+    * library.
+    *
+    * @example
+    * # Create a wasm record from a record string.
+    * let record_plaintext_wasm = RecordPlainext.from_string("{
+    *   owner: aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48.private,
+    *   metadata: {
+    *     player1: aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48.private,
+    *     player2: aleo1dreuxnmg9cny8ee9v2u0wr4v4affnwm09u2pytfwz0f2en2shgqsdsfjn6.private,
+    *     nonce: 660310649780728486489183263981322848354071976582883879926426319832534836534field.private
+    *   },
+    *   id: 1953278585719525811355617404139099418855053112960441725284031425961000152405field.private,
+    *   positions: 50794271u64.private,
+    *   attempts: 0u64.private,
+    *   hits: 0u64.private,
+    *   _nonce: 5668100912391182624073500093436664635767788874314097667746354181784048204413group.public
+    * }");
+    *
+    * let expected_object = {
+    *   owner: "aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48",
+    *   metadata: {
+    *     player1: "aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48",
+    *     player2: "aleo1dreuxnmg9cny8ee9v2u0wr4v4affnwm09u2pytfwz0f2en2shgqsdsfjn6",
+    *     nonce: "660310649780728486489183263981322848354071976582883879926426319832534836534field"
+    *   },
+    *   id: "1953278585719525811355617404139099418855053112960441725284031425961000152405field",
+    *   positions: 50794271,
+    *   attempts: 0,
+    *   hits: 0,
+    *   _nonce: "5668100912391182624073500093436664635767788874314097667746354181784048204413group"
+    * };
+    *
+    * # Create the expected object
+    * let record_plaintext_object = record_plaintext_wasm.to_js_object();
+    * assert(JSON.stringify(record_plaintext_object) == JSON.stringify(expected_object));
+    *
+    * @returns {Object} Javascript object representation of the record
+    * @returns {object}
+    */
+    toJsObject() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.recordplaintext_toJsObject(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Returns the record plaintext string
+    *
+    * @returns {string} String representation of the record plaintext
+    * @returns {string}
+    */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.recordplaintext_toString(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Returns the amount of microcredits in the record
+    *
+    * @returns {u64} Amount of microcredits in the record
+    * @returns {bigint}
+    */
+    microcredits() {
+        const ret = wasm.recordplaintext_microcredits(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * Returns the nonce of the record. This can be used to uniquely identify a record.
+    *
     * @returns {string} Nonce of the record
     * @returns {string}
     */
@@ -3147,6 +4234,7 @@ class RecordPlaintext {
     * @param {PrivateKey} private_key Private key of the account that owns the record
     * @param {string} program_id Program ID of the program that the record is associated with
     * @param {string} record_name Name of the record
+    *
     * @returns {string} Serial number of the record
     * @param {PrivateKey} private_key
     * @param {string} program_id
@@ -3182,6 +4270,209 @@ class RecordPlaintext {
             wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
         }
     }
+    /**
+    * Get the tag of the record using the graph key.
+    * @param {GraphKey} graph_key
+    * @param {Field} commitment
+    * @returns {Field}
+    */
+    tag(graph_key, commitment) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(graph_key, GraphKey);
+            _assertClass(commitment, Field);
+            var ptr0 = commitment.__destroy_into_raw();
+            wasm.recordplaintext_tag(retptr, this.__wbg_ptr, graph_key.__wbg_ptr, ptr0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Field.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
+const ScalarFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_scalar_free(ptr >>> 0));
+/**
+* Scalar field element.
+*/
+class Scalar {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Scalar.prototype);
+        obj.__wbg_ptr = ptr;
+        ScalarFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ScalarFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_scalar_free(ptr);
+    }
+    /**
+    * Returns the string representation of the group.
+    * @returns {string}
+    */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.scalar_toString(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Create a plaintext element from a group element.
+    * @returns {Plaintext}
+    */
+    toPlaintext() {
+        const ret = wasm.scalar_toPlaintext(this.__wbg_ptr);
+        return Plaintext.__wrap(ret);
+    }
+    /**
+    * Creates a group object from a string representation of a group.
+    * @param {string} group
+    * @returns {Scalar}
+    */
+    static fromString(group) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(group, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.scalar_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Scalar.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Generate a random group element.
+    * @returns {Scalar}
+    */
+    static random() {
+        const ret = wasm.scalar_random();
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Add two scalar elements.
+    * @param {Scalar} other
+    * @returns {Scalar}
+    */
+    add(other) {
+        _assertClass(other, Scalar);
+        const ret = wasm.scalar_add(this.__wbg_ptr, other.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Subtract two scalar elements.
+    * @param {Scalar} other
+    * @returns {Scalar}
+    */
+    subtract(other) {
+        _assertClass(other, Scalar);
+        const ret = wasm.scalar_subtract(this.__wbg_ptr, other.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Multiply two scalar elements.
+    * @param {Scalar} other
+    * @returns {Scalar}
+    */
+    multiply(other) {
+        _assertClass(other, Scalar);
+        const ret = wasm.scalar_multiply(this.__wbg_ptr, other.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Divide two scalar elements.
+    * @param {Scalar} other
+    * @returns {Scalar}
+    */
+    divide(other) {
+        _assertClass(other, Scalar);
+        const ret = wasm.scalar_divide(this.__wbg_ptr, other.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Double the scalar element.
+    * @returns {Scalar}
+    */
+    double() {
+        const ret = wasm.scalar_double(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Power of a scalar element.
+    * @param {Scalar} other
+    * @returns {Scalar}
+    */
+    pow(other) {
+        _assertClass(other, Scalar);
+        const ret = wasm.scalar_pow(this.__wbg_ptr, other.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Invert the scalar element.
+    * @returns {Scalar}
+    */
+    inverse() {
+        const ret = wasm.scalar_inverse(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Creates a one valued element of the scalar field.
+    * @returns {Scalar}
+    */
+    static one() {
+        const ret = wasm.scalar_one();
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Creates a zero valued element of the scalar field
+    * @returns {Scalar}
+    */
+    static zero() {
+        const ret = wasm.field_zero();
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Check if one scalar element equals another.
+    * @param {Scalar} other
+    * @returns {boolean}
+    */
+    equals(other) {
+        _assertClass(other, Scalar);
+        const ret = wasm.field_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 
 const SignatureFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3229,6 +4520,32 @@ class Signature {
         return Signature.__wrap(ret);
     }
     /**
+    * Get an address from a signature.
+    *
+    * @returns {Address} Address object
+    * @returns {Address}
+    */
+    to_address() {
+        const ret = wasm.signature_to_address(this.__wbg_ptr);
+        return Address.__wrap(ret);
+    }
+    /**
+    * Get the challenge of a signature.
+    * @returns {Scalar}
+    */
+    challenge() {
+        const ret = wasm.graphkey_sk_tag(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
+    * Get the response of a signature.
+    * @returns {Scalar}
+    */
+    response() {
+        const ret = wasm.signature_response(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
     * Verify a signature of a message with an address
     *
     * @param {Address} address The address to verify the signature with
@@ -3253,24 +4570,352 @@ class Signature {
     * @param {string} signature
     * @returns {Signature}
     */
-    static from_string(signature) {
-        const ptr0 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.signature_from_string(ptr0, len0);
-        return Signature.__wrap(ret);
+    static from_string(signature) {
+        const ptr0 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.signature_from_string(ptr0, len0);
+        return Signature.__wrap(ret);
+    }
+    /**
+    * Get a string representation of a signature
+    *
+    * @returns {string} String representation of a signature
+    * @returns {string}
+    */
+    to_string() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.signature_to_string(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+
+const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0));
+/**
+* Webassembly Representation of an Aleo transaction
+*
+* This object is created when generating an on-chain function deployment or execution and is the
+* object that should be submitted to the Aleo Network in order to deploy or execute a function.
+*/
+class Transaction {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Transaction.prototype);
+        obj.__wbg_ptr = ptr;
+        TransactionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TransactionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_transaction_free(ptr);
+    }
+    /**
+    * Create a transaction from a string
+    *
+    * @param {string} transaction String representation of a transaction
+    * @returns {Transaction}
+    * @param {string} transaction
+    * @returns {Transaction}
+    */
+    static fromString(transaction) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(transaction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.transaction_fromString(retptr, ptr0, len0);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Transaction.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Create a transaction from a Uint8Array of left endian bytes.
+    *
+    * @param {Uint8Array} Uint8Array of left endian bytes encoding a Transaction.
+    * @returns {Transaction}
+    * @param {Uint8Array} bytes
+    * @returns {Transaction}
+    */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_fromBytesLe(retptr, addHeapObject(bytes));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Transaction.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get the transaction as a string. If you want to submit this transaction to the Aleo Network
+    * this function will create the string that should be submitted in the `POST` data.
+    *
+    * @returns {string} String representation of the transaction
+    * @returns {string}
+    */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_toString(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Get the transaction as a Uint8Array of left endian bytes.
+    *
+    * @returns {Uint8Array} Uint8Array representation of the transaction
+    * @returns {Uint8Array}
+    */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Returns true if the transaction contains the given serial number.
+    *
+    * @param {boolean} True if the transaction contains the given serial number.
+    * @param {Field} serial_number
+    * @returns {boolean}
+    */
+    constainsSerialNumber(serial_number) {
+        _assertClass(serial_number, Field);
+        const ret = wasm.transaction_constainsSerialNumber(this.__wbg_ptr, serial_number.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Returns true if the transaction contains the given commitment.
+    *
+    * @param {boolean} True if the transaction contains the given commitment.
+    * @param {Field} commitment
+    * @returns {boolean}
+    */
+    constainsCommitment(commitment) {
+        _assertClass(commitment, Field);
+        const ret = wasm.transaction_constainsCommitment(this.__wbg_ptr, commitment.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Find a record in the transaction by the record's commitment.
+    * @param {Field} commitment
+    * @returns {RecordCiphertext | undefined}
+    */
+    findRecord(commitment) {
+        _assertClass(commitment, Field);
+        const ret = wasm.transaction_findRecord(this.__wbg_ptr, commitment.__wbg_ptr);
+        return ret === 0 ? undefined : RecordCiphertext.__wrap(ret);
+    }
+    /**
+    * Returns the transaction's base fee.
+    * @returns {bigint}
+    */
+    baseFeeAmount() {
+        const ret = wasm.transaction_baseFeeAmount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * Returns the transaction's total fee.
+    * @returns {bigint}
+    */
+    feeAmount() {
+        const ret = wasm.transaction_feeAmount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * Returns the transaction's priority fee.
+    *
+    * returns {bigint} The transaction's priority fee.
+    * @returns {bigint}
+    */
+    priorityFeeAmount() {
+        const ret = wasm.transaction_priorityFeeAmount(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+    * Returns true if the transaction is a deployment transaction.
+    *
+    * @returns {boolean} True if the transaction is a deployment transaction
+    * @returns {boolean}
+    */
+    isDeploy() {
+        const ret = wasm.transaction_isDeploy(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Returns true if the transaction is an execution transaction.
+    *
+    * @returns {boolean} True if the transaction is an execution transaction
+    * @returns {boolean}
+    */
+    isExecute() {
+        const ret = wasm.transaction_isExecute(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Returns true if the transaction is a fee transaction.
+    *
+    * @returns {boolean} True if the transaction is a fee transaction
+    * @returns {boolean}
+    */
+    isFee() {
+        const ret = wasm.transaction_isFee(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Returns the program deployed within the transaction if the transaction is a deployment
+    * transaction.
+    *
+    * @returns {Program | undefined} The program deployed within the transaction.
+    * @returns {Program | undefined}
+    */
+    deployedProgram() {
+        const ret = wasm.transaction_deployedProgram(this.__wbg_ptr);
+        return ret === 0 ? undefined : Program.__wrap(ret);
+    }
+    /**
+    * Returns the execution within the transaction (if present).
+    *
+    * @returns {Execution | undefined} The execution within the transaction.
+    * @returns {Execution | undefined}
+    */
+    execution() {
+        const ret = wasm.transaction_execution(this.__wbg_ptr);
+        return ret === 0 ? undefined : Execution.__wrap(ret);
+    }
+    /**
+    * Get the record plaintext present in a transaction owned by a specific view key.
+    *
+    * @param {ViewKey} view_key View key used to decrypt the ciphertext
+    *
+    * @returns {Array<RecordPlaintext>} Array of record plaintext objects
+    * @param {ViewKey} view_key
+    * @returns {Array<any>}
+    */
+    ownedRecords(view_key) {
+        _assertClass(view_key, ViewKey);
+        const ret = wasm.transaction_ownedRecords(this.__wbg_ptr, view_key.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get the records present in a transaction and their commitments.
+    *
+    * @returns {Array<{commitment: Field, record: RecordCiphertext}>} Array of record ciphertext objects
+    * @returns {Array<any>}
+    */
+    records() {
+        const ret = wasm.transaction_records(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get a summary of the transaction within a javascript object.
+    *
+    * If the transaction is an execution transaction, this function will return a list of the
+    * transitions and their inputs and outputs.
+    *
+    * If the transaction is a deployment transaction, this function will return the program id and
+    * a list of the functions and their verifying keys, constraint, and variable counts.
+    *
+    * @param {boolean} convert_to_js If true the inputs and outputs will be converted to JS objects,
+    * if false the inputs and outputs will be in wasm format.
+    *
+    * @returns {Object} Transaction summary
+    * @param {boolean} convert_to_js
+    * @returns {object}
+    */
+    summary(convert_to_js) {
+        const ret = wasm.transaction_summary(this.__wbg_ptr, convert_to_js);
+        return takeObject(ret);
+    }
+    /**
+    * Get the id of the transaction. This is the merkle root of the transaction's inclusion proof.
+    *
+    * This value can be used to query the status of the transaction on the Aleo Network to see
+    * if it was successful. If successful, the transaction will be included in a block and this
+    * value can be used to lookup the transaction data on-chain.
+    *
+    * @returns {string} TransactionId
+    * @returns {string}
+    */
+    id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_id(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
     }
     /**
-    * Get a string representation of a signature
+    * Get the
+    * Get the type of the transaction (will return "deploy" or "execute")
     *
-    * @returns {string} String representation of a signature
+    * @returns {string} Transaction type
     * @returns {string}
     */
-    to_string() {
+    transactionType() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.signature_to_string(retptr, this.__wbg_ptr);
+            wasm.transaction_transactionType(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -3281,68 +4926,129 @@ class Signature {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+    * Get the transitions in a transaction.
+    *
+    * @returns {Array<Transition>} Array of transition objects
+    * @returns {Array<any>}
+    */
+    transitions() {
+        const ret = wasm.transaction_transitions(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get the verifying keys in a transaction.
+    *
+    * @returns {Array<Object>} Array of verifying keys.
+    * @returns {Array<any>}
+    */
+    verifyingKeys() {
+        const ret = wasm.transaction_verifyingKeys(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 
-const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
+const TransitionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0));
+    : new FinalizationRegistry(ptr => wasm.__wbg_transition_free(ptr >>> 0));
 /**
-* Webassembly Representation of an Aleo transaction
-*
-* This object is created when generating an on-chain function deployment or execution and is the
-* object that should be submitted to the Aleo Network in order to deploy or execute a function.
 */
-class Transaction {
+class Transition {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Transaction.prototype);
+        const obj = Object.create(Transition.prototype);
         obj.__wbg_ptr = ptr;
-        TransactionFinalization.register(obj, obj.__wbg_ptr, obj);
+        TransitionFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        TransactionFinalization.unregister(this);
+        TransitionFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_transaction_free(ptr);
+        wasm.__wbg_transition_free(ptr);
     }
     /**
-    * Create a transaction from a string
+    * Get the transition ID
     *
-    * @param {string} transaction String representation of a transaction
-    * @returns {Transaction}
-    * @param {string} transaction
-    * @returns {Transaction}
+    * @returns {string} The transition ID
+    * @returns {string}
     */
-    static fromString(transaction) {
+    id() {
+        let deferred1_0;
+        let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(transaction, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            wasm.transition_id(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+    * Create a transition from a string
+    *
+    * @param {string} transition String representation of a transition
+    * @returns {Transition}
+    * @param {string} transition
+    * @returns {Transition}
+    */
+    static fromString(transition) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(transition, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len0 = WASM_VECTOR_LEN;
-            wasm.transaction_fromString(retptr, ptr0, len0);
+            wasm.transition_fromString(retptr, ptr0, len0);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             var r2 = getInt32Memory0()[retptr / 4 + 2];
             if (r2) {
                 throw takeObject(r1);
             }
-            return Transaction.__wrap(r0);
+            return Transition.__wrap(r0);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-    * Get the transaction as a string. If you want to submit this transaction to the Aleo Network
+    * Create a transition from a Uint8Array of left endian bytes.
+    *
+    * @param {Uint8Array} Uint8Array of left endian bytes encoding a Transition.
+    * @returns {Transition}
+    * @param {Uint8Array} bytes
+    * @returns {Transition}
+    */
+    static fromBytesLe(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transition_fromBytesLe(retptr, addHeapObject(bytes));
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Transition.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get the transition as a string. If you want to submit this transition to the Aleo Network
     * this function will create the string that should be submitted in the `POST` data.
     *
-    * @returns {string} String representation of the transaction
+    * @returns {string} String representation of the transition
     * @returns {string}
     */
     toString() {
@@ -3350,7 +5056,7 @@ class Transaction {
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.transaction_toString(retptr, this.__wbg_ptr);
+            wasm.transition_toString(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -3362,21 +5068,36 @@ class Transaction {
         }
     }
     /**
-    * Get the id of the transaction. This is the merkle root of the transaction's inclusion proof.
-    *
-    * This value can be used to query the status of the transaction on the Aleo Network to see
-    * if it was successful. If successful, the transaction will be included in a block and this
-    * value can be used to lookup the transaction data on-chain.
+    * Get the transition as a Uint8Array of left endian bytes.
     *
-    * @returns {string} Transaction id
+    * @returns {Uint8Array} Uint8Array representation of the transition
+    * @returns {Uint8Array}
+    */
+    toBytesLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transition_toBytesLe(retptr, this.__wbg_ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            var r2 = getInt32Memory0()[retptr / 4 + 2];
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * Get the program ID of the transition.
     * @returns {string}
     */
-    transactionId() {
+    programId() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.transaction_transactionId(retptr, this.__wbg_ptr);
+            wasm.transition_programId(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -3388,17 +5109,15 @@ class Transaction {
         }
     }
     /**
-    * Get the type of the transaction (will return "deploy" or "execute")
-    *
-    * @returns {string} Transaction type
+    * Get the function name of the transition.
     * @returns {string}
     */
-    transactionType() {
+    functionName() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.transaction_transactionType(retptr, this.__wbg_ptr);
+            wasm.transition_functionName(retptr, this.__wbg_ptr);
             var r0 = getInt32Memory0()[retptr / 4 + 0];
             var r1 = getInt32Memory0()[retptr / 4 + 1];
             deferred1_0 = r0;
@@ -3409,6 +5128,118 @@ class Transaction {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+    * Returns true if the transition contains the given commitment.
+    *
+    * @param {boolean} True if the transition contains the given commitment.
+    * @param {Field} commitment
+    * @returns {boolean}
+    */
+    containsCommitment(commitment) {
+        _assertClass(commitment, Field);
+        const ret = wasm.transition_containsCommitment(this.__wbg_ptr, commitment.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Check if the transition contains a serial number.
+    *
+    * @param {Field} serial_number The serial number to check for
+    *
+    * @returns {bool} True if the transition contains a serial number, false otherwise
+    * @param {Field} serial_number
+    * @returns {boolean}
+    */
+    containsSerialNumber(serial_number) {
+        _assertClass(serial_number, Field);
+        const ret = wasm.transition_containsSerialNumber(this.__wbg_ptr, serial_number.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+    * Find a record in the transition by the record's commitment.
+    * @param {Field} commitment
+    * @returns {RecordCiphertext | undefined}
+    */
+    findRecord(commitment) {
+        _assertClass(commitment, Field);
+        const ret = wasm.transition_findRecord(this.__wbg_ptr, commitment.__wbg_ptr);
+        return ret === 0 ? undefined : RecordCiphertext.__wrap(ret);
+    }
+    /**
+    * Get the record plaintext present in a transition owned by a specific view key.
+    *
+    * @param {ViewKey} view_key The view key of the record owner.
+    *
+    * @returns {Array<RecordPlaintext>} Array of record plaintext objects
+    * @param {ViewKey} view_key
+    * @returns {Array<any>}
+    */
+    ownedRecords(view_key) {
+        _assertClass(view_key, ViewKey);
+        const ret = wasm.transition_ownedRecords(this.__wbg_ptr, view_key.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get the records present in a transition and their commitments.
+    *
+    * @returns {Array<{commitment: Field, record: RecordCiphertext}>} Array of record ciphertext objects
+    * @returns {Array<any>}
+    */
+    records() {
+        const ret = wasm.transition_records(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+    * Get the inputs of the transition.
+    *
+    * @param {bool} convert_to_js If true the inputs will be converted to JS objects, if false
+    * the inputs will be in wasm format.
+    *
+    * @returns {Array} Array of inputs
+    * @param {boolean} convert_to_js
+    * @returns {Array<any>}
+    */
+    inputs(convert_to_js) {
+        const ret = wasm.transition_inputs(this.__wbg_ptr, convert_to_js);
+        return takeObject(ret);
+    }
+    /**
+    * Get the outputs of the transition.
+    *
+    * @param {bool} convert_to_js If true the outputs will be converted to JS objects, if false
+    * the outputs will be in wasm format.
+    *
+    * @returns {Array} Array of outputs
+    * @param {boolean} convert_to_js
+    * @returns {Array<any>}
+    */
+    outputs(convert_to_js) {
+        const ret = wasm.transition_outputs(this.__wbg_ptr, convert_to_js);
+        return takeObject(ret);
+    }
+    /**
+    * Get the transition public key of the transition.
+    * @returns {Group}
+    */
+    tpk() {
+        const ret = wasm.computekey_pk_sig(this.__wbg_ptr);
+        return Group.__wrap(ret);
+    }
+    /**
+    * Get the transition commitment of the transition.
+    * @returns {Field}
+    */
+    tcm() {
+        const ret = wasm.transition_tcm(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
+    /**
+    * Get the transition signer commitment of the transition.
+    * @returns {Field}
+    */
+    scm() {
+        const ret = wasm.transition_scm(this.__wbg_ptr);
+        return Field.__wrap(ret);
+    }
 }
 
 const VerifyingKeyFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -3954,6 +5785,14 @@ class ViewKey {
         return Address.__wrap(ret);
     }
     /**
+    * Get the underlying scalar of a view key.
+    * @returns {Scalar}
+    */
+    to_scalar() {
+        const ret = wasm.graphkey_sk_tag(this.__wbg_ptr);
+        return Scalar.__wrap(ret);
+    }
+    /**
     * Decrypt a record ciphertext with a view key
     *
     * @param {string} ciphertext String representation of a record ciphertext
@@ -4155,24 +5994,16 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     };
-    imports.wbg.__wbg_log_eb85b4536c227931 = function(arg0, arg1) {
-        console.log(getStringFromWasm0(arg0, arg1));
-    };
-    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
-        const ret = BigInt.asUintN(64, arg0);
+    imports.wbg.__wbg_transaction_new = function(arg0) {
+        const ret = Transaction.__wrap(arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_keypair_new = function(arg0) {
-        const ret = KeyPair.__wrap(arg0);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_transaction_new = function(arg0) {
-        const ret = Transaction.__wrap(arg0);
-        return addHeapObject(ret);
+    imports.wbg.__wbg_log_0373a28c0a891b83 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_executionresponse_new = function(arg0) {
         const ret = ExecutionResponse.__wrap(arg0);
@@ -4185,6 +6016,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_d4638f722068f043 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_module = function() {
         const ret = __wbg_init.__wbindgen_wasm_module;
         return addHeapObject(ret);
@@ -4193,10 +6028,14 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_4026f00664f3193f = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_bf2b4274ab1ad344 = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_keypair_new = function(arg0) {
+        const ret = KeyPair.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_cb_drop = function(arg0) {
         const obj = takeObject(arg0).original;
         if (obj.cnt-- == 1) {
@@ -4226,6 +6065,70 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
+    imports.wbg.__wbg_plaintext_new = function(arg0) {
+        const ret = Plaintext.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_field_new = function(arg0) {
+        const ret = Field.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_ciphertext_new = function(arg0) {
+        const ret = Ciphertext.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_bigint_from_i128 = function(arg0, arg1) {
+        const ret = arg0 << BigInt(64) | BigInt.asUintN(64, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_bigint_from_u128 = function(arg0, arg1) {
+        const ret = BigInt.asUintN(64, arg0) << BigInt(64) | BigInt.asUintN(64, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_recordciphertext_new = function(arg0) {
+        const ret = RecordCiphertext.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_recordplaintext_new = function(arg0) {
+        const ret = RecordPlaintext.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_group_new = function(arg0) {
+        const ret = Group.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_verifyingkey_new = function(arg0) {
+        const ret = VerifyingKey.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_address_new = function(arg0) {
+        const ret = Address.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_signature_new = function(arg0) {
+        const ret = Signature.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_transition_new = function(arg0) {
+        const ret = Transition.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
         try {
             var state0 = {a: arg0, b: arg1};
@@ -4233,7 +6136,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_282(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_419(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -4244,10 +6147,6 @@ function __wbg_get_imports() {
             state0.a = state0.b = 0;
         }
     };
-    imports.wbg.__wbindgen_number_new = function(arg0) {
-        const ret = arg0;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
         const ret = new Error();
         return addHeapObject(ret);
@@ -4270,14 +6169,6 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
-    imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
-        const ret = getObject(arg0).buffer;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
-        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_randomFillSync_5c9c955aa56b6049 = function() { return handleError(function (arg0, arg1) {
         getObject(arg0).randomFillSync(takeObject(arg1));
     }, arguments) };
@@ -4461,12 +6352,12 @@ function __wbg_get_imports() {
         getInt32Memory0()[arg0 / 4 + 1] = len1;
         getInt32Memory0()[arg0 / 4 + 0] = ptr1;
     }, arguments) };
-    imports.wbg.__wbindgen_closure_wrapper5994 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 622, __wbg_adapter_34);
+    imports.wbg.__wbindgen_closure_wrapper6326 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 624, __wbg_adapter_40);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper6020 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 622, __wbg_adapter_34);
+    imports.wbg.__wbindgen_closure_wrapper6352 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 624, __wbg_adapter_40);
         return addHeapObject(ret);
     };
 
@@ -4524,12 +6415,17 @@ async function __wbg_init(input, maybe_memory) {
 var exports = /*#__PURE__*/Object.freeze({
     __proto__: null,
     Address: Address,
+    Ciphertext: Ciphertext,
+    ComputeKey: ComputeKey,
     Execution: Execution,
     ExecutionResponse: ExecutionResponse,
     Field: Field,
+    GraphKey: GraphKey,
+    Group: Group,
     KeyPair: KeyPair,
     Metadata: Metadata,
     OfflineQuery: OfflineQuery,
+    Plaintext: Plaintext,
     PrivateKey: PrivateKey,
     PrivateKeyCiphertext: PrivateKeyCiphertext,
     Program: Program,
@@ -4537,8 +6433,10 @@ var exports = /*#__PURE__*/Object.freeze({
     ProvingKey: ProvingKey,
     RecordCiphertext: RecordCiphertext,
     RecordPlaintext: RecordPlaintext,
+    Scalar: Scalar,
     Signature: Signature,
     Transaction: Transaction,
+    Transition: Transition,
     VerifyingKey: VerifyingKey,
     ViewKey: ViewKey,
     default: __wbg_init,