@provablehq/wasm 0.10.5 → 0.10.6-rc.1

package/dist/mainnet/aleo_wasm.d.ts

@@ -2,18 +2,6 @@
 /* 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
- */
-export function snarkVerify(verifying_key: VerifyingKey, inputs: Array<any>, proof: Proof): boolean;
 /**
  * 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 +15,7 @@ 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 batch SNARK proof against multiple verifying keys and their corresponding public inputs.
  *
@@ -40,6 +28,18 @@ 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;
+/**
+ * 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;
 export function stringToField(string: string): Field;
 /**
  * Set test consensus version heights for testing.
@@ -2887,6 +2887,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 +3049,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 +3253,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 +3272,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 +3284,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 +3335,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 +3356,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 +3379,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 +3399,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 +3417,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 +3429,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 +3457,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 +3489,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 +3523,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 +3534,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 +3587,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 +3598,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 +3608,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