@provablehq/wasm 0.10.5 → 0.11.0

package/dist/mainnet/aleo_wasm.d.ts

@@ -1,19 +1,14 @@
 /* tslint:disable */
 /* eslint-disable */
 export function runRayonThread(receiver: number): void;
-export function initThreadPool(url: URL, num_threads: number): Promise<void>;
 /**
- * Verify a SNARK proof against a verifying key and public inputs.
- *
- * This function verifies a proof produced by an Aleo program that may not be deployed on chain.
- * It directly invokes the Varuna proof verification from snarkVM.
- *
- * @param {VerifyingKey} verifying_key The verifying key for the circuit
- * @param {Array<string>} inputs Array of field element strings representing public inputs (e.g. ["1field", "2field"])
- * @param {Proof} proof The proof to verify
- * @returns {boolean} True if the proof is valid, false otherwise
+ * Set the WASM log level from JS. Called automatically by the SDK's
+ * `setLogLevel(level)` to keep TS and WASM logging in sync.
+ * Levels: 0=silent, 1=error, 2=warn, 3=info (default), 4=debug.
+ * Values above 4 are clamped to debug.
  */
-export function snarkVerify(verifying_key: VerifyingKey, inputs: Array<any>, proof: Proof): boolean;
+export function setWasmLogLevel(level: number): void;
+export function initThreadPool(url: URL, num_threads: number): Promise<void>;
 /**
  * Verify an execution. Executions with multiple transitions must have the program source code and
  * verifying keys of imported functions supplied from outside to correctly verify. Also, this does
@@ -27,7 +22,19 @@ export function snarkVerify(verifying_key: VerifyingKey, inputs: Array<any>, pro
  * @param {Object} import_verifying_keys The verifying keys for the imports in the form of { "program_id.aleo": [["function, "verifying_key"], ...],  ...}
  * @returns {boolean} True if the execution is valid, false otherwise
  */
-export function verifyFunctionExecution(execution: Execution, verifying_key: VerifyingKey, program: Program, function_id: string, imports: object | null | undefined, imported_verifying_keys: object | null | undefined, block_height: number): boolean;
+export function verifyFunctionExecution(execution: Execution, verifying_key: VerifyingKey, program: Program, function_id: string, imports: object | null | undefined, imported_verifying_keys: object | null | undefined, block_height: number, program_imports?: ProgramImports | null): boolean;
+/**
+ * Verify a SNARK proof against a verifying key and public inputs.
+ *
+ * This function verifies a proof produced by an Aleo program that may not be deployed on chain.
+ * It directly invokes the Varuna proof verification from snarkVM.
+ *
+ * @param {VerifyingKey} verifying_key The verifying key for the circuit
+ * @param {Array<string>} inputs Array of field element strings representing public inputs (e.g. ["1field", "2field"])
+ * @param {Proof} proof The proof to verify
+ * @returns {boolean} True if the proof is valid, false otherwise
+ */
+export function snarkVerify(verifying_key: VerifyingKey, inputs: Array<any>, proof: Proof): boolean;
 /**
  * Verify a batch SNARK proof against multiple verifying keys and their corresponding public inputs.
  *
@@ -40,7 +47,6 @@ export function verifyFunctionExecution(execution: Execution, verifying_key: Ver
  * @returns {boolean} True if the batch proof is valid, false otherwise
  */
 export function snarkVerifyBatch(verifying_keys: Array<any>, inputs: Array<any>, proof: Proof): boolean;
-export function stringToField(string: string): Field;
 /**
  * Set test consensus version heights for testing.
  *
@@ -53,6 +59,7 @@ export function stringToField(string: string): Field;
  * getOrInitConsensusVersionTestHeights("0,1,2,3,4,5,6,7,8,9,10,11,12,13");
  */
 export function getOrInitConsensusVersionTestHeights(heights?: string | null): Array<any>;
+export function stringToField(string: string): Field;
 /**
  * Public address of an Aleo account
  */
@@ -2887,6 +2894,18 @@ export class Program {
    * console.log(credits_functions === expected_functions); // Output should be "true"
    */
   getFunctions(): Array<any>;
+  /**
+   * Get the external call graph reachable from a specific entry function.
+   *
+   * Starting from `entry_function`, traces all reachable functions and closures
+   * within this program (via local calls) and collects external calls
+   * (`call program.aleo/function`). Returns a JS object mapping program names
+   * to arrays of called function names.
+   *
+   * @param {string} entry_function The name of the entry function to trace from
+   * @returns {object} An object like `{ "program.aleo": ["fn1", "fn2"] }`
+   */
+  getCallGraph(entry_function: string): any;
   /**
    * Get a javascript object representation of a program record and its types
    *
@@ -3037,6 +3056,198 @@ export class Program {
    */
   toString(): string;
 }
+/**
+ * Backed by `Rc<RefCell<>>` for interior mutability — cloning produces a cheap
+ * reference-counted copy that shares the same underlying data. This allows
+ * execution functions to clone the builder internally while the caller's
+ * original reference automatically sees any mutations (e.g. synthesized keys).
+ */
+export class ProgramImports {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Add a program's source code to the imports.
+   *
+   * The source is parsed, validated, and added to the internal Process.
+   * Static imports of the program are resolved depth-first from programs
+   * already present in this builder.
+   *
+   * @param {string} name The program name (e.g., "my_program.aleo").
+   * @param {string} source The program source code.
+   * @param {number | undefined} edition The program edition (defaults to 1).
+   */
+  addProgram(name: string, source: string, edition?: number | null): void;
+  /**
+   * Create a ProgramImports from a plain JavaScript object.
+   *
+   * Accepts three formats:
+   * ```js
+   * // 1. Plain string — source code only.
+   * { "my_program.aleo": "program source..." }
+   *
+   * // 2. Structured — program source with optional edition.
+   * { "my_program.aleo": { program: "program source..." } }
+   *
+   * // 3. Structured with keys — program source plus proving/verifying keys per function.
+   * {
+   *   "my_program.aleo": {
+   *     program: "program source...",
+   *     keys: {
+   *       "my_function": {
+   *         provingKey: Uint8Array,
+   *         verifyingKey: Uint8Array
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * Programs created via this method default to edition 1.
+   *
+   * @param {Object} object A plain JavaScript object mapping program names to source code
+   *   and optional keys.
+   * @returns {ProgramImports}
+   */
+  static fromObject(object: object): ProgramImports;
+  /**
+   * Return the source code of a program by name, without serializing keys.
+   *
+   * @param {string} name The program name (e.g., "my_program.aleo").
+   * @returns {string | undefined}
+   */
+  getProgram(name: string): string | undefined;
+  /**
+   * Return the names of all programs in this builder as a JS `Array<string>`.
+   *
+   * This is a lightweight alternative to `toObject()` when you only need to
+   * enumerate program names without serializing keys.
+   *
+   * @returns {Array<string>}
+   */
+  programNames(): Array<any>;
+  /**
+   * Add a proving key for a function or record within an imported program.
+   *
+   * The key is transferred directly from the WASM `ProvingKey` type with no
+   * serialization overhead.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @param {string} identifier The function name or record name the key belongs to.
+   * @param {ProvingKey} key The proving key.
+   */
+  addProvingKey(program_name: string, identifier: string, key: ProvingKey): void;
+  /**
+   * Get a proving key for a specific program and identifier (function or record name).
+   * Returns a clone of the key from the internal Process. Non-destructive — the key
+   * remains available for future calls.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @param {string} identifier The function or record name.
+   * @returns {ProvingKey | undefined}
+   */
+  getProvingKey(program_name: string, identifier: string): ProvingKey | undefined;
+  /**
+   * Add a verifying key for a function or record within an imported program.
+   *
+   * The key is transferred directly from the WASM `VerifyingKey` type with no
+   * serialization overhead.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @param {string} identifier The function name or record name the key belongs to.
+   * @param {VerifyingKey} key The verifying key.
+   */
+  addVerifyingKey(program_name: string, identifier: string, key: VerifyingKey): void;
+  /**
+   * Get a verifying key for a specific program and identifier (function or record name).
+   * Returns a clone of the key from the internal Process. Non-destructive — the key
+   * remains available for future calls.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @param {string} identifier The function or record name.
+   * @returns {VerifyingKey | undefined}
+   */
+  getVerifyingKey(program_name: string, identifier: string): VerifyingKey | undefined;
+  /**
+   * Add a proving key from its byte representation.
+   *
+   * Deserializes the bytes into a native proving key and stores it. The program
+   * must already have been added via `addProgram`.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @param {string} identifier The function name or record name the key belongs to.
+   * @param {Uint8Array} bytes The proving key bytes.
+   */
+  addProvingKeyBytes(program_name: string, identifier: string, bytes: Uint8Array): void;
+  /**
+   * Add a verifying key from its byte representation.
+   *
+   * Deserializes the bytes into a native verifying key and stores it. The program
+   * must already have been added via `addProgram`.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @param {string} identifier The function name or record name the key belongs to.
+   * @param {Uint8Array} bytes The verifying key bytes.
+   */
+  addVerifyingKeyBytes(program_name: string, identifier: string, bytes: Uint8Array): void;
+  /**
+   * Return the names of functions that have both a proving key and a verifying key
+   * stored for the given program.
+   *
+   * @param {string} program_name The program name (e.g., "my_program.aleo").
+   * @returns {Array<string>}
+   */
+  functionKeysAvailable(program_name: string): Array<any>;
+  /**
+   * Create a new empty ProgramImports builder.
+   *
+   * Initializes an internal snarkVM Process. This is the same cost as a
+   * single execution call, but is paid once and reused across all operations.
+   */
+  constructor();
+  /**
+   * Create a cheap clone that shares the same underlying data.
+   *
+   * Useful for passing to WASM execution functions which consume ownership:
+   * the caller keeps the original, and both copies see any mutations
+   * (e.g. synthesized keys) through the shared interior state.
+   */
+  clone(): ProgramImports;
+  /**
+   * Check whether a specific program has been added.
+   *
+   * @param {string} name The program name.
+   * @returns {boolean}
+   */
+  contains(name: string): boolean;
+  /**
+   * Check whether any programs have been added to this builder.
+   *
+   * @returns {boolean}
+   */
+  isEmpty(): boolean;
+  /**
+   * Convert this ProgramImports to a plain JavaScript object.
+   *
+   * Entries without keys use the simple `{ "name.aleo": "source" }` format.
+   * Entries with keys use the structured format:
+   * ```js
+   * {
+   *   "name.aleo": {
+   *     program: "program source...",
+   *     keys: {
+   *       "function_name": {
+   *         provingKey: Uint8Array,
+   *         verifyingKey: Uint8Array
+   *       }
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @returns {Object}
+   */
+  toObject(): object;
+}
 export class ProgramManager {
   private constructor();
   free(): void;
@@ -3049,7 +3260,7 @@ export class ProgramManager {
    * @param {Array} inputs The inputs to the function
    * @param {Object | undefined} imports The imports for the program
    */
-  static synthesizeKeyPair(private_key: PrivateKey, program: string, function_id: string, inputs: Array<any>, imports?: object | null, edition?: number | null): Promise<KeyPair>;
+  static synthesizeKeyPair(private_key: PrivateKey, program: string, function_id: string, inputs: Array<any>, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise<KeyPair>;
   static loadInclusionProver(proving_key: ProvingKey): void;
   /**
    * Create a `ProvingRequest` object. This object creates authorizations for the top level
@@ -3068,7 +3279,7 @@ export class ProgramManager {
    * @param broadcast (optional) Flag to indicate if the transaction should be broadcast
    * @returns {Authorization}
    */
-  static buildProvingRequest(private_key: PrivateKey, program: string, function_name: string, inputs: Array<any>, base_fee_credits: number, priority_fee_credits: number, fee_record: RecordPlaintext | null | undefined, imports: object | null | undefined, broadcast: boolean, unchecked: boolean, edition: number | null | undefined, use_fee_master: boolean): Promise<ProvingRequest>;
+  static buildProvingRequest(private_key: PrivateKey, program: string, function_name: string, inputs: Array<any>, base_fee_credits: number, priority_fee_credits: number, fee_record: RecordPlaintext | null | undefined, imports: object | null | undefined, broadcast: boolean, unchecked: boolean, edition: number | null | undefined, use_fee_master: boolean, program_imports?: ProgramImports | null): Promise<ProvingRequest>;
   /**
    * Build a proving request from a `Request` object. By default this method currently uses the feemaster.
    *
@@ -3080,7 +3291,7 @@ export class ProgramManager {
    * @param {object | undefined} imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
    * @param {PrivateKey | undefined} [private_key] Optional private key of the signer. If not provided, functions which call other programs may not succeed.
    */
-  static buildProvingRequestFromExecutionRequest(request: ExecutionRequest, program: string, unchecked: boolean, broadcast: boolean, edition?: number | null, imports?: object | null, private_key?: PrivateKey | null): Promise<ProvingRequest>;
+  static buildProvingRequestFromExecutionRequest(request: ExecutionRequest, program: string, unchecked: boolean, broadcast: boolean, edition?: number | null, imports?: object | null, private_key?: PrivateKey | null, program_imports?: ProgramImports | null): Promise<ProvingRequest>;
   /**
    * Join two records together to create a new record with an amount of credits equal to the sum
    * of the credits of the two original records
@@ -3131,7 +3342,7 @@ export class ProgramManager {
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @returns {Transaction}
    */
-  static buildDevnodeDeploymentTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null): Promise<Transaction>;
+  static buildDevnodeDeploymentTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, program_imports?: ProgramImports | null): Promise<Transaction>;
   /**
    * Upgrade a deployed Aleo program without synthesizing keys and generating certificates.
    * Intended for use with Leo Devnode.
@@ -3152,7 +3363,7 @@ export class ProgramManager {
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @returns {Transaction}
    */
-  static buildDevnodeUpgradeTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null): Promise<Transaction>;
+  static buildDevnodeUpgradeTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, program_imports?: ProgramImports | null): Promise<Transaction>;
   /**
    * Estimate the component of the deployment cost which comes from the fee for the program name.
    * Note that this cost does not represent the entire cost of deployment. It is additional to
@@ -3175,7 +3386,7 @@ export class ProgramManager {
    * are a string representing the program source code \{ "hello.aleo": "hello.aleo source code" \}
    * @returns {u64}
    */
