@provablehq/wasm 0.9.10-testnet-rc → 0.9.11

package/dist/mainnet/aleo_wasm.d.ts

@@ -19,7 +19,7 @@ export function verifyFunctionExecution(execution: Execution, verifying_key: Ver
 /**
  * Set test consensus version heights for testing.
  *
- * @params {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.
+ * @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;
@@ -156,6 +156,12 @@ export class Authorization {
    * @param {Uint8Array} bytes Left-endian bytes representing the Authorization.
    */
   static fromBytesLe(bytes: Uint8Array): Authorization;
+  /**
+   * Get the function name.
+   *
+   * @returns {string} The function name.
+   */
+  functionName(): string;
   /**
    * Returns `true` if the Authorization is for `credits.aleo/fee_public`.
    */
@@ -2331,26 +2337,31 @@ export class ProgramManager {
    * @returns {u64} Fee in microcredits
    */
   static estimateFinalizeFee(program: string, _function: string): bigint;
+  /**
+   * Execute an authorization.
+   *
+   * @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.
+   */
+  static executeAuthorization(authorization: Authorization, fee_authorization: Authorization | null | undefined, program: string, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, imports?: object | null, url?: string | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
   /**
    * 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.
    *
-   * 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 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 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
+   * @param edition {
    * @returns {u64} Fee in microcredits
    */
-  static estimateExecutionFee(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, url?: string | null, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null, edition?: number | null): Promise<bigint>;
+  static estimateExecutionFee(program: string, _function: string, imports?: object | null, edition?: number | null): bigint;
   /**
    * Execute an arbitrary function locally
    *
@@ -2372,6 +2383,20 @@ export class ProgramManager {
    * @param {VerifyingKey | undefined} verifying_key (optional) Provide a verifying key to use for the function execution
    */
   static executeFunctionOffline(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, prove_execution: boolean, cache: boolean, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, url?: string | null, offline_query?: OfflineQuery | null, edition?: number | null): Promise<ExecutionResponse>;
+  /**
+   * 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
+   */
+  static estimateFeeForAuthorization(authorization: Authorization, program: string, imports?: object | null, edition?: number | null): bigint;
   /**
    * Execute Aleo function and create an Aleo execution transaction
    *

package/dist/mainnet/index.js

@@ -267,7 +267,7 @@ function verifyFunctionExecution(execution, verifying_key, program, function_id,
 /**
  * Set test consensus version heights for testing.
  *
- * @params {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.
+ * @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;
@@ -307,7 +307,7 @@ function __wbg_adapter_40(arg0, arg1, arg2) {
     wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wbg_adapter_867(arg0, arg1, arg2, arg3) {
+function __wbg_adapter_870(arg0, arg1, arg2, arg3) {
     wasm.__wbindgen_export_7(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
@@ -686,6 +686,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}
@@ -7859,43 +7889,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.
-     *
-     * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network
+     * Execute an authorization.
      *
-     * @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);
@@ -7907,13 +7930,62 @@ 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 {bigint}
+     */
+    static estimateExecutionFee(program, _function, imports, edition) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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;
+            wasm.programmanager_estimateExecutionFee(retptr, ptr0, len0, ptr1, len1, isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(edition) ? 0xFFFFFF : edition);
+            var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            return BigInt.asUintN(64, r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Execute an arbitrary function locally
      *
@@ -7973,6 +8045,42 @@ 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 {bigint}
+     */
+    static estimateFeeForAuthorization(authorization, program, imports, edition) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(authorization, Authorization);
+            const ptr0 = passStringToWasm0(program, wasm.__wbindgen_export_3, wasm.__wbindgen_export_4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.programmanager_estimateFeeForAuthorization(retptr, authorization.__wbg_ptr, ptr0, len0, isLikeNone(imports) ? 0 : addHeapObject(imports), isLikeNone(edition) ? 0xFFFFFF : edition);
+            var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            return BigInt.asUintN(64, r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Execute Aleo function and create an Aleo execution transaction
      *
@@ -13144,7 +13252,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_bac25b70f2db29a3 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_bf427d7de6a9bf32 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
@@ -13162,7 +13270,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_867(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_870(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -13349,7 +13457,7 @@ function __wbg_get_imports() {
         const ret = Signature.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_spawnWorker_231c975bbb3598af = function(arg0, arg1, arg2, arg3) {
+    imports.wbg.__wbg_spawnWorker_dbf0b39172b37e8e = function(arg0, arg1, arg2, arg3) {
         const ret = spawnWorker(getObject(arg0), getObject(arg1), getObject(arg2), arg3 >>> 0);
         return addHeapObject(ret);
     };
@@ -13469,11 +13577,11 @@ function __wbg_get_imports() {
         const ret = false;
         return ret;
     };
-    imports.wbg.__wbindgen_closure_wrapper7347 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper7380 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 548, __wbg_adapter_40);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper7352 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper7385 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 548, __wbg_adapter_40);
         return addHeapObject(ret);
     };