@provablehq/wasm 0.9.18 → 0.10.0

package/dist/mainnet/aleo_wasm.d.ts

@@ -680,32 +680,126 @@ export class ExecutionRequest {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Computes the function ID and serialized input data for a program function call.
+     * This is a helper for external signing wallets and other applications that need to compute
+     * publicly computable inputs for the `Request::sign` function.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} input_types The input types of the function as strings.
+     * @param {string[]} inputs The inputs to the function as strings.
+     * @param {boolean} is_root Flag to indicate if this is the top level function in the call graph.
+     * @param {Field | undefined} program_checksum The program checksum (required if the program has a constructor).
+     * @param {ViewKey | undefined} view_key The view key of the signer to compute a record's tag and h values.
+     *
+     * @returns {ExternalSigningInput}
+     */
+    static computeExternalSigningInputs(program_id: string, function_name: string, inputs: Array<any>, input_types: Array<any>, is_root: boolean, program_checksum?: Field | null, view_key?: ViewKey | null): object;
     /**
      * Creates an request object from a bytes representation of an request.
      */
     static fromBytesLe(bytes: Uint8Array): ExecutionRequest;
+    /**
+     * Builds a request from externally-signed data using externally-supplied record view keys.
+     *
+     * For record inputs, the caller provides `record_view_keys` and `gammas` directly.
+     * The method uses these to compute commitment, serial number, tag, and InputID for each record.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Signature} signature The externally-computed signature.
+     * @param {Field} tvk The transition view key.
+     * @param {Address} signer The signer address.
+     * @param {Field} sk_tag The tag secret key.
+     * @param {Field[] | undefined} record_view_keys Pre-computed record view keys (required when there are record inputs).
+     * @param {Group[] | undefined} gammas An array of gammas (required when there are record inputs).
+     */
+    static fromExternallySignedData(program_id: string, function_name: string, inputs: Array<any>, input_types: Array<any>, signature: Signature, tvk: Field, signer: Address, sk_tag: Field, record_view_keys?: Array<any> | null, gammas?: Array<any> | null): ExecutionRequest;
+    /**
+     * Builds a request from externally-signed data with pre-computed input IDs.
+     *
+     * Each element of `input_ids` is either:
+     * - A `Field` for constant, public, or private inputs (the input hash).
+     * - A JS Array `[Field, Group, Field, Field, Field]` for record inputs
+     *   (commitment, gamma, record_view_key, serial_number, tag).
+     *
+     * The `input_types` array is used to determine the InputID variant for scalar fields.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Signature} signature The externally-computed signature.
+     * @param {Field} tvk The transition view key.
+     * @param {Address} signer The signer address.
+     * @param {Field} sk_tag The tag secret key.
+     * @param {(Field | [Field, Group, Field, Field, Field])[]} input_ids Pre-computed input IDs.
+     */
+    static fromExternallySignedDataWithInputIds(program_id: string, function_name: string, inputs: Array<any>, input_types: Array<any>, signature: Signature, tvk: Field, signer: Address, sk_tag: Field, input_ids: Array<any>): ExecutionRequest;
+    /**
+     * Builds a request from externally-signed data using a view key to derive record view keys.
+     *
+     * For record inputs, the method computes `record_view_key = (nonce * view_key).to_x_coordinate()`
+     * for each record, then uses it with the supplied `gammas` to compute commitment, serial number,
+     * tag, and InputID.
+     *
+     * @param {string} program_id The id of the program.
+     * @param {string} function_name The function name.
+     * @param {string[]} inputs The inputs to the function.
+     * @param {string[]} input_types The input types of the function.
+     * @param {Signature} signature The externally-computed signature.
+     * @param {Field} tvk The transition view key.
+     * @param {Address} signer The signer address.
+     * @param {Field} sk_tag The tag secret key.
+     * @param {ViewKey} view_key The view key of the signer.
+     * @param {Group[] | undefined} gammas An array of gammas (required when there are record inputs).
+     */
+    static fromExternallySignedDataWithViewKey(program_id: string, function_name: string, inputs: Array<any>, input_types: Array<any>, signature: Signature, tvk: Field, signer: Address, sk_tag: Field, view_key: ViewKey, gammas?: Array<any> | null): ExecutionRequest;
     /**
      * Builds a request object from a string representation of a request.
      *
      * @param {string} request String representation of the request.
      */
     static fromString(request: string): ExecutionRequest;