-  static estimateDeploymentFee(program: string, imports?: object | null): Promise<bigint>;
+  static estimateDeploymentFee(program: string, imports?: object | null, program_imports?: ProgramImports | null): Promise<bigint>;
   /**
    * Deploy an Aleo program
    *
@@ -3195,7 +3406,7 @@ export class ProgramManager {
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @returns {Transaction}
    */
-  static buildDeploymentTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
+  static buildDeploymentTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null, program_imports?: ProgramImports | null): Promise<Transaction>;
   /**
    * Upgrade an Aleo program
    *
@@ -3213,7 +3424,7 @@ export class ProgramManager {
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @returns {Transaction}
    */
-  static buildUpgradeTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null): Promise<Transaction>;
+  static buildUpgradeTransaction(private_key: PrivateKey, program: string, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, offline_query?: OfflineQuery | null, program_imports?: ProgramImports | null): Promise<Transaction>;
   /**
    * Generate an execution transaction without a proof.
    * Intended for use with the Leo devnode tool.
@@ -3225,22 +3436,13 @@ export class ProgramManager {
    * @param priority_fee_credits The optional priority fee to be paid for the transaction
    * @param fee_record The record to spend the fee from
    * @param url The url of the Aleo network node to send the transaction to
-   * If this is set to 'true' the keys synthesized (or passed in as optional parameters via the
-   * `proving_key` and `verifying_key` arguments) will be stored in the ProgramManager's memory
-   * and used for subsequent transactions. If this is set to 'false' the proving and verifying
-   * keys will be deallocated from memory after the transaction is executed.
    * @param imports (optional) Provide a list of imports to use for the function execution 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 function execution
-   * @param verifying_key (optional) Provide a verifying key to use for the function execution
-   * @param fee_proving_key (optional) Provide a proving key to use for the fee execution
-   * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
-   * @param offline_query An offline query object to use if building a transaction without an internet connection.
-   * @param edition The edition of the program to execute. Defaults to the latest found on the network, or 1 if the program does not exist on the network.
+   * @param edition The edition of the program to execute. Defaults to 1.
    * @returns {Transaction}
    */
-  static buildDevnodeExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, edition?: number | null): Promise<Transaction>;
+  static buildDevnodeExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise<Transaction>;
   /**
    * Estimate the finalize fee component for executing a function. This fee is additional to the
    * size of the execution of the program in bytes. If the function does not have a finalize
@@ -3262,22 +3464,21 @@ export class ProgramManager {
    * @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 edition The program edition (defaults to 1).
    */
-  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, query?: QueryOption | null): Promise<Transaction>;
+  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, query?: QueryOption | null, program_imports?: ProgramImports | null, edition?: number | 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.
+   * Estimate Fee for Aleo function execution.
    *
    * @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 {
+   * @param edition The edition of the program. Defaults to 1.
    * @returns {u64} Fee in microcredits
    */
-  static estimateExecutionFee(program: string, _function: string, imports?: object | null, edition?: number | null): bigint;
+  static estimateExecutionFee(program: string, _function: string, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): bigint;
   /**
    * Execute an arbitrary function locally
    *
@@ -3295,10 +3496,10 @@ export class ProgramManager {
    * @param {Object | undefined} imports (optional) Provide a list of imports to use for the function execution 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 {ProvingKey | undefined} proving_key (optional) Provide a verifying key to use for the function execution
+   * @param {ProvingKey | undefined} proving_key (optional) Provide a proving key to use for the function execution
    * @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, query?: QueryOption | null, edition?: number | null): Promise<ExecutionResponse>;
+  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, query?: QueryOption | null, edition?: number | null, program_imports?: ProgramImports | null): Promise<ExecutionResponse>;
   /**
    * Compute the query requirements for a function execution without making
    * any network calls. Returns the commitments that need state paths and
@@ -3329,7 +3530,7 @@ export class ProgramManager {
    * @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;
+  static estimateFeeForAuthorization(authorization: Authorization, program: string, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): bigint;
   /**
    * Execute Aleo function and create an Aleo execution transaction
    *
@@ -3340,22 +3541,18 @@ export class ProgramManager {
    * @param priority_fee_credits The optional priority fee to be paid for the transaction
    * @param fee_record The record to spend the fee from
    * @param url The url of the Aleo network node to send the transaction to
-   * If this is set to 'true' the keys synthesized (or passed in as optional parameters via the
-   * `proving_key` and `verifying_key` arguments) will be stored in the ProgramManager's memory
-   * and used for subsequent transactions. If this is set to 'false' the proving and verifying
-   * keys will be deallocated from memory after the transaction is executed.
    * @param imports (optional) Provide a list of imports to use for the function execution 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 function execution
+   * @param proving_key (optional) Provide a proving key to use for the function execution
    * @param verifying_key (optional) Provide a verifying key to use for the function execution
    * @param fee_proving_key (optional) Provide a proving key to use for the fee execution
    * @param fee_verifying_key (optional) Provide a verifying key to use for the fee execution
    * @param offline_query An offline query object to use if building a transaction without an internet connection.
-   * @param edition The edition of the program to execute. Defaults to the latest found on the network, or 1 if the program does not exist on the network.
+   * @param edition The edition of the program to execute. Defaults to 1.
    * @returns {Transaction}
    */
-  static buildExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null, edition?: number | null): Promise<Transaction>;
+  static buildExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array<any>, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, proving_key?: ProvingKey | null, verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null, edition?: number | null, program_imports?: ProgramImports | null): Promise<Transaction>;
   /**
    * Send credits from one Aleo account to another
    *
@@ -3397,7 +3594,7 @@ export class ProgramManager {
    * @param {object | undefined} imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
    * @param {PrivateKey | undefined} [private_key] Optional private key of the signer. If not provided, functions which call other programs may not succeed.
    */
