@provablehq/wasm 0.9.9 → 0.9.10

package/dist/testnet/worker.js

@@ -264,6 +264,26 @@ function verifyFunctionExecution(execution, verifying_key, program, function_id,
     }
 }
 
+/**
+ * Set test consensus version heights for testing.
+ *
+ * @param {string | undefined} heights The block heights at which each consensus version applies. This input should be a simple csv list of block heights and there should be one number for each consensus version. If left undefined, the default test heights will be applied.
+ *
+ * @example
+ * import { getOrInitConsensusVersionHeights } from @provablehq/sdk;
+ *
+ * Set the consensus version heights.
+ * getOrInitConsensusVersionTestHeights("0,1,2,3,4,5,6,7,8,9");
+ * @param {string | null} [heights]
+ * @returns {Array<any>}
+ */
+function getOrInitConsensusVersionTestHeights(heights) {
+    var ptr0 = isLikeNone(heights) ? 0 : passStringToWasm0(heights, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.getOrInitConsensusVersionTestHeights(ptr0, len0);
+    return takeObject(ret);
+}
+
 function passArrayJsValueToWasm0(array, malloc) {
     const ptr = malloc(array.length * 4, 4) >>> 0;
     const mem = getDataViewMemory0();
@@ -283,12 +303,16 @@ function getArrayJsValueFromWasm0(ptr, len) {
     }
     return result;
 }
-function __wbg_adapter_40(arg0, arg1, arg2) {
-    wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
+function __wbg_adapter_40(arg0, arg1) {
+    wasm.__wbindgen_export_6(arg0, arg1);
+}
+
+function __wbg_adapter_43(arg0, arg1, arg2) {
+    wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_859(arg0, arg1, arg2, arg3) {
-    wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wbg_adapter_873(arg0, arg1, arg2, arg3) {
+    wasm.__wbindgen_export_8(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
@@ -666,6 +690,36 @@ class Authorization {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get the function name.
+     *
+     * @returns {string} The function name.
+     * @returns {string}
+     */
+    functionName() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.authorization_functionName(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);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_2(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Returns `true` if the Authorization is for `credits.aleo/fee_public`.
      * @returns {boolean}
@@ -2996,6 +3050,17 @@ class Field {
             heap[stack_pointer++] = undefined;
         }
     }
+    /**
+     * Initializes a new field as a domain separator.
+     * @param {string} domain
+     * @returns {Field}
+     */
+    static newDomainSeparator(domain) {
+        const ptr0 = passStringToWasm0(domain, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.field_newDomainSeparator(ptr0, len0);
+        return Field.__wrap(ret);
+    }
     /**
      * Add two field elements.
      * @param {Field} other
@@ -5895,9 +5960,9 @@ class Plaintext {
         wasm.__wbg_plaintext_free(ptr, 0);
     }
     /**
-     * Get the left endian boolean array representation of the bits of the plaintext.
+     * Get the little endian boolean array representation of the bits of the plaintext.
      *
-     * @returns {Array} The left endian boolean array representation of the bits of the plaintext.
+     * @returns {Array} The little endian boolean array representation of the bits of the plaintext.
      * @returns {Array<any>}
      */
     toBitsLe() {
@@ -5955,9 +6020,9 @@ class Plaintext {
         }
     }
     /**
-     * Get the left endian byte array representation of the plaintext.
+     * Get the little endian byte array representation of the plaintext.
      *
-     * @returns {Uint8Array} The left endian byte array representation of the plaintext.
+     * @returns {Uint8Array} The little endian byte array representation of the plaintext.
      * @returns {Uint8Array}
      */
     toBytesLe() {
@@ -5978,7 +6043,7 @@ class Plaintext {
     /**
      * Get a plaintext object from a series of bits represented as a boolean array.
      *
-     * @param {Array} bits A left endian boolean array representing the bits plaintext.
+     * @param {Array} bits A little endian boolean array representing the bits plaintext.
      *
      * @returns {Plaintext} The plaintext object.
      * @param {Array<any>} bits
@@ -6002,7 +6067,7 @@ class Plaintext {
     /**
      * Get a plaintext object from a series of bytes.
      *
-     * @param {Uint8Array} bytes A left endian byte array representing the plaintext.
+     * @param {Uint8Array} bytes A little endian byte array representing the plaintext.
      *
      * @returns {Plaintext} The plaintext object.
      * @param {Uint8Array} bytes
@@ -6023,6 +6088,27 @@ class Plaintext {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Get the raw field array representation of the plaintext.
+     *
+     * @returns {Array} The raw field array representation of the plaintext.
+     * @returns {Array<any>}
+     */
+    toFieldsRaw() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toFieldsRaw(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);
+        }
+    }
     /**
      * Gives the type of the plaintext.
      *
@@ -6045,6 +6131,68 @@ class Plaintext {
             wasm.__wbindgen_export_2(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Get the raw big endian boolean array representation of the bits of the plaintext.
+     *
+     * @returns {Array} The raw big endian boolean array representation of the bits of the plaintext.
+     * @returns {Array<any>}
+     */
+    toBitsRawBe() {
+        const ret = wasm.plaintext_toBitsRawBe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the raw little endian boolean array representation of the bits of the plaintext.
+     *
+     * @returns {Array} The raw little endian boolean array representation of the bits of the plaintext.
+     * @returns {Array<any>}
+     */
+    toBitsRawLe() {
+        const ret = wasm.plaintext_toBitsRawLe(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get the raw big endian byte array representation of the plaintext.
+     *
+     * @returns {Uint8Array} The raw big endian byte array representation of the plaintext.
+     * @returns {Uint8Array}
+     */
+    toBytesRawBe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toBytesRawBe(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);
+        }
+    }
+    /**
+     * Get the raw little endian byte array representation of the plaintext.
+     *
+     * @returns {Uint8Array} The raw little endian byte array representation of the plaintext.
+     * @returns {Uint8Array}
+     */
+    toBytesRawLe() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.plaintext_toBytesRawLe(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);
+        }
+    }
     /**
      * Encrypt a plaintext with a transition view key.
      *
@@ -7419,10 +7567,10 @@ class ProgramManager {
     /**
      * Synthesize proving and verifying keys for a program
      *
-     * @param program {string} The program source code of the program to synthesize keys for
-     * @param function_id {string} The function to synthesize keys for
-     * @param inputs {Array} The inputs to the function
-     * @param imports {Object | undefined} The imports for the program
+     * @param {string} program The program source code of the program to synthesize keys for
+     * @param {string} function_id The function to synthesize keys for
+     * @param {Array} inputs The inputs to the function
+     * @param {Object | undefined} imports The imports for the program
      * @param {PrivateKey} private_key
      * @param {string} program
      * @param {string} function_id
@@ -7440,6 +7588,14 @@ class ProgramManager {
         const ret = wasm.programmanager_synthesizeKeyPair(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(edition) ? 0xFFFFFF : edition);
         return takeObject(ret);
     }
+    /**
+     * @param {ProvingKey} proving_key
+     */
+    static loadInclusionProver(proving_key) {
+        _assertClass(proving_key, ProvingKey);
+        var ptr0 = proving_key.__destroy_into_raw();
+        wasm.programmanager_loadInclusionProver(ptr0);
+    }
     /**
      * Create a `ProvingRequest` object. This object creates authorizations for the top level
      * function and associated fee function. This object can be sent directly to a remote prover
@@ -7737,43 +7893,36 @@ class ProgramManager {
         }
     }
     /**
-     * Estimate Fee for Aleo function execution. Note if "cache" is set to true, the proving and
-     * verifying keys will be stored in the ProgramManager's memory and used for subsequent
-     * program executions.
+     * Execute an authorization.
      *
-     * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
-     *
-     * @param private_key The private key of the sender
-     * @param program The source code of the program to estimate the execution fee for
-     * @param function The name of the function to execute
-     * @param inputs A javascript array of inputs to the function
-     * @param url The url of the Aleo network node to send the transaction to
-     * @param imports (optional) Provide a list of imports to use for the fee estimation in the
-     * form of a javascript object where the keys are a string of the program name and the values
-     * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
-     * @param proving_key (optional) Provide a verifying key to use for the fee estimation
-     * @param verifying_key (optional) Provide a verifying key to use for the fee estimation
-     * @returns {u64} Fee in microcredits
-     * @param {PrivateKey} private_key
+     * @param authorization The authorization to execute.
+     * @param fee_authorization The fee authorization to execute.
+     * @param program The program authorized to be executed.
+     * @param imports The imports of the program being executed.
+     * @param url The url to get the inclusion proving information from.
+     * @param offline_query Optional offline query object if building a Transaction offline.
+     * @param {Authorization} authorization
+     * @param {Authorization | null | undefined} fee_authorization
      * @param {string} program
-     * @param {string} _function
-     * @param {Array<any>} inputs
-     * @param {string | null} [url]
-     * @param {object | null} [imports]
      * @param {ProvingKey | null} [proving_key]
      * @param {VerifyingKey | null} [verifying_key]
+     * @param {ProvingKey | null} [fee_proving_key]
+     * @param {VerifyingKey | null} [fee_verifying_key]
+     * @param {object | null} [imports]
+     * @param {string | null} [url]
      * @param {OfflineQuery | null} [offline_query]
-     * @param {number | null} [edition]
-     * @returns {Promise<bigint>}
+     * @returns {Promise<Transaction>}
      */
-    static estimateExecutionFee(private_key, program, _function, inputs, url, imports, proving_key, verifying_key, offline_query, edition) {
-        _assertClass(private_key, PrivateKey);
-        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        const len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
-        var len2 = WASM_VECTOR_LEN;
+    static executeAuthorization(authorization, fee_authorization, program, proving_key, verifying_key, fee_proving_key, fee_verifying_key, imports, url, offline_query) {
+        _assertClass(authorization, Authorization);
+        var ptr0 = authorization.__destroy_into_raw();
+        let ptr1 = 0;
+        if (!isLikeNone(fee_authorization)) {
+            _assertClass(fee_authorization, Authorization);
+            ptr1 = fee_authorization.__destroy_into_raw();
+        }
+        const ptr2 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len2 = WASM_VECTOR_LEN;
         let ptr3 = 0;
         if (!isLikeNone(proving_key)) {
             _assertClass(proving_key, ProvingKey);
@@ -7785,11 +7934,49 @@ class ProgramManager {
             ptr4 = verifying_key.__destroy_into_raw();
         }
         let ptr5 = 0;
+        if (!isLikeNone(fee_proving_key)) {
+            _assertClass(fee_proving_key, ProvingKey);
+            ptr5 = fee_proving_key.__destroy_into_raw();
+        }
+        let ptr6 = 0;
+        if (!isLikeNone(fee_verifying_key)) {
+            _assertClass(fee_verifying_key, VerifyingKey);
+            ptr6 = fee_verifying_key.__destroy_into_raw();
+        }
+        var ptr7 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        var len7 = WASM_VECTOR_LEN;
+        let ptr8 = 0;
         if (!isLikeNone(offline_query)) {
             _assertClass(offline_query, OfflineQuery);
-            ptr5 = offline_query.__destroy_into_raw();
+            ptr8 = offline_query.__destroy_into_raw();
         }
-        const ret = wasm.programmanager_estimateExecutionFee(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), ptr2, len2, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr3, ptr4, ptr5, isLikeNone(edition) ? 0xFFFFFF : edition);
+        const ret = wasm.programmanager_executeAuthorization(ptr0, ptr1, ptr2, len2, ptr3, ptr4, ptr5, ptr6, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr7, len7, ptr8);
+        return takeObject(ret);
+    }
+    /**
+     * Estimate Fee for Aleo function execution. Note if "cache" is set to true, the proving and
+     * verifying keys will be stored in the ProgramManager's memory and used for subsequent
+     * program executions.
+     *
+     * @param program The source code of the program to estimate the execution fee for.
+     * @param function The name of the function to estimate the execution fee for.
+     * @param imports (optional) Provide a list of imports to use for the fee estimation in the
+     * form of a javascript object where the keys are a string of the program name and the values
+     * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
+     * @param edition {
+     * @returns {u64} Fee in microcredits
+     * @param {string} program
+     * @param {string} _function
+     * @param {object | null} [imports]
+     * @param {number | null} [edition]
+     * @returns {Promise<bigint>}
+     */
+    static estimateExecutionFee(program, _function, imports, edition) {
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(_function, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_estimateExecutionFee(ptr0, len0, ptr1, len1, isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(edition) ? 0xFFFFFF : edition);
         return takeObject(ret);
     }
     /**
@@ -7851,6 +8038,31 @@ class ProgramManager {
         const ret = wasm.programmanager_executeFunctionOffline(private_key.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(inputs), prove_execution, cache, isLikeNone(imports) ? 0 : addHeapObject(imports), ptr2, ptr3, ptr4, len4, ptr5, isLikeNone(edition) ? 0xFFFFFF : edition);
         return takeObject(ret);
     }
+    /**
+     * Estimate Fee for an Authorization.
+     *
+     * @param authorization Authorization to estimate the fee for.
+     * @param program The program the Authorization is for.
+     * @param imports Provide a list of imports to use for the fee estimation in the
+     * form of a javascript object where the keys are a string of the program name and the values
+     * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
+     * @param offline_query The offline query object used to insert the global state root and state paths needed to create
+     * a valid inclusion proof offline.
+     * @param edition: Optional edition to estimate the fee for.
+     * @returns {u64} Fee in microcredits
+     * @param {Authorization} authorization
+     * @param {string} program
+     * @param {object | null} [imports]
+     * @param {number | null} [edition]
+     * @returns {Promise<bigint>}
+     */
+    static estimateFeeForAuthorization(authorization, program, imports, edition) {
+        _assertClass(authorization, Authorization);
+        const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.programmanager_estimateFeeForAuthorization(authorization.__wbg_ptr, ptr0, len0, isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(edition) ? 0xFFFFFF : edition);
+        return takeObject(ret);
+    }
     /**
      * Execute Aleo function and create an Aleo execution transaction
      *
@@ -12888,6 +13100,9 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg_abort_410ec47a64ac6117 = function(arg0, arg1) {
+        getObject(arg0).abort(getObject(arg1));
+    };
     imports.wbg.__wbg_abort_775ef1d17fc65868 = function(arg0) {
         getObject(arg0).abort();
     };
@@ -12926,6 +13141,10 @@ function __wbg_get_imports() {
         const ret = Ciphertext.__wrap(arg0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_clearTimeout_86721db0036bea98 = function(arg0) {
+        const ret = clearTimeout(takeObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
         const ret = getObject(arg0).crypto;
         return addHeapObject(ret);
@@ -12957,6 +13176,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).fetch(getObject(arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_fetch_d36a73832f0a45e8 = function(arg0) {
+        const ret = fetch(getObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_fetch_f1856afdb49415d1 = function(arg0) {
         const ret = fetch(getObject(arg0));
         return addHeapObject(ret);
@@ -13022,7 +13245,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_95e0b7e090d013b6 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_3d00345a85838c37 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
@@ -13040,7 +13263,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_859(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_873(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -13188,6 +13411,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_send_40a47636ff90f64d = function() { return handleError(function (arg0) {
         getObject(arg0).send();
     }, arguments) };
+    imports.wbg.__wbg_setTimeout_2e707715f8cc9497 = function(arg0, arg1) {
+        const ret = setTimeout(getObject(arg0), arg1);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
@@ -13227,7 +13454,7 @@ function __wbg_get_imports() {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_45047dc45447b7dc = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_11a3cff24c5879d7 = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -13347,12 +13574,16 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper6736 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 492, __wbg_adapter_40);
+    imports.wbg.__wbindgen_closure_wrapper7305 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 533, __wbg_adapter_40);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_closure_wrapper7964 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 533, __wbg_adapter_43);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper6741 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 492, __wbg_adapter_40);
+    imports.wbg.__wbindgen_closure_wrapper7968 = function(arg0, arg1, arg2) {
+        const ret = makeMutClosure(arg0, arg1, 533, __wbg_adapter_43);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_is_function = function(arg0) {
@@ -13428,7 +13659,7 @@ function __wbg_get_imports() {
 }
 
 function __wbg_init_memory(imports, memory) {
-    imports.wbg.memory = memory || new WebAssembly.Memory({initial:23,maximum:65536,shared:true});
+    imports.wbg.memory = memory || new WebAssembly.Memory({initial:167,maximum:65536,shared:true});
 }
 
 function __wbg_finalize_init(instance, module, thread_stack_size) {
@@ -13545,6 +13776,7 @@ var exports = /*#__PURE__*/Object.freeze({
     VerifyingKey: VerifyingKey,
     ViewKey: ViewKey,
     default: __wbg_init,
+    getOrInitConsensusVersionTestHeights: getOrInitConsensusVersionTestHeights,
     initSync: initSync,
     initThreadPool: initThreadPool,
     runRayonThread: runRayonThread,