+    /**
+     * Alias for `function_name` (camelCase).
+     */
+    functionName(): string;
     /**
      * Returns the function name.
      */
     function_name(): string;
+    /**
+     * Alias for `input_ids` (camelCase).
+     */
+    inputIds(): Array<any>;
     /**
      * Returns the input IDs for the transition.
+     *
+     * Each element is either a WASM `Field` (for constant/public/private/external_record inputs)
+     * or a JS Array `[Field, Group, Field, Field, Field]` (for record inputs: commitment, gamma,
+     * record_view_key, serial_number, tag).
      */
     input_ids(): Array<any>;
     /**
      * Returns the function inputs as an array of strings.
      */
     inputs(): Array<any>;
+    /**
+     * Alias for `network_id` (camelCase).
+     */
+    networkId(): number;
     /**
      * Returns the network ID.
      */
     network_id(): number;
+    /**
+     * Alias for `program_id` (camelCase).
+     */
+    programId(): string;
     /**
      * Returns the program ID.
      */
@@ -734,6 +828,10 @@ export class ExecutionRequest {
      * Returns the request signer.
      */
     signer(): Address;
+    /**
+     * Alias for `sk_tag` (camelCase).
+     */
+    skTag(): Field;
     /**
      * Returns the tag secret key `sk_tag`.
      */
@@ -752,6 +850,10 @@ export class ExecutionRequest {
      * @returns {string} String representation of the request.
      */
     toString(): string;
+    /**
+     * Alias for `to_tpk` (camelCase).
+     */
+    toTpk(): Group;
     /**
      * Returns the transition public key `tpk`.
      */
@@ -975,6 +1077,14 @@ export class Group {
      * Create a group element from a Uint8Array of left endian bytes.
      */
     static fromBytesLe(bytes: Uint8Array): Group;
+    /**
+     * Generate the group element from the x coordinate of the group.
+     */
+    static fromField(field: Field): Group;
+    /**
+     * Generate the group element from a string representation of the x coordinate of the group.
+     */
+    static fromFieldString(field: string): Group;
     /**
      * Creates a group object from a string representation of a group element.
      */
@@ -2336,6 +2446,17 @@ export class ProgramManager {
      * @returns {Authorization}
      */
     static authorizeFee(private_key: PrivateKey, deployment_or_execution_id: string, base_fee_credits: number, priority_fee_credits: number, fee_record?: RecordPlaintext | null): Promise<Authorization>;
+    /**
+     * Build an authorization from a `Request` object.
+     *
+     * @param {ExecutionRequest} request The execution request to build the authorization from.
+     * @param {string} program The program source code containing the function to authorize.
+     * @param {boolean} unchecked Whether or not to generate an unchecked authorization.
+     * @param {number | undefined} edition The edition of the program.
+     * @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>;
     /**
      * Create an execution `Authorization` without generating a circuit. Use this function when
      * fast delegated proving is needed.
@@ -2497,6 +2618,18 @@ export class ProgramManager {
      * @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>;
+    /**
+     * Build a proving request from a `Request` object. By default this method currently uses the feemaster.
+     *
+     * @param {ExecutionRequest} request The execution request to build the authorization from.
+     * @param {string} program The program source code containing the function to authorize.
+     * @param {boolean} unchecked Whether or not to generate an unchecked authorization.
+     * @param {boolean} broadcast Whether or not to broadcast the transaction.
+     * @param {number | undefined} edition The edition of the program.
+     * @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>;
     /**
      * Split an Aleo credits record into two separate records. This function does not require a fee.
      *
@@ -2653,6 +2786,41 @@ export class ProgramManager {
     static synthesizeKeyPair(private_key: PrivateKey, program: string, function_id: string, inputs: Array<any>, imports?: object | null, edition?: number | null): Promise<KeyPair>;
 }
 
+/**
+ * SNARK proof for verification of program execution
+ */
+export class Proof {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Construct a new proof from a byte array
+     *
+     * @param {Uint8Array} bytes Byte array representation of a proof
+     * @returns {Proof}
+     */
+    static fromBytes(bytes: Uint8Array): Proof;
+    /**
+     * Create a proof from string
+     *
+     * @param {string} string String representation of the proof
+     * @returns {Proof}
+     */
+    static fromString(string: string): Proof;
+    /**
+     * Return the byte representation of a proof
+     *
+     * @returns {Uint8Array} Byte array representation of a proof
+     */
+    toBytes(): Uint8Array;
+    /**
+     * Get a string representation of the proof
+     *
+     * @returns {string} String representation of the proof
+     */
+    toString(): string;
+}
+
 /**
  * Proving key for a function within an Aleo program
  */
@@ -3042,6 +3210,15 @@ export class RecordPlaintext {
      * @returns {RecordPlaintext} Record plaintext
      */
     static fromString(record: string): RecordPlaintext;
+    /**
+     * Compute the record's gamma value.
+     *
+     * @param {string} program_id The program id that produced the record.
+     * @param {string} record_name The name of the record within the program.
+     * @param {PrivateKey} private_key The private key that created the record.
+     * @returns {Group} The computed value of gamma.
+     */
+    gamma(program_id: string, record_name: string, private_key: PrivateKey): Group;
     /**
      * Get the record entry matching a key.
      *
@@ -4161,6 +4338,139 @@ export class U8 {
     toString(): string;
 }
 
+/**
+ * Aleo Value type. Value is the fundamental type representing program function inputs and outputs
+ * in Aleo. It wraps three variants: Plaintext, Record, and Future.
+ *
+ * @example
+ * // Parse a plaintext value from a string.
+ * const value = Value.fromString("100u64");
+ * console.log(value.valueType()); // "plaintext"
+ * console.log(value.isPlaintext()); // true
+ *
+ * // Extract the inner Plaintext.
+ * const plaintext = value.toPlaintext();
+ * console.log(plaintext.toString()); // "100u64"
+ */
+export class Value {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Creates a Value from a little-endian byte array.
+     *
+     * @param {Uint8Array} bytes A little-endian byte array.
+     * @returns {Value} The Value object.
+     */
+    static fromBytesLe(bytes: Uint8Array): Value;
+    /**
+     * Creates a Value from a Plaintext object.
+     *
+     * @param {Plaintext} plaintext The Plaintext to wrap.
+     * @returns {Value} A Value wrapping the Plaintext.
+     */
+    static fromPlaintext(plaintext: Plaintext): Value;
+    /**
+     * Creates a Value from a RecordPlaintext object.
+     *
+     * @param {RecordPlaintext} record The RecordPlaintext to wrap.
+     * @returns {Value} A Value wrapping the Record.
+     */
+    static fromRecordPlaintext(record: RecordPlaintext): Value;
+    /**
+     * Creates a Value from its string representation.
+     *
+     * @param {string} value The string representation of the value.
+     * @returns {Value} The Value object.
+     */
+    static fromString(value: string): Value;
+    /**
+     * Returns true if the value is a Future variant.
+     *
+     * Note: There is no `toFuture()` method because the Future type does not have a WASM wrapper.
+     * Use `toString()` or `toBytesLe()` to serialize a Future value.
+     *
+     * @returns {boolean}
+     */
+    isFuture(): boolean;
+    /**
+     * Returns true if the value is a Plaintext variant.
+     *
+     * @returns {boolean}
+     */
+    isPlaintext(): boolean;
+    /**
+     * Returns true if the value is a Record variant.
+     *
+     * @returns {boolean}
+     */
+    isRecord(): boolean;
+    /**
+     * Returns the little-endian boolean array representation of the bits.
+     *
+     * @returns {Array} Boolean array of bits in little-endian order.
+     */
+    toBitsLe(): Array<any>;
+    /**
+     * Returns the raw big-endian boolean array representation of the bits.
+     *
+     * @returns {Array} Raw boolean array of bits in big-endian order.
+     */
+    toBitsRawBe(): Array<any>;
+    /**
+     * Returns the raw little-endian boolean array representation of the bits.
+     *
+     * @returns {Array} Raw boolean array of bits in little-endian order.
+     */
+    toBitsRawLe(): Array<any>;
+    /**
+     * Returns the little-endian byte array representation of the value.
+     *
+     * @returns {Uint8Array} The little-endian byte array.
+     */
+    toBytesLe(): Uint8Array;
+    /**
+     * Returns the field array representation of the value.
+     *
+     * @returns {Array} Array of Field elements.
+     */
+    toFields(): Array<any>;
+    /**
+     * Returns the raw field array representation of the value.
+     *
+     * @returns {Array} Array of raw Field elements.
+     */
+    toFieldsRaw(): Array<any>;
+    /**
+     * Extracts the inner Plaintext from a Plaintext variant.
+     *
+     * @returns {Plaintext} The inner Plaintext value.
+     * @throws If the value is not a Plaintext variant.
+     */
+    toPlaintext(): Plaintext;
+    /**
+     * Extracts the inner Record from a Record variant as a RecordPlaintext.
+     *
+     * @returns {RecordPlaintext} The inner record.
+     * @throws If the value is not a Record variant.
+     */
+    toRecordPlaintext(): RecordPlaintext;
+    /**
+     * Returns the string representation of the value.
+     *
+     * @returns {string} The string representation of the value.
+     */
+    toString(): string;
+    /**
+     * Returns the type of the value variant as a string.
+     *
+     * Possible values: "plaintext", "record", "future".
+     *
+     * @returns {string} The variant type name.
+     */
+    valueType(): string;
+}
+
 /**
  * Verifying key for a function within an Aleo program
  */
@@ -4392,6 +4702,23 @@ export class VerifyingKey {
      * @returns {VerifyingKey} Verifying key for the unbond_public function
      */
     static unbondPublicVerifier(): VerifyingKey;
+    /**
+     * Verify a SNARK proof against this verifying key and public inputs.
+     *
+     * @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
+     */
+    verify(inputs: Array<any>, proof: Proof): boolean;
+    /**
+     * Verify a batch SNARK proof against multiple verifying keys and their corresponding public inputs.
+     *
+     * @param {Array<string>} verifying_keys Array of verifying key strings, one per circuit
+     * @param {Array<Array<Array<string>>>} inputs 3D array of field element strings [circuit_idx][instance_idx][field_idx]
+     * @param {Proof} proof The batch proof to verify
+     * @returns {boolean} True if the batch proof is valid, false otherwise
+     */
+    static verifyBatch(verifying_keys: Array<any>, inputs: Array<any>, proof: Proof): boolean;
 }
 
 export class ViewKey {
@@ -4467,7 +4794,7 @@ export class ViewKey {
  * @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;
+ * import { getOrInitConsensusVersionTestHeights } from '@provablehq/sdk';
  *
  * Set the consensus version heights.
  * getOrInitConsensusVersionTestHeights("0,1,2,3,4,5,6,7,8,9,10,11,12");
@@ -4478,6 +4805,34 @@ export function initThreadPool(url: URL, num_threads: number): Promise<void>;
 
 export function runRayonThread(receiver: number): 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 a batch SNARK proof against multiple verifying keys and their corresponding public inputs.
+ *
+ * This function verifies a batch proof produced by Aleo programs that may not be deployed on chain.
+ * Each verifying key is paired with one or more sets of public inputs (instances).
+ *
+ * @param {Array<string>} verifying_keys Array of verifying key strings, one per circuit
+ * @param {Array<Array<Array<string>>>} inputs 3D array of field element strings [circuit_idx][instance_idx][field_idx]
+ * @param {Proof} proof The batch proof to verify
+ * @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;
+
 /**
  * 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