-  static buildAuthorizationFromExecutionRequest(request: ExecutionRequest, program: string, unchecked: boolean, edition?: number | null, imports?: object | null, private_key?: PrivateKey | null): Promise<Authorization>;
+  static buildAuthorizationFromExecutionRequest(request: ExecutionRequest, program: string, unchecked: boolean, edition?: number | null, imports?: object | null, private_key?: PrivateKey | null, program_imports?: ProgramImports | null): Promise<Authorization>;
   /**
    * Create an execution `Authorization` without generating a circuit. Use this function when
    * fast delegated proving is needed.
@@ -3408,7 +3605,7 @@ export class ProgramManager {
    * @param inputs A javascript array of inputs to the function.
    * @param imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
    */
-  static buildAuthorizationUnchecked(private_key: PrivateKey, program: string, function_name: string, inputs: Array<any>, imports?: object | null, edition?: number | null): Promise<Authorization>;
+  static buildAuthorizationUnchecked(private_key: PrivateKey, program: string, function_name: string, inputs: Array<any>, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise<Authorization>;
   /**
    * Create an execution `Authorization` for a given program:function tuple with specified inputs.
    *
@@ -3418,7 +3615,7 @@ export class ProgramManager {
    * @param inputs A javascript array of inputs to the function.
    * @param imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}.
    */
-  static authorize(private_key: PrivateKey, program: string, function_name: string, inputs: Array<any>, imports?: object | null, edition?: number | null): Promise<Authorization>;
+  static authorize(private_key: PrivateKey, program: string, function_name: string, inputs: Array<any>, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise<Authorization>;
 }
 /**
  * SNARK proof for verification of program execution
@@ -3651,53 +3848,125 @@ export class ProvingKey {
 }
 /**
  * Represents a proving request to a prover.
+ *
+ * Carries one of two variants:
+ * - `Authorization` — a fully-constructed snarkVM `Authorization` (plus optional
+ *   fee authorization). Submitted to `/prove/authorization` (encrypted-only).
+ * - `Request` — a single signed snarkVM `Request` (plus optional fee `Request`)
+ *   that the prover authorizes server-side. Submitted to `/prove/request`
+ *   (encrypted-only).
+ *
+ * Use {@link ProvingRequest#kind} when handling a `ProvingRequest` of unknown
+ * variant (e.g. after deserialization). Variant-specific accessors throw if
+ * called on the wrong variant.
  */
 export class ProvingRequest {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
   /**
-   * Creates a ProvingRequest from a string representation.
+   * Returns the signed fee `ExecutionRequest` in the Request variant, or
+   * `undefined` when no fee request is set or this is an Authorization variant.
+   */
+  feeRequest(): ExecutionRequest | undefined;
+  /**
+   * Creates a `ProvingRequest` from a JSON string representation.
+   *
+   * The variant is determined automatically by the JSON shape:
+   * `{ authorization, ... }` → Authorization variant; `{ request, ... }` →
+   * Request variant. Use {@link ProvingRequest#kind} to inspect the
+   * resulting variant.
    *
-   * @param {Uint8Array} request String representation of the ProvingRequest.
+   * @param {string} request JSON string representation of the ProvingRequest.
    */
   static fromString(request: string): ProvingRequest;
   /**
-   * Creates a left-endian byte representation of the ProvingRequest.
+   * Creates a left-endian byte representation of the ProvingRequest,
+   * dispatching on the variant. The bytes are wire-compatible with the
+   * matching DPS route (`/prove[/encrypted]` for Authorization,
+   * `/prove/request` for Request).
    */
   toBytesLe(): Uint8Array;
   /**
-   * Get the Authorization of the main function in the ProvingRequest.
+   * Creates a new Request-variant `ProvingRequest` from a single signed
+   * `ExecutionRequest` and an optional signed fee `ExecutionRequest`.
+   *
+   * The Request variant is processed by the DPS at the `/prove/request`
+   * endpoint, which is encrypted-only. The server runs
+   * `Process::authorize_request` to turn each `Request` into an
+   * `Authorization` before proving.
+   *
+   * Only valid for single-public-request executions. Layered / nested
+   * calls are not supported by `/prove/request` at this time.
+   *
+   * @param {ExecutionRequest} request The signed request for the function.
+   * @param {ExecutionRequest} fee_request Optional signed request for the fee function. When omitted, the prover generates and pays the fee.
+   * @param {boolean} broadcast Flag that indicates whether the remote proving service should attempt to submit the transaction on the caller's behalf.
+   */
+  static fromRequest(request: ExecutionRequest, fee_request: ExecutionRequest | null | undefined, broadcast: boolean): ProvingRequest;
+  /**
+   * Returns the Authorization of the main function in the ProvingRequest.
+   *
+   * @throws If this `ProvingRequest` is a Request variant. Check
+   * {@link ProvingRequest#kind} or use {@link ProvingRequest#request} instead.
    */
   authorization(): Authorization;
   /**
-   * Creates a ProvingRequest from a left-endian byte representation of the ProvingRequest.
+   * Reads bytes as an Authorization-variant `ProvingRequest`. For the
+   * Request variant, use {@link ProvingRequest.fromBytesLeRequest}
+   * explicitly — byte layout carries no variant discriminator.
    *
-   * @param {Uint8Array} bytes Left-endian bytes representing the proving request.
+   * @param {Uint8Array} bytes Left-endian bytes representing an Authorization-variant proving request.
    */
   static fromBytesLe(bytes: Uint8Array): ProvingRequest;
   /**
-   * Get the fee Authorization in the ProvingRequest.
+   * Returns the fee Authorization in the ProvingRequest, or `undefined`
+   * when no fee is set or this is a Request variant.
    */
   feeAuthorization(): Authorization | undefined;
   /**
-   * Creates a new ProvingRequest from a function Authorization and an optional fee Authorization.
+   * Reads bytes as a Request-variant `ProvingRequest`. Byte layout is
+   * disjoint from the Authorization variant; callers must pick the right
+   * reader for the bytes they hold.
+   *
+   * @param {Uint8Array} bytes Left-endian bytes representing a Request-variant proving request.
+   */
+  static fromBytesLeRequest(bytes: Uint8Array): ProvingRequest;
+  /**
+   * Creates a new Authorization-variant `ProvingRequest` from a function
+   * `Authorization` and an optional fee `Authorization`.
    *
    * @param {Authorization} authorization An Authorization for a function.
    * @param {Authorization} fee_authorization The authorization for the `credits.aleo/fee_public` or `credits.aleo/fee_private` function that pays the fee for the execution of the main function.
    * @param {boolean} broadcast Flag that indicates whether the remote proving service should attempt to submit the transaction on the caller's behalf.
    */
   static new(authorization: Authorization, fee_authorization: Authorization | null | undefined, broadcast: boolean): ProvingRequest;
+  /**
+   * Returns the variant of this `ProvingRequest`: `"authorization"` or
+   * `"request"`. Useful when handling a `ProvingRequest` whose variant
+   * was determined at deserialization time.
+   */
+  kind(): string;
   /**
    * Check if a ProvingRequest is the same as another ProvingRequest.
    */
   equals(other: ProvingRequest): boolean;
+  /**
+   * Returns the signed `ExecutionRequest` carried by the Request variant.
+   *
+   * @throws If this `ProvingRequest` is an Authorization variant. Check
+   * {@link ProvingRequest#kind} or use {@link ProvingRequest#authorization}
+   * instead.
+   */
+  request(): ExecutionRequest;
   /**
    * Get the broadcast flag set in the ProvingRequest.
    */
   broadcast(): boolean;
   /**
-   * Creates a string representation of the ProvingRequest.
+   * Creates a JSON string representation of the ProvingRequest.
+   * The shape carries enough information to recover the variant via
+   * {@link ProvingRequest.fromString}.
    */
   toString(): string;
 }