/* tslint:disable */ /* eslint-disable */ export function runRayonThread(receiver: number): void; export function initThreadPool(url: URL, num_threads: number): Promise; /** * 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 setWasmLogLevel(level: number): void; /** * 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} verifying_keys Array of verifying key strings, one per circuit * @param {Array>>} 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, inputs: Array, 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} 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, 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 * not verify that the state root of the execution is included in the Aleo Network ledger. * * @param {Execution} execution The function execution to verify * @param {VerifyingKey} verifying_key The verifying key for the function * @param {Program} program The program that the function execution belongs to * @param {String} function_id The name of the function that was executed * @param {Object} imports The imports for the program in the form of { "program_id.aleo":"source code", ... } * @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, program_imports?: ProgramImports | null): boolean; /** * Set test consensus version heights for testing. * * @param {string | undefined} heights The block heights at which each consensus version applies. This input should be a simple csv list of block heights and there should be one number for each consensus version. If left undefined, the default test heights will be applied. * * @example * import { getOrInitConsensusVersionTestHeights } from '@provablehq/sdk'; * * Set the consensus version heights. * getOrInitConsensusVersionTestHeights("0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16"); */ export function getOrInitConsensusVersionTestHeights(heights?: string | null): Array; export function stringToField(string: string): Field; /** * Public address of an Aleo account */ export class Address { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get an address object from a group. * * @param {Group} group The group object. * * @returns {Address} The address object. */ static fromGroup(group: Group): Address; /** * Get the left endian boolean array representation of the bits of the address. */ toBitsLe(): Array; /** * Get an address object from an array of fields. * * @param {Array} fields An array of fields. * * @returns {Plaintext} The address object. */ static fromFields(fields: Array): Address; /** * Create an aleo address object from a string representation of an address. * The input is automatically lowercased before parsing. * * @param {string} address String representation of an address * @returns {Address} Address */ static from_string(address: string): Address; /** * Get the left endian byte array representation of the address. */ toBytesLe(): Uint8Array; /** * Cast the address to an I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast the address to a U8 with lossy truncation. */ toU8Lossy(): U8; /** * Get an address from a series of bits represented as a boolean array. * * @param {Array} bits A left endian boolean array representing the bits of the address. * * @returns {Address} The address object. */ static fromBitsLe(bits: Array): Address; /** * Cast the address to an I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast the address to an I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast the address to an I64 with lossy truncation. */ toI64Lossy(): I64; /** * Get the plaintext representation of the address. */ toPlaintext(): Plaintext; /** * Get a string representation of an Aleo address object * * @returns {string} String representation of the address */ toString(): string; /** * Cast the address to a U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast the address to a U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast the address to a U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get an address from a series of bytes. * * @param {Uint8Array} bytes A left endian byte array representing the address. * * @returns {Address} The address object. */ static fromBytesLe(bytes: Uint8Array): Address; /** * Derive an Aleo address from a view key * * @param {ViewKey} view_key The view key to derive the address from * @returns {Address} Address corresponding to the view key */ static from_view_key(view_key: ViewKey): Address; /** * Cast the address to an I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast the address to a U128 with lossy truncation. */ toU128Lossy(): U128; /** * Get the address of a program based on the program ID. * * @param {string} program_id The program ID string. * @returns {Address} The address corresponding to the program ID. */ static fromProgramId(program_id: string): Address; /** * Cast the address to a Scalar with lossy truncation (via x-coordinate). */ toScalarLossy(): Scalar; /** * Derive an Aleo address from a compute key. * * @param {ComputeKey} compute_key The compute key to derive the address from */ static from_compute_key(compute_key: ComputeKey): Address; /** * Derive an Aleo address from a private key * * @param {PrivateKey} private_key The private key to derive the address from * @returns {Address} Address corresponding to the private key */ static from_private_key(private_key: PrivateKey): Address; /** * Cast the address to a Boolean with lossy truncation (LSB of x-coordinate). */ toBooleanLossy(): Boolean; /** * Verify a signature for a message signed by the address * * @param {Uint8Array} Byte array representing a message signed by the address * @returns {boolean} Boolean representing whether or not the signature is valid */ verify(message: Uint8Array, signature: Signature): boolean; /** * Check if the input is a valid Aleo address. * String addresses are automatically lowercased before validation. * * @param {string | Uint8Array} address - Either a string representation of an address * or a Uint8Array of bytes in little-endian format. * @returns {boolean} True if the input is a valid address, false otherwise. */ static isValid(address: any): boolean; /** * Cast the address to a Field element (x-coordinate of the underlying group point). */ toField(): Field; /** * Get the group representation of the address object. */ toGroup(): Group; /** * Get the field array representation of the address. */ toFields(): Array; /** * Get a string representation of an Aleo address object * * @param {Address} Address * @returns {string} String representation of the address */ to_string(): string; } /** * Authorization object containing the authorization for a transaction. */ export class Authorization { private constructor(); free(): void; [Symbol.dispose](): void; /** * Reconstructs an Authorization object from its string representation. * * @param {String} authorization The string representation of the Authorization. */ static fromString(authorization: string): Authorization; /** * Returns the left-endian byte representation of the Authorization. */ toBytesLe(): Uint8Array; /** * Get the transitions in an Authorization. * * @returns {Array} Array of transition objects */ transitions(): Array; /** * Creates an authorization object from a left-endian byte representation of an 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`. */ isFeePublic(): boolean; /** * Returns `true` if the Authorization is for `credits.aleo/fee_private`. */ isFeePrivate(): boolean; /** * Returns the execution ID for the Authorization. * * @returns {Field} The execution ID for the Authorization, call toString() after this result to get the string representation. */ toExecutionId(): Field; /** * Insert a transition into the Authorization. * * @param {Transition} transition The transition object to insert into the Authorization. */ insertTransition(transition: Transition): void; /** * Returns the number of `Request`s in the Authorization. */ len(): number; /** * Create a new authorization from a request object. * * @param {ExecutionRequest} request The ExecutionRequest to build the authorization from. */ static new(request: ExecutionRequest): Authorization; /** * Check if an Authorization object is the same as another. * * @param {Authorization} other The Authorization object to determine equality with. */ equals(other: Authorization): boolean; /** * Return `true` if the Authorization is empty. */ isEmpty(): boolean; /** * Returns `true` if the Authorization is for `credits.aleo/split`. */ isSplit(): boolean; /** * Returns a new and independent replica of the Authorization. */ replicate(): Authorization; /** * Returns the string representation of the Authorization. */ toString(): string; } export class BHP1024 { free(): void; [Symbol.dispose](): void; /** * Returns a BHP hash with an input hasher of 1024 bits. */ hashToGroup(input: Array): Group; /** * Returns a BHP commitment with an input hasher of 1024 bits and randomizer. */ commitToGroup(input: Array, randomizer: Scalar): Group; /** * Create a BHP hasher with an input size of 1024 bits. */ constructor(); /** * Returns the BHP hash with an input hasher of 1024 bits. */ hash(input: Array): Field; /** * Create a BHP hasher with an input size of 1024 bits with a custom domain separator. */ static setup(domain_separator: string): BHP1024; /** * Returns a BHP commitment with an input hasher of 1024 bits and randomizer. */ commit(input: Array, randomizer: Scalar): Field; } export class BHP256 { free(): void; [Symbol.dispose](): void; /** * Returns a BHP hash with an input hasher of 256 bits. */ hashToGroup(input: Array): Group; /** * Returns a BHP commitment with an input hasher of 256 bits and randomizer. */ commitToGroup(input: Array, randomizer: Scalar): Group; /** * Create a BHP hasher with an input size of 256 bits. */ constructor(); /** * Returns the BHP hash with an input hasher of 256 bits. */ hash(input: Array): Field; /** * Create a BHP hasher with an input size of 256 bits with a custom domain separator. */ static setup(domain_separator: string): BHP256; /** * Returns a BHP commitment with an input hasher of 256 bits and randomizer. */ commit(input: Array, randomizer: Scalar): Field; } export class BHP512 { free(): void; [Symbol.dispose](): void; /** * Returns a BHP hash with an input hasher of 512 bits. */ hashToGroup(input: Array): Group; /** * Returns a BHP commitment with an input hasher of 512 bits and randomizer. */ commitToGroup(input: Array, randomizer: Scalar): Group; /** * Create a BHP hasher with an input size of 512 bits. */ constructor(); /** * Returns the BHP hash with an input hasher of 512 bits. */ hash(input: Array): Field; /** * Create a BHP hasher with an input size of 512 bits with a custom domain separator. */ static setup(domain_separator: string): BHP512; /** * Returns a BHP commitment with an input hasher of 512 bits and randomizer. */ commit(input: Array, randomizer: Scalar): Field; } export class BHP768 { free(): void; [Symbol.dispose](): void; /** * Returns a BHP hash with an input hasher of 768 bits. */ hashToGroup(input: Array): Group; /** * Returns a BHP commitment with an input hasher of 768 bits and randomizer. */ commitToGroup(input: Array, randomizer: Scalar): Group; /** * Create a BHP hasher with an input size of 768 bits. */ constructor(); /** * Returns the BHP hash with an input hasher of 768 bits. */ hash(input: Array): Field; /** * Create a BHP hasher with an input size of 768 bits with a custom domain separator. */ static setup(domain_separator: string): BHP768; /** * Returns a BHP commitment with an input hasher of 768 bits and randomizer. */ commit(input: Array, randomizer: Scalar): Field; } /** * Boolean element. */ export class Boolean { free(): void; [Symbol.dispose](): void; /** * Cast the boolean to an Address (strict, via Group). Returns an error if conversion fails. */ toAddress(): Address; /** * Get the left endian boolean array representation of the boolean element. */ toBitsLe(): Array; /** * Creates a boolean object from a string representation ("true"/"false"). */ static fromString(boolean: string): Boolean; /** * Encode the boolean element as a Uint8Array of left endian bytes. */ toBytesLe(): Uint8Array; /** * Reconstruct a boolean element from a boolean array representation. */ static fromBitsLe(bits: Array): Boolean; /** * Create a plaintext from the boolean element. */ toPlaintext(): Plaintext; /** * Create a boolean element from a Uint8Array of left endian bytes. */ static fromBytesLe(bytes: Uint8Array): Boolean; /** * Cast the boolean to a Group element (lossy, via Field with Elligator-2 fallback). * This conversion never fails. */ toGroupLossy(): Group; /** * Cast the boolean to an Address (lossy, via Group with Elligator-2 fallback). */ toAddressLossy(): Address; /** * Logical OR. */ or(other: Boolean): Boolean; /** * Logical AND. */ and(other: Boolean): Boolean; /** * Creates a Boolean from a native JS bool. */ constructor(value: boolean); /** * Logical NOR. */ nor(other: Boolean): Boolean; /** * Logical NOT. */ not(): Boolean; /** * Logical XOR. */ xor(other: Boolean): Boolean; /** * Logical NAND. */ nand(other: Boolean): Boolean; /** * Clone the boolean element. */ clone(): Boolean; /** * Cast the boolean to an I8 (false=0, true=1). */ toI8(): I8; /** * Cast the boolean to a U8 (false=0, true=1). */ toU8(): U8; /** * Check if one boolean element equals another. */ equals(other: Boolean): boolean; /** * Generate a random boolean element. */ static random(): Boolean; /** * Cast the boolean to an I16 (false=0, true=1). */ toI16(): I16; /** * Cast the boolean to an I32 (false=0, true=1). */ toI32(): I32; /** * Cast the boolean to an I64 (false=0, true=1). */ toI64(): I64; /** * Cast the boolean to a U16 (false=0, true=1). */ toU16(): U16; /** * Cast the boolean to a U32 (false=0, true=1). */ toU32(): U32; /** * Cast the boolean to a U64 (false=0, true=1). */ toU64(): U64; /** * Cast the boolean to an I128 (false=0, true=1). */ toI128(): I128; /** * Cast the boolean to a U128 (false=0, true=1). */ toU128(): U128; /** * Cast the boolean to a Field element (false=0, true=1). Lossless. */ toField(): Field; /** * Cast the boolean to a Group element (strict, via Field x-coordinate recovery). * Returns an error if the resulting field is not a valid x-coordinate. */ toGroup(): Group; /** * Cast the boolean to a Scalar element (false=0, true=1). Lossless. */ toScalar(): Scalar; /** * Returns the string representation of the boolean element. */ toString(): string; } /** * A query implementation that delegates state fetching to JS callback functions. * * Instead of making direct HTTP calls via reqwest, each QueryTrait method * calls a JS function that returns a Promise. The JS side handles the actual * network request through the configured transport. */ export class CallbackQuery { free(): void; [Symbol.dispose](): void; /** * Create a new CallbackQuery with JS callback functions. * * @param {Function} get_state_root A function that returns Promise (the state root) * @param {Function} get_state_paths A function that takes string[] (commitments) and returns Promise (state paths) * @param {Function} get_block_height A function that returns Promise (the block height) */ constructor(get_state_root: Function, get_state_paths: Function, get_block_height: Function); } /** * SnarkVM Ciphertext object. A Ciphertext represents an symmetrically encrypted plaintext. This * object provides decryption methods to recover the plaintext from the ciphertext (given the * api consumer has the proper decryption materials). */ export class Ciphertext { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get the left endian boolean array representation of the bits of the ciphertext. */ toBitsLe(): Array; /** * Get a ciphertext object from an array of fields. * * @param {Array} fields An array of fields. * * @returns {Ciphertext} The ciphertext object. */ static fromFields(fields: Array): Ciphertext; /** * Deserialize a Ciphertext string into a Ciphertext object. * * @param {string} ciphertext A string representation of the ciphertext. * * @returns {Ciphertext} The Ciphertext object. */ static fromString(ciphertext: string): Ciphertext; /** * Get the left endian byte array representation of the ciphertext. */ toBytesLe(): Uint8Array; /** * Get a ciphertext object from a series of bits represented as a boolean array. * * @param {Array} bits A left endian boolean array representing the bits of the ciphertext. * * @returns {Ciphertext} The ciphertext object. */ static fromBitsLe(bits: Array): Ciphertext; /** * Deserialize a left endian byte array into a Ciphertext. * * @param {Uint8Array} bytes The byte array representing the Ciphertext. * * @returns {Ciphertext} The Ciphertext object. */ static fromBytesLe(bytes: Uint8Array): Ciphertext; /** * Decrypts a ciphertext into plaintext using the given ciphertext view key. * * @param {Field} transition_view_key The transition view key that was used to encrypt the ciphertext. * * @returns {Plaintext} The decrypted plaintext. */ decryptSymmetric(transition_view_key: Field): Plaintext; /** * Decrypt a ciphertext using the view key of the transition signer, transition public key, and * (program, function, index) tuple. * * @param {ViewKey} view_key The view key of the transition signer. * @param {Group} transition_public_key The transition public key used to encrypt the ciphertext. * @param {string} program The program ID associated with the ciphertext. * @param {string} function_name The name of the function associated with the encrypted inputs and outputs. * @param {u16} index The index of the input or output parameter that was encrypted. * * @returns {Plaintext} The decrypted plaintext. */ decryptWithTransitionInfo(view_key: ViewKey, transition_public_key: Group, program: string, function_name: string, index: number): Plaintext; /** * Decrypt a ciphertext using the transition view key and a (program, function, index) tuple. * * @param {Field} transition_view_key The transition view key that was used to encrypt the ciphertext. * @param {string} program The program ID associated with the ciphertext. * @param {string} function_name The name of the function associated with the encrypted inputs and outputs. * @param {u16} index The index of the input or output parameter that was encrypted. * * @returns {Plaintext} The decrypted plaintext. */ decryptWithTransitionViewKey(transition_view_key: Field, program: string, function_name: string, index: number): Plaintext; /** * Decrypt the ciphertext using the given view key. * * @param {ViewKey} viewKey The view key of the account that encrypted the ciphertext. * @param {Group} nonce The nonce used to encrypt the ciphertext. * * @returns {Plaintext} The decrypted plaintext. */ decrypt(view_key: ViewKey, nonce: Group): Plaintext; /** * Serialize a Ciphertext object into a byte array. * * @returns {Uint8Array} The serialized Ciphertext. */ toBytes(): Uint8Array; /** * Get the field array representation of the ciphertext. */ toFields(): Array; /** * Serialize a Ciphertext into a js string. * * @returns {string} The serialized Ciphertext. */ toString(): string; } export class ComputeKey { private constructor(); free(): void; [Symbol.dispose](): void; /** * Create a new compute key from a private key. * * @param {PrivateKey} private_key Private key * * @returns {ComputeKey} Compute key */ static from_private_key(private_key: PrivateKey): ComputeKey; /** * Get the pr_tag of the compute key. * * @returns {Group} pr_tag */ pk_sig(): Group; /** * Get the pr_sig of the compute key. * * @returns {Group} pr_sig */ pr_sig(): Group; /** * Get the sk_prf of the compute key. * * @returns {Scalar} sk_prf */ sk_prf(): Scalar; /** * Get the address from the compute key. * * @returns {Address} */ address(): Address; } /** * A fixed-size representation of an Aleo record. Like static records, a dynamic record * contains an owner, nonce, and a version, but instead of storing the full data it only * stores the Merkle root of the data, ensuring all dynamic records have a constant size. */ export class DynamicRecord { private constructor(); free(): void; [Symbol.dispose](): void; /** * Returns the dynamic record as a little-endian bit array (JS Array of booleans). */ toBitsLe(): Array; /** * Creates a DynamicRecord from a RecordPlaintext. */ static fromRecord(record: RecordPlaintext): DynamicRecord; /** * Creates a DynamicRecord from its string representation. */ static fromString(s: string): DynamicRecord; /** * Serializes the dynamic record to a little-endian byte array (Uint8Array). */ toBytesLe(): Uint8Array; /** * Deserializes a DynamicRecord from a little-endian byte array (Uint8Array). */ static fromBytesLe(bytes: Uint8Array): DynamicRecord; /** * Returns the Merkle root of the record data as a Field. */ root(): Field; /** * Returns the nonce of the record as a Group. */ nonce(): Group; /** * Returns the owner address of the dynamic record. */ owner(): Address; /** * Returns `true` if the dynamic record is a hiding variant (version != 0). */ isHiding(): boolean; /** * Returns the dynamic record as an array of field elements. */ toFields(): Array; /** * Converts this DynamicRecord back to a RecordPlaintext. * `owner_is_private` controls whether the owner field uses private or public visibility. */ toRecord(owner_is_private: boolean): RecordPlaintext; /** * Returns the string representation of the dynamic record. */ toString(): string; } /** * EncryptionToolkit provides a set of functions for encrypting, decrypting, and generating individual view keys for records, transitions, and ciphertexts. */ export class EncryptionToolkit { private constructor(); free(): void; [Symbol.dispose](): void; /** * Generates a transition view key from the view key and the transition public key. * * @param {ViewKey} view_key The view key of the account that generated the transition. * @param {Group} tpk The transition public key. * * @returns {Field} The transition view key. */ static generateTvk(view_key: ViewKey, tpk: Group): Field; /** * Decrypt the sender ciphertext associated with a record. * * @param {ViewKey} view_key View key associated with the record. * @param {RecordPlaintext} record Record plaintext associated with a sender. * @param {Field} sender_ciphertext Sender ciphertext associated with the record. * * @returns {Address} address of the sender. */ static decryptSender(view_key: ViewKey, record: RecordPlaintext, sender_ciphertext: Field): Address; /** * Checks if a record ciphertext is owned by the given view key. * * @param {ViewKey} view_key View key of the owner of the records. * @param {Vec} records The record ciphertexts for which to check ownership. * * @returns {Vec} The record ciphertexts that are owned by the view key. */ static checkOwnedRecords(view_key: ViewKey, records: RecordCiphertext[]): RecordCiphertext[]; /** * Decrypts a set of record ciphertexts in parallel and stores successful decryptions. * * @param {ViewKey} view_key The view key of the owner of the records. * @param {Vec} records The record ciphertexts to decrypt. * * @returns {vec} The decrypted record plaintexts. */ static decryptOwnedRecords(view_key: ViewKey, records: RecordCiphertext[]): RecordPlaintext[]; /** * Decrypt the sender ciphertext associated with the record with the record view key. * * @param {Field} record_view_key Record view key associated with the record. * @param {Field} sender_ciphertext Sender ciphertext associated with the record. * * @return {Address} the address of the sender. */ static decryptSenderWithRvk(record_view_key: Field, sender_ciphertext: Field): Address; /** * Creates a record view key from the view key. This can be later be used to decrypt a * * @param {ViewKey} view_key The view key of the owner of the record. * @param {RecordCiphertext} record_ciphertext The record ciphertext used to derive the record view key. * * @returns {Field} The record view key. */ static generateRecordViewKey(view_key: ViewKey, record_ciphertext: RecordCiphertext): Field; /** * Decrypts a transition using the transition view key. The ciphertext inputs and outputs * can only be decrypted if the transition view key was generated by the transaction signer. * * @param {Transition} transition The transition to decrypt. * @param {Field} transition_vk The transition view key. * * @returns {Transition} The decrypted transition. */ static decryptTransitionWithVk(transition: Transition, transition_vk: Field): Transition; /** * Decrypts a record ciphertext using the record view key. Decryption only succeeds * if the record view key was generated from the view key of the record owner. * * @param {Field} record_vk The record view key. * @param {RecordCiphertext} record_ciphertext The record ciphertext to decrypt. * * @returns {RecordPlaintext} The decrypted record plaintext. */ static decryptRecordWithRVk(record_vk: Field, record_ciphertext: RecordCiphertext): RecordPlaintext; } /** * Execution of an Aleo program. */ export class Execution { private constructor(); free(): void; [Symbol.dispose](): void; /** * Creates an execution object from a string representation of an execution. * * @returns {Execution | Error} The wasm representation of an execution object. */ static fromString(execution: string): Execution; /** * Returns the transitions present in the execution. * * @returns Array the array of transitions present in the execution. */ transitions(): Array; /** * Returns the global state root of the execution. * * @returns {Execution | Error} The global state root used in the execution. */ globalStateRoot(): string; /** * Returns the proof of the execution. * * @returns {string} The execution proof. */ proof(): string; /** * Returns the string representation of the execution. * * @returns {string} The string representation of the execution. */ toString(): string; } export class ExecutionRequest { private constructor(); free(): void; [Symbol.dispose](): void; /** * Returns the network ID. */ network_id(): number; /** * Returns the program ID. */ program_id(): string; /** * Builds a request object from a string representation of a request. * * @param {string} request String representation of the request. */ static fromString(request: string): ExecutionRequest; /** * Returns the bytes representation of the request. */ toBytesLe(): Uint8Array; /** * Alias for `sk_tag` (camelCase). */ skTag(): Field; /** * Alias for `to_tpk` (camelCase). */ toTpk(): Group; /** * Creates an request object from a bytes representation of an request. */ static fromBytesLe(bytes: Uint8Array): ExecutionRequest; /** * Returns the function name. */ function_name(): string; /** * Alias for `input_ids` (camelCase). */ inputIds(): Array; /** * Alias for `network_id` (camelCase). */ networkId(): number; /** * Alias for `program_id` (camelCase). */ programId(): string; /** * Alias for `function_name` (camelCase). */ functionName(): string; /** * 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, input_types: Array, signature: Signature, tvk: Field, signer: Address, sk_tag: Field, record_view_keys?: Array | null, gammas?: Array | null): ExecutionRequest; /** * 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, input_types: Array, is_root: boolean, program_checksum?: Field | null, view_key?: ViewKey | null): object; /** * Returns the signer commitment `scm`. */ scm(): Field; /** * Returns the transition commitment `tcm`. */ tcm(): Field; /** * Returns the transition view key `tvk`. */ tvk(): Field; /** * 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, input_types: Array, signature: Signature, tvk: Field, signer: Address, sk_tag: Field, view_key: ViewKey, gammas?: Array | 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, input_types: Array, signature: Signature, tvk: Field, signer: Address, sk_tag: Field, input_ids: Array): ExecutionRequest; /** * Create a new request by signing over a program ID and set of inputs. * * @param {PrivateKey} private_key The private key of the signer. * @param {string} program_id The id of the program to create the signature for. * @param {string} function_name The function name to create the signature for. * @param {string[]} inputs The inputs to the function. * @param {string[]} input_types The input types of the function. * @param {Field | undefined} root_tvk The tvk of the function at the top of the call graph. This is undefined if this request is built for the top-level call or if there is only one function in the call graph. * @param {Field | undefined} program_checksum The checksum of the program. This is undefined if the call is not dynamic. * @param {boolean} is_root Flag to indicate if this is the top level function in the call graph. * @param {boolean} is_dynamic Flag to indicate if this is a dynamic call. */ static sign(private_key: PrivateKey, program_id: string, function_name: string, inputs: Array, input_types: Array, root_tvk: Field | null | undefined, program_checksum: Field | null | undefined, is_root: boolean, is_dynamic: boolean): ExecutionRequest; /** * Returns the function inputs as an array of strings. */ inputs(): Array; /** * Returns the request signer. */ signer(): Address; /** * Returns the tag secret key `sk_tag`. */ sk_tag(): Field; /** * Returns the transition public key `tpk`. */ to_tpk(): Group; /** * Verify the input types within a request. * * @param {string[]} input_types The input types within the request. * @param {boolean} is_root Flag to indicate whether this request is the first function in the call graph. * @param {Field | undefined} program_checksum The checksum of the program. This is undefined if the call is not dynamic. */ verify(input_types: Array, is_root: boolean, program_checksum?: Field | null): boolean; /** * 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; /** * Returns the signature for the transition. */ signature(): Signature; /** * Returns the request as a string. * * @returns {string} String representation of the request. */ toString(): string; } /** * Webassembly Representation of an Aleo function execution response * * This object is returned by the execution of an Aleo function off-chain. It provides methods for * retrieving the outputs of the function execution. */ export class ExecutionResponse { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get the outputs of the executed function * * @returns {Array} Array of strings representing the outputs of the function */ getOutputs(): Array; /** * Returns the program */ getProgram(): Program; /** * Returns the execution object if present, null if otherwise. * * @returns {Execution | undefined} The execution object if present, null if otherwise */ getExecution(): Execution | undefined; /** * Returns the function identifier */ getFunctionId(): string; /** * Returns the proving_key if the proving key was cached in the Execution response. * Note the proving key is removed from the response object after the first call to this * function. Subsequent calls will return null. * * @returns {ProvingKey | undefined} The proving key */ getProvingKey(): ProvingKey | undefined; /** * Returns the verifying_key associated with the program * * @returns {VerifyingKey} The verifying key */ getVerifyingKey(): VerifyingKey; /** * Returns the program keys if present */ getKeys(): KeyPair; } /** * Field element. */ export class Field { private constructor(); free(): void; [Symbol.dispose](): void; /** * Cast the field element to an Address (strict, via Group x-coordinate recovery). * Returns an error if the field is not a valid x-coordinate on the curve. */ toAddress(): Address; /** * Get the left endian boolean array representation of the field element. */ toBitsLe(): Array; /** * Cast the field element to a Boolean (strict). * Returns an error if the field is not zero or one. */ toBoolean(): Boolean; /** * Creates a field object from a string representation of a field element. */ static fromString(field: string): Field; /** * Encode the field element as a Uint8Array of left endian bytes. */ toBytesLe(): Uint8Array; /** * Cast the field to an I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast the field to a U8 with lossy truncation. */ toU8Lossy(): U8; /** * Reconstruct a field element from a boolean array representation. */ static fromBitsLe(bits: Array): Field; /** * Cast the field to an I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast the field to an I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast the field to an I64 with lossy truncation. */ toI64Lossy(): I64; /** * Create a plaintext from the field element. */ toPlaintext(): Plaintext; /** * Cast the field to a U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast the field to a U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast the field to a U64 with lossy truncation. */ toU64Lossy(): U64; /** * Create a field element from a Uint8Array of left endian bytes. */ static fromBytesLe(bytes: Uint8Array): Field; /** * Cast the field to an I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast the field to a U128 with lossy truncation. */ toU128Lossy(): U128; /** * Cast the field element to a Group element with lossy conversion. * * Uses the snarkVM cast_lossy path: tries x-coordinate recovery first, * falls back to the generator for field == 1, and applies Elligator-2 * otherwise. This conversion never fails. */ toGroupLossy(): Group; /** * Cast the field element to a Scalar with lossy truncation. */ toScalarLossy(): Scalar; /** * Cast the field element to an Address with lossy conversion (via Group, Elligator-2 fallback). */ toAddressLossy(): Address; /** * Cast the field element to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Initializes a new field as a domain separator. */ static newDomainSeparator(domain: string): Field; /** * Add two field elements. */ add(other: Field): Field; /** * Get the multiplicative identity of the field. */ static one(): Field; /** * Power of a field element. */ pow(other: Field): Field; /** * Get the additive identity element of the field. */ static zero(): Field; /** * Clone the field element. */ clone(): Field; /** * Divide two field elements. */ divide(other: Field): Field; /** * Double the field element. */ double(): Field; /** * Check if one field element equals another. */ equals(other: Field): boolean; /** * Generate a random field element. */ static random(): Field; /** * Invert the field element. */ inverse(): Field; /** * Multiply two field elements. */ multiply(other: Field): Field; /** * Subtract two field elements. */ subtract(other: Field): Field; /** * Cast the field element to a Group element (strict). * * Attempts to recover the group element from the field as an x-coordinate. * Returns an error if the field is not a valid x-coordinate on the curve. */ toGroup(): Group; /** * Returns the string representation of the field element. */ toString(): string; } export class GraphKey { private constructor(); free(): void; [Symbol.dispose](): void; /** * Create a new graph key from a string representation of a graph key * * @param {string} graph_key String representation of a graph key * @returns {GraphKey} Graph key */ static from_string(graph_key: string): GraphKey; /** * Get a string representation of a graph key * * @returns {string} String representation of a graph key */ toString(): string; /** * Create a new graph key from a view key. * * @param {ViewKey} view_key View key * @returns {GraphKey} Graph key */ static from_view_key(view_key: ViewKey): GraphKey; /** * Get the sk_tag of the graph key. Used to determine ownership of records. */ sk_tag(): Field; /** * Get a string representation of a graph key * * @returns {string} String representation of a graph key */ to_string(): string; } /** * Elliptic curve element. */ export class Group { private constructor(); free(): void; [Symbol.dispose](): void; /** * Generate the group element from the x coordinate of the group. */ static fromField(field: Field): Group; /** * Cast the group element to an Address (lossless — Address wraps Group). */ toAddress(): Address; /** * Get the left endian boolean array representation of the group element. */ toBitsLe(): Array; /** * Creates a group object from a string representation of a group element. */ static fromString(group: string): Group; /** * Encode the group element as a Uint8Array of left endian bytes. */ toBytesLe(): Uint8Array; /** * Cast the group to an I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast the group to a U8 with lossy truncation. */ toU8Lossy(): U8; /** * Reconstruct a group element from a boolean array representation. */ static fromBitsLe(bits: Array): Group; /** * Cast the group to an I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast the group to an I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast the group to an I64 with lossy truncation. */ toI64Lossy(): I64; /** * Create a plaintext element from a group element. */ toPlaintext(): Plaintext; /** * Cast the group to a U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast the group to a U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast the group to a U64 with lossy truncation. */ toU64Lossy(): U64; /** * Create a group element from a Uint8Array of left endian bytes. */ static fromBytesLe(bytes: Uint8Array): Group; /** * Cast the group to an I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast the group to a U128 with lossy truncation. */ toU128Lossy(): U128; /** * Multiply a group element by a scalar element. */ scalarMultiply(scalar: Scalar): Group; /** * Cast the group element to a Scalar with lossy truncation (via x-coordinate). */ toScalarLossy(): Scalar; /** * Get the x-coordinate of the group element. */ toXCoordinate(): Field; /** * Cast the group element to a Boolean with lossy truncation (LSB of x-coordinate). */ toBooleanLossy(): Boolean; /** * Generate the group element from a string representation of the x coordinate of the group. */ static fromFieldString(field: string): Group; /** * Add two group elements. */ add(other: Group): Group; /** * Get the group identity element under the group operation (i.e. the point at infinity.) */ static zero(): Group; /** * Clone the group element. */ clone(): Group; /** * Double the group element. */ double(): Group; /** * Check if one group element equals another. */ equals(other: Group): boolean; /** * Generate a random group element. */ static random(): Group; /** * Get the inverse of the group element. This is the reflection of the point about the axis * of symmetry i.e. (x,y) -> (x, -y). */ inverse(): Group; /** * Subtract two group elements (equivalently: add the inverse of an element). */ subtract(other: Group): Group; /** * Cast the group element to a Field (returns x-coordinate). * This is an alias for `toXCoordinate()`. */ toField(): Field; /** * Get the generator of the group. */ static generator(): Group; /** * Get the field array representation of the group. */ toFields(): Array; /** * Returns the string representation of the group element. */ toString(): string; } export class I128 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): I128; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): I128; /** * Wrapped absolute value. */ absWrapped(): I128; /** * Wrapped addition with another integer. */ addWrapped(other: I128): I128; /** * Wrapped division. */ divWrapped(other: I128): I128; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): I128; /** * Construct an integer from a string representation. */ static fromString(s: string): I128; /** * Wrapped multiplication with another integer. */ mulWrapped(other: I128): I128; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: I128): I128; /** * Wrapped subtraction with another integer. */ subWrapped(other: I128): I128; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): I128; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): I128; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): I128; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): I128; /** * Get the remainder from integer division. */ rem(other: I128): I128; /** * Clone the integer in wasm memory. */ clone(): I128; /** * Check equality with another integer. */ equals(other: I128): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): I128; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): I128; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): I128; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class I16 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): I16; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): I16; /** * Wrapped absolute value. */ absWrapped(): I16; /** * Wrapped addition with another integer. */ addWrapped(other: I16): I16; /** * Wrapped division. */ divWrapped(other: I16): I16; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): I16; /** * Construct an integer from a string representation. */ static fromString(s: string): I16; /** * Wrapped multiplication with another integer. */ mulWrapped(other: I16): I16; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: I16): I16; /** * Wrapped subtraction with another integer. */ subWrapped(other: I16): I16; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): I16; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): I16; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): I16; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): I16; /** * Get the remainder from integer division. */ rem(other: I16): I16; /** * Clone the integer in wasm memory. */ clone(): I16; /** * Check equality with another integer. */ equals(other: I16): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): I16; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): I16; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): I16; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class I32 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): I32; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): I32; /** * Wrapped absolute value. */ absWrapped(): I32; /** * Wrapped addition with another integer. */ addWrapped(other: I32): I32; /** * Wrapped division. */ divWrapped(other: I32): I32; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): I32; /** * Construct an integer from a string representation. */ static fromString(s: string): I32; /** * Wrapped multiplication with another integer. */ mulWrapped(other: I32): I32; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: I32): I32; /** * Wrapped subtraction with another integer. */ subWrapped(other: I32): I32; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): I32; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): I32; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): I32; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): I32; /** * Get the remainder from integer division. */ rem(other: I32): I32; /** * Clone the integer in wasm memory. */ clone(): I32; /** * Check equality with another integer. */ equals(other: I32): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): I32; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): I32; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): I32; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class I64 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): I64; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): I64; /** * Wrapped absolute value. */ absWrapped(): I64; /** * Wrapped addition with another integer. */ addWrapped(other: I64): I64; /** * Wrapped division. */ divWrapped(other: I64): I64; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): I64; /** * Construct an integer from a string representation. */ static fromString(s: string): I64; /** * Wrapped multiplication with another integer. */ mulWrapped(other: I64): I64; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: I64): I64; /** * Wrapped subtraction with another integer. */ subWrapped(other: I64): I64; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): I64; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): I64; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): I64; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): I64; /** * Get the remainder from integer division. */ rem(other: I64): I64; /** * Clone the integer in wasm memory. */ clone(): I64; /** * Check equality with another integer. */ equals(other: I64): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): I64; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): I64; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): I64; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class I8 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): I8; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): I8; /** * Wrapped absolute value. */ absWrapped(): I8; /** * Wrapped addition with another integer. */ addWrapped(other: I8): I8; /** * Wrapped division. */ divWrapped(other: I8): I8; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): I8; /** * Construct an integer from a string representation. */ static fromString(s: string): I8; /** * Wrapped multiplication with another integer. */ mulWrapped(other: I8): I8; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: I8): I8; /** * Wrapped subtraction with another integer. */ subWrapped(other: I8): I8; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): I8; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): I8; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): I8; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): I8; /** * Get the remainder from integer division. */ rem(other: I8): I8; /** * Clone the integer in wasm memory. */ clone(): I8; /** * Check equality with another integer. */ equals(other: I8): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): I8; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): I8; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): I8; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } /** * Key pair object containing both the function proving and verifying keys */ export class KeyPair { free(): void; [Symbol.dispose](): void; /** * Get the proving key. This method will remove the proving key from the key pair * * @returns {ProvingKey} */ provingKey(): ProvingKey; /** * Get the verifying key. This method will remove the verifying key from the key pair * * @returns {VerifyingKey} */ verifyingKey(): VerifyingKey; /** * Create new key pair from proving and verifying keys * * @param {ProvingKey} proving_key Proving key corresponding to a function in an Aleo program * @param {VerifyingKey} verifying_key Verifying key corresponding to a function in an Aleo program * @returns {KeyPair} Key pair object containing both the function proving and verifying keys */ constructor(proving_key: ProvingKey, verifying_key: VerifyingKey); } export class Metadata { private constructor(); free(): void; [Symbol.dispose](): void; static fee_public(): Metadata; static bond_public(): Metadata; static fee_private(): Metadata; static unbond_public(): Metadata; static bond_validator(): Metadata; static transfer_public(): Metadata; static transfer_private(): Metadata; static claim_unbond_public(): Metadata; static set_validator_state(): Metadata; static transfer_public_as_signer(): Metadata; static transfer_private_to_public(): Metadata; static transfer_public_to_private(): Metadata; static join(): Metadata; static split(): Metadata; static baseUrl(): string; static inclusion(): Metadata; name: string; locator: string; prover: string; verifier: string; verifyingKey: string; } /** * An offline query object used to insert the global state root and state paths needed to create * a valid inclusion proof offline. */ export class OfflineQuery { free(): void; [Symbol.dispose](): void; /** * Create an offline query object from a json string representation. * * @param {string} JSON string representation of the offline query object. */ static fromString(s: string): OfflineQuery; /** * Add a new state path to the offline query object. * * @param {string} commitment: The commitment corresponding to a record input. * @param {string} state_path: The state path corresponding to the commitment. */ addStatePath(commitment: string, state_path: string): void; /** * Add a new block height to the offline query object. * * @param {u32} block_height The block height to add. */ addBlockHeight(block_height: number): void; /** * Creates a new offline query object. The state root is required to be passed in as a string * * @param {u32} block_height The block height. * @param {string} state_root The state root of the current network. * * @returns {OfflineQuery} The newly created offline query object. */ constructor(block_height: number, state_root: string); /** * Get a json string representation of the offline query object. * * @returns {string} JSON string representation of the offline query object. */ toString(): string; } export class Pedersen128 { free(): void; [Symbol.dispose](): void; /** * Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer. */ commitToGroup(input: Array, randomizer: Scalar): Group; /** * Create a Pedersen hasher for a given (up to) 128-bit input. */ constructor(); /** * Returns the Pedersen hash for a given (up to) 128-bit input. */ hash(input: Array): Field; /** * Create a Pedersen hasher for a given (up to) 128-bit input with a custom domain separator. */ static setup(domain_separator: string): Pedersen128; /** * Returns a Pedersen commitment for the given (up to) 128-bit input and randomizer. */ commit(input: Array, randomizer: Scalar): Field; } export class Pedersen64 { free(): void; [Symbol.dispose](): void; /** * Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer. */ commitToGroup(input: Array, randomizer: Scalar): Group; /** * Create a Pedersen hasher for a given (up to) 64-bit input. */ constructor(); /** * Returns the Pedersen hash for a given (up to) 64-bit input. */ hash(input: Array): Field; /** * Create a Pedersen64 hasher for a given (up to) 64-bit input with a custom domain separator. */ static setup(domain_separator: string): Pedersen64; /** * Returns a Pedersen commitment for the given (up to) 64-bit input and randomizer. */ commit(input: Array, randomizer: Scalar): Field; } /** * SnarkVM Plaintext object. Plaintext is a fundamental monadic type used to represent Aleo * primitive types (boolean, field, group, i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, * scalar, and signature), struct types, and array types. * * In the context of a web or NodeJS application, this type is useful for turning an Aleo type into * a JS value, object, or array that might be necessary for performing computations within the * application. * * @example * // Get the bond state of an existing address. * const bondState = await fetch(https://api.provable.com/v2/mainnet/program/credits.aleo/mapping/bond_state/aleo12zlythl7htjdtjjjz3ahdj4vl6wk3zuzm37s80l86qpx8fyx95fqnxcn2f); * // Convert the bond state to a Plaintext object. * const bondStatePlaintext = Plaintext.fromString(bond_state); * // Convert the Plaintext object to a JS object. * const bondStateObject = bond_state_plaintext.toObject(); * // Check if the bond state matches the expected object. * const expectedObject = { validator: "aleo12zlythl7htjdtjjjz3ahdj4vl6wk3zuzm37s80l86qpx8fyx95fqnxcn2f", microcredits: 100000000u64 }; * assert( JSON.stringify(bondStateObject) === JSON.stringify(expectedObject) ); */ export class Plaintext { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get the little endian boolean array representation of the bits of the plaintext. * * @returns {Array} The little endian boolean array representation of the bits of the plaintext. */ toBitsLe(): Array; /** * Get a plaintext object from an array of fields. * * @param {Array} fields An array of fields. * * @returns {Plaintext} The plaintext object. */ static fromFields(fields: Array): Plaintext; /** * Creates a plaintext object from a string representation of a plaintext. * * @param {string} plaintext The string representation of the plaintext. * * @returns {Plaintext} The plaintext object. */ static fromString(plaintext: string): Plaintext; /** * Get the little endian byte array representation of the plaintext. * * @returns {Uint8Array} The little endian byte array representation of the plaintext. */ toBytesLe(): Uint8Array; /** * Get a plaintext object from a series of bits represented as a boolean array. * * @param {Array} bits A little endian boolean array representing the bits plaintext. * * @returns {Plaintext} The plaintext object. */ static fromBitsLe(bits: Array): Plaintext; /** * Get a plaintext object from a series of bytes. * * @param {Uint8Array} bytes A little endian byte array representing the plaintext. * * @returns {Plaintext} The plaintext object. */ static fromBytesLe(bytes: Uint8Array): Plaintext; /** * Get the raw field array representation of the plaintext. * * @returns {Array} The raw field array representation of the plaintext. */ toFieldsRaw(): Array; /** * Gives the type of the plaintext. * * @returns {string} The type of the plaintext. */ plaintextType(): string; /** * Get the raw big endian boolean array representation of the bits of the plaintext. * * @returns {Array} The raw big endian boolean array representation of the bits of the plaintext. */ toBitsRawBe(): Array; /** * Get the raw little endian boolean array representation of the bits of the plaintext. * * @returns {Array} The raw little endian boolean array representation of the bits of the plaintext. */ toBitsRawLe(): Array; /** * Get the raw big endian byte array representation of the plaintext. * * @returns {Uint8Array} The raw big endian byte array representation of the plaintext. */ toBytesRawBe(): Uint8Array; /** * Get the raw little endian byte array representation of the plaintext. * * @returns {Uint8Array} The raw little endian byte array representation of the plaintext. */ toBytesRawLe(): Uint8Array; /** * Encrypt a plaintext with a transition view key. * * @param {Field} transition_view_key The transition view key of the transition * associated with the plaintext. * * @returns {Ciphertext} The encrypted ciphertext. */ encryptSymmetric(transition_view_key: Field): Ciphertext; /** * Find plaintext member if the plaintext is a struct. Returns `null` if the plaintext is not * a struct or the member does not exist. * * @param {string} name The name of the plaintext member to find. * * @returns {Plaintext} The plaintext member. */ find(name: string): Plaintext; /** * Encrypt a plaintext with an address and randomizer. * * @param {Address} address The address to encrypt the plaintext for. * @param {Scalar} randomizer The randomizer to use for encryption. * * @returns {Ciphertext} The encrypted ciphertext. */ encrypt(address: Address, randomizer: Scalar): Ciphertext; /** * Get the field array representation of the plaintext. * * @returns {Array} The field array representation of the plaintext. */ toFields(): Array; /** * Attempt to convert the plaintext to a JS object. * * @returns {Object} The JS object representation of the plaintext. */ toObject(): any; /** * Returns the string representation of the plaintext. * * @returns {string} The string representation of the plaintext. */ toString(): string; } export class Poseidon2 { free(): void; [Symbol.dispose](): void; /** * Returns the Poseidon hash with an input rate of 2 on the affine curve. */ hashToGroup(input: Array): Group; /** * Returns the Poseidon hash with an input rate of 2 on the scalar field. */ hashToScalar(input: Array): Scalar; /** * Create a Poseidon hasher with an input rate of 2. */ constructor(); /** * Returns the Poseidon hash with an input rate of 2. */ hash(input: Array): Field; /** * Create a Poseidon hasher with an input rate of 2 and a custom domain separator. */ static setup(domain_separator: string): Poseidon2; /** * Returns the extended Poseidon hash with an input rate of 2. */ hashMany(input: Array, num_outputs: number): Array; } export class Poseidon4 { free(): void; [Symbol.dispose](): void; /** * Returns the Poseidon hash with an input rate of 4 on the affine curve. */ hashToGroup(input: Array): Group; /** * Returns the Poseidon hash with an input rate of 4 on the scalar field. */ hashToScalar(input: Array): Scalar; /** * Create a Poseidon hasher with an input rate of 4. */ constructor(); /** * Returns the Poseidon hash with an input rate of 4. */ hash(input: Array): Field; /** * Create a Poseidon hasher with an input rate of 4 and a custom domain separator. */ static setup(domain_separator: string): Poseidon4; /** * Returns the extended Poseidon hash with an input rate of 4. */ hashMany(input: Array, num_outputs: number): Array; } export class Poseidon8 { free(): void; [Symbol.dispose](): void; /** * Returns the Poseidon hash with an input rate of 8 on the affine curve. */ hashToGroup(input: Array): Group; /** * Returns the Poseidon hash with an input rate of 8 on the scalar field. */ hashToScalar(input: Array): Scalar; /** * Create a Poseidon hasher with an input rate of 8. */ constructor(); /** * Returns the Poseidon hash with an input rate of 8. */ hash(input: Array): Field; /** * Create a Poseidon hasher with an input rate of 8 and a custom domain separator. */ static setup(domain_separator: string): Poseidon8; /** * Returns the extended Poseidon hash with an input rate of 8. */ hashMany(input: Array, num_outputs: number): Array; } /** * Private key of an Aleo account */ export class PrivateKey { free(): void; [Symbol.dispose](): void; /** * Sign an instance of a valid Aleo data type or record. * * @param {String} message The string representation of the Aleo datatype or record to sign. * @returns {Signature} Signature of the message. */ signValue(message: string): Signature; /** * Get the address corresponding to the private key * * @returns {Address} */ to_address(): Address; /** * Get a private key from a string representation of a private key * * @param {string} seed String representation of a private key * @returns {PrivateKey} */ static from_string(private_key: string): PrivateKey; /** * Get the byte representation of a private key * * @returns {Uint8Array} Byte representation of a private key */ toBytesLe(): Uint8Array; /** * Get the view key corresponding to the private key * * @returns {ViewKey} */ to_view_key(): ViewKey; /** * Get a string representation of the private key. This function should be used very carefully * as it exposes the private key plaintext * * @returns {string} String representation of a private key */ toString(): string; /** * Get a private key from a byte representation * * @param {Uint8Array} bytes Byte representation of a private key * @returns {PrivateKey} Private key */ static fromBytesLe(bytes: Uint8Array): PrivateKey; /** * Get a new randomly generated private key ciphertext using a secret. The secret is sensitive * and will be needed to decrypt the private key later, so it should be stored securely * * @param {string} secret Secret used to encrypt the private key * @returns {PrivateKeyCiphertext} Ciphertext representation of the private key */ static newEncrypted(secret: string): PrivateKeyCiphertext; /** * Encrypt an existing private key with a secret. The secret is sensitive and will be needed to * decrypt the private key later, so it should be stored securely * * @param {string} secret Secret used to encrypt the private key * @returns {PrivateKeyCiphertext} Ciphertext representation of the private key */ toCiphertext(secret: string): PrivateKeyCiphertext; /** * Get a private key from a series of unchecked bytes * * @param {Uint8Array} seed Unchecked 32 byte long Uint8Array acting as the seed for the private key * @returns {PrivateKey} */ static from_seed_unchecked(seed: Uint8Array): PrivateKey; /** * Get private key from a private key ciphertext and secret originally used to encrypt it * * @param {PrivateKeyCiphertext} ciphertext Ciphertext representation of the private key * @param {string} secret Secret originally used to encrypt the private key * @returns {PrivateKey} Private key */ static fromPrivateKeyCiphertext(ciphertext: PrivateKeyCiphertext, secret: string): PrivateKey; /** * Generate a new private key using a cryptographically secure random number generator * * @returns {PrivateKey} */ constructor(); /** * Sign a message with the private key * * @param {Uint8Array} Byte array representing a message signed by the address * @returns {Signature} Signature generated by signing the message with the address */ sign(message: Uint8Array): Signature; /** * Get a string representation of the private key. This function should be used very carefully * as it exposes the private key plaintext * * @returns {string} String representation of a private key */ to_string(): string; } /** * Private Key in ciphertext form */ export class PrivateKeyCiphertext { private constructor(); free(): void; [Symbol.dispose](): void; /** * Creates a PrivateKeyCiphertext from a string * * @param {string} ciphertext Ciphertext string * @returns {PrivateKeyCiphertext} Private key ciphertext */ static fromString(ciphertext: string): PrivateKeyCiphertext; /** * Encrypt a private key using a secret string. The secret is sensitive and will be needed to * decrypt the private key later, so it should be stored securely * * @param {PrivateKey} private_key Private key to encrypt * @param {string} secret Secret to encrypt the private key with * @returns {PrivateKeyCiphertext} Private key ciphertext */ static encryptPrivateKey(private_key: PrivateKey, secret: string): PrivateKeyCiphertext; /** * Decrypts a private ciphertext using a secret string. This must be the same secret used to * encrypt the private key * * @param {string} secret Secret used to encrypt the private key * @returns {PrivateKey} Private key */ decryptToPrivateKey(secret: string): PrivateKey; /** * Returns the ciphertext string * * @returns {string} Ciphertext string */ toString(): string; } /** * Webassembly Representation of an Aleo program */ export class Program { private constructor(); free(): void; [Symbol.dispose](): void; /** * Create a program from a program string * * @param {string} program Aleo program source code * @returns {Program} Program object */ static fromString(program: string): Program; /** * Get program_imports * * @returns {Array} The program imports * * @example * * const DOUBLE_TEST = "import multiply_test.aleo; * * program double_test.aleo; * * function double_it: * input r0 as u32.private; * call multiply_test.aleo/multiply 2u32 r0 into r1; * output r1 as u32.private;"; * * const expected_imports = [ * "multiply_test.aleo" * ]; * * const program = aleo_wasm.Program.fromString(DOUBLE_TEST_PROGRAM); * const imports = program.getImports(); * console.log(imports === expected_imports); // Output should be "true" */ getImports(): Array; /** * Get the checksum of the program. * * @returns {Uint8Array} The checksum of the program as a 32-byte Uint8Array */ toChecksum(): Uint8Array; /** * Get a the list of a program's mappings and the names/types of their keys and values. * * @returns {Array} - An array of objects representing the mappings in the program * @example * const expected_mappings = [ * { * name: "account", * key_name: "owner", * key_type: "address", * value_name: "microcredits", * value_type: "u64" * } * ] * * const credits_program = aleo_wasm.Program.getCreditsProgram(); * const credits_mappings = credits_program.getMappings(); * console.log(credits_mappings === expected_mappings); // Output should be "true" */ getMappings(): Array; /** * Determine if a function is present in the program * * @param {string} functionName Name of the function to check for * @returns {boolean} True if the program is valid, false otherwise */ hasFunction(function_name: string): boolean; /** * Get javascript array of functions names in the program * * @returns {Array} Array of all function names present in the program * * @example * const expected_functions = [ * "mint", * "transfer_private", * "transfer_private_to_public", * "transfer_public", * "transfer_public_to_private", * "join", * "split", * "fee" * ] * * const credits_program = aleo_wasm.Program.getCreditsProgram(); * const credits_functions = credits_program.getFunctions(); * console.log(credits_functions === expected_functions); // Output should be "true" */ getFunctions(): Array; /** * Get the program's name (without the `.aleo` suffix) encoded as a field element. * * This is the same value as casting the program name identifier to a field on-chain * (e.g. `my_program.aleo` -> `Identifier("my_program") as field`), which is used as * the program id in dynamic dispatch calls such as `IARC20@(token_id)`. * * @example * const program = aleo_wasm.Program.getCreditsProgram(); * const field = program.nameToField(); // Field encoding of "credits" * * @returns {Field} The program name as a field element */ nameToField(): Field; /** * 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 * * @param {string} record_name Name of the record to get members for * @returns {Object} Object containing the record name, type, and members * * @example * * const expected_record = { * type: "record", * record: "Credits", * members: [ * { * name: "owner", * type: "address", * visibility: "private" * }, * { * name: "microcredits", * type: "u64", * visibility: "private" * } * ]; * }; * * const credits_program = aleo_wasm.Program.getCreditsProgram(); * const credits_record = credits_program.getRecordMembers("Credits"); * console.log(credits_record === expected_record); // Output should be "true" */ getRecordMembers(record_name: string): object; /** * Get a javascript object representation of a program struct and its types * * @param {string} struct_name Name of the struct to get members for * @returns {Array} Array containing the struct members * * @example * * const STRUCT_PROGRAM = "program token_issue.aleo; * * struct token_metadata: * network as u32; * version as u32; * * struct token: * token_id as u32; * metadata as token_metadata; * * function no_op: * input r0 as u64; * output r0 as u64;" * * const expected_struct_members = [ * { * name: "token_id", * type: "u32", * }, * { * name: "metadata", * type: "struct", * struct_id: "token_metadata", * members: [ * { * name: "network", * type: "u32", * } * { * name: "version", * type: "u32", * } * ] * } * ]; * * const program = aleo_wasm.Program.fromString(STRUCT_PROGRAM); * const struct_members = program.getStructMembers("token"); * console.log(struct_members === expected_struct_members); // Output should be "true" */ getStructMembers(struct_name: string): Array; /** * Get the credits.aleo program * * @returns {Program} The credits.aleo program */ static getCreditsProgram(): Program; /** * Get a javascript object representation of the function inputs and types. This can be used * to generate a web form to capture user inputs for an execution of a function. * * @param {string} function_name Name of the function to get inputs for * @returns {Array} Array of function inputs * * @example * const expected_inputs = [ * { * type:"record", * visibility:"private", * record:"credits", * members:[ * { * name:"microcredits", * type:"u64", * visibility:"private" * } * ], * register:"r0" * }, * { * type:"address", * visibility:"private", * register:"r1" * }, * { * type:"u64", * visibility:"private", * register:"r2" * } * ]; * * const credits_program = aleo_wasm.Program.getCreditsProgram(); * const transfer_function_inputs = credits_program.getFunctionInputs("transfer_private"); * console.log(transfer_function_inputs === expected_inputs); // Output should be "true" */ getFunctionInputs(function_name: string): Array; /** * Get the id of the program * * @returns {string} The id of the program */ id(): string; /** * Get a unique address of the program * * @returns {Address} The address of the program */ address(): Address; /** * Determine if the program implements the ARC-20 fungible token interface (IARC20). * * This checks that the program defines a `Token` record with an `amount: u128` entry * (additional entries are permitted, per the interface's open record definition) and * that every function and view function required by ARC-20 is present with the exact * input and output signature defined by the standard. * * @see https://github.com/ProvableHQ/ARCs/blob/master/arc-0020/README.md * * @returns {boolean} True if the program implements the ARC-20 token interface */ isArc20(): boolean; /** * Determine if the program implements the ARC-22 compliant token interface (IARC22). * * This checks that the program defines `Token` and `ComplianceRecord` records with the * entries required by the standard (additional entries are permitted, per the * interface's open record definitions), and that every function and view function * required by ARC-22 is present with the exact input and output signature defined by * the standard. The `MerkleProof` struct used by the private transfer functions may be * declared locally (in which case its shape must match the standard exactly) or * imported from another program such as a freeze list registry. * * Note: this checks the token interface (IARC22) only. The freeze list registry * interface (IARC22Freezelist) is typically implemented by a separate program and is * not required for a token program to be considered ARC-22 compliant. * * @see https://github.com/ProvableHQ/ARCs/blob/master/arc-0022/README.md * * @returns {boolean} True if the program implements the ARC-22 token interface */ isArc22(): boolean; /** * Determine equality with another program * * @param {Program} other The other program to compare * @returns {boolean} True if the programs are equal, false otherwise */ isEqual(other: Program): boolean; /** * Get a string representation of the program * * @returns {string} String containing the program source code */ toString(): string; } /** * Backed by `Rc>` 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`. * * This is a lightweight alternative to `toObject()` when you only need to * enumerate program names without serializing keys. * * @returns {Array} */ programNames(): Array; /** * 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} */ functionKeysAvailable(program_name: string): Array; /** * 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; [Symbol.dispose](): void; /** * Synthesize proving and verifying keys for a program * * @param {string} program The program source code of the program to synthesize keys for * @param {string} function_id The function to synthesize keys for * @param {Array} inputs The inputs to the function * @param {Object | undefined} imports The imports for the program */ static synthesizeKeyPair(private_key: PrivateKey, program: string, function_id: string, inputs: Array, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise; static loadInclusionProver(proving_key: ProvingKey): void; /** * Create a `ProvingRequest` object. This object creates authorizations for the top level * function and associated fee function. This object can be sent directly to a remote prover * OR used to extract both execution and fee authorizations. * * @param private_key The private key of the signer. * @param program The program source code containing the function to authorize. * @param function_name The function to authorize. * @param inputs A javascript array of inputs to the function. * @param base_fee_credits The base fee to be paid for the authorization * @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 imports The imports to the program in the format {"programname.aleo":"aleo instructions source code"}. * @param url The url of the Aleo network node to send the transaction to * @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, 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; /** * 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, program_imports?: ProgramImports | null): Promise; /** * 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 * * @param private_key The private key of the sender * @param record_1 The first record to combine * @param record_2 The second record to combine * @param priority_fee_credits The opptional 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 * @param join_proving_key (optional) Provide a proving key to use for the join function * @param join_verifying_key (optional) Provide a verifying key to use for the join function * @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 * @returns {Transaction} Transaction object */ static buildJoinTransaction(private_key: PrivateKey, record_1: RecordPlaintext, record_2: RecordPlaintext, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, join_proving_key?: ProvingKey | null, join_verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null): Promise; /** * Split an Aleo credits record into two separate records. This function does not require a fee. * * @param private_key The private key of the sender * @param split_amount The amount of the credit split. This amount will be subtracted from the * value of the record and two new records will be created with the split amount and the remainder * @param amount_record The record to split * @param url The url of the Aleo network node to send the transaction to * @param split_proving_key (optional) Provide a proving key to use for the split function * @param split_verifying_key (optional) Provide a verifying key to use for the split function * @returns {Transaction} Transaction object */ static buildSplitTransaction(private_key: PrivateKey, split_amount: number, amount_record: RecordPlaintext, url?: string | null, split_proving_key?: ProvingKey | null, split_verifying_key?: VerifyingKey | null, query?: QueryOption | null): Promise; /** * Deploy an Aleo program without synthesizing keys and generating certificates. * Intended for use with Leo Devnode. * * @param private_key The private key of the sender * @param program The source code of the program being deployed * @param imports A javascript object holding the source code of any imported programs in the * form \{"program_name1": "program_source_code", "program_name2": "program_source_code", ..\}. * Note that all imported programs must be deployed on chain before the main program in order * for the deployment to succeed * @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 * @param imports (optional) Provide a list of imports to use for the program deployment 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 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 * @returns {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; /** * Upgrade a deployed Aleo program without synthesizing keys and generating certificates. * Intended for use with Leo Devnode. * * @param private_key The private key of the sender * @param program The source code of the upgraded program * @param imports A javascript object holding the source code of any imported programs in the * form \{"program_name1": "program_source_code", "program_name2": "program_source_code", ..\}. * Note that all imported programs must be deployed on chain before the main program in order * for the deployment to succeed * @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 * @param imports (optional) Provide a list of imports to use for the program deployment 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 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 * @returns {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; /** * 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 * the cost of the size (in bytes) of the deployment. * * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network * * @param name The name of the program to be deployed * @returns {u64} */ static estimateProgramNameCost(name: string): bigint; /** * Estimate the fee for a program deployment * * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network * * @param program The source code of the program being deployed * @param imports (optional) Provide a list of imports to use for the deployment 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" \} * @returns {u64} */ static estimateDeploymentFee(program: string, imports?: object | null, program_imports?: ProgramImports | null): Promise; /** * Deploy an Aleo program * * @param private_key The private key of the sender * @param program The source code of the program being deployed * @param imports A javascript object holding the source code of any imported programs in the * form \{"program_name1": "program_source_code", "program_name2": "program_source_code", ..\}. * Note that all imported programs must be deployed on chain before the main program in order * for the deployment to succeed * @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 * @param imports (optional) Provide a list of imports to use for the program deployment 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 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 * @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, program_imports?: ProgramImports | null): Promise; /** * Upgrade an Aleo program * * @param private_key The private key of the sender * @param program The source code of the program being upgraded * @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 * @param imports (optional) Provide a list of imports to use for the program deployment 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" \} * Note that all imported programs must be deployed on chain before the main program in order * for the deployment to succeed * @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 * @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, program_imports?: ProgramImports | null): Promise; /** * Generate an execution transaction without a proof. * Intended for use with the Leo devnode tool. * * @param private_key The private key of the sender * @param program The source code of the program being executed * @param function The name of the function to execute * @param inputs A javascript array of inputs to the function * @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 * @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 edition The edition of the program to execute. Defaults to 1. * @returns {Transaction} */ static buildDevnodeExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise; /** * 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 * step, then the finalize fee is 0. * * Disclaimer: Fee estimation is experimental and may not represent a correct estimate on any current or future network * * @param program The program containing the function to estimate the finalize fee for * @param function The function to estimate the finalize fee for * @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. * @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, program_imports?: ProgramImports | null, edition?: number | null): Promise; /** * 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 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, program_imports?: ProgramImports | null): bigint; /** * Execute an arbitrary function locally * * @param {PrivateKey} private_key The private key of the sender * @param {string} program The source code of the program being executed * @param {string} function The name of the function to execute * @param {Array} inputs A javascript array of inputs to the function * @param {boolean} prove_execution If true, the execution will be proven and an execution object * containing the proof and the encrypted inputs and outputs needed to verify the proof offline * will be returned. * @param {boolean} cache Cache the proving and verifying keys in the Execution response. * If this is set to 'true' the keys synthesized will be stored in the Execution Response * and the `ProvingKey` and `VerifyingKey` can be retrieved from the response via the `.getKeys()` * method. * @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 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, 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; /** * Compute the query requirements for a function execution without making * any network calls. Returns the commitments that need state paths and * whether the function has dynamic record inputs. * * This enables the JS layer to pre-fetch state data via its configured * transport and construct an OfflineQuery, so that the subsequent WASM * execution call never makes its own network requests. * * @param {string} program The source code of the program * @param {string} function_name The name of the function to execute * @param {Array} inputs The inputs to the function * @param {PrivateKey} private_key The private key (used to derive the view key for commitment computation) * @param {RecordPlaintext | undefined} fee_record Optional fee record to include in commitment computation * @returns {Object} An object with { commitments: string[], hasDynamicInputs: boolean } */ static computeQueryRequirements(program: string, function_name: string, inputs: Array, private_key: PrivateKey, fee_record?: RecordPlaintext | null): any; /** * 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, program_imports?: ProgramImports | null): bigint; /** * Execute Aleo function and create an Aleo execution transaction * * @param private_key The private key of the sender * @param program The source code of the program being executed * @param function The name of the function to execute * @param inputs A javascript array of inputs to the function * @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 * @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 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 1. * @returns {Transaction} */ static buildExecutionTransaction(private_key: PrivateKey, program: string, _function: string, inputs: Array, 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; /** * Send credits from one Aleo account to another * * @param private_key The private key of the sender * @param amount_credits The amount of credits to send * @param recipient The recipient of the transaction * @param transfer_type The type of the transfer (options: "private", "public", "private_to_public", "public_to_private") * @param amount_record The record to fund the amount from * @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 * @param transfer_verifying_key (optional) Provide a verifying key to use for the transfer * function * @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 * @returns {Transaction} */ static buildTransferTransaction(private_key: PrivateKey, amount_credits: number, recipient: string, transfer_type: string, amount_record: RecordPlaintext | null | undefined, priority_fee_credits: number, fee_record?: RecordPlaintext | null, url?: string | null, transfer_proving_key?: ProvingKey | null, transfer_verifying_key?: VerifyingKey | null, fee_proving_key?: ProvingKey | null, fee_verifying_key?: VerifyingKey | null, query?: QueryOption | null): Promise; /** * Create an `Authorization` for `credits.aleo/fee_public` or `credits.aleo/fee_private`. * This object requires an associated execution or deployment ID. This can be gained from * any previously created authorization by calling (authorization.toExecutionId()). * * @param private_key The private key of the signer. * @param deployment_or_execution_id The id of the deployment or execution to authorize the fee program for. * @param base_fee_credits The base fee to be paid for the authorization * @param priority_fee_credits The optional priority fee to be paid for the transaction * @param fee_record The record to spend the fee from * @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; /** * 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, program_imports?: ProgramImports | null): Promise; /** * Create an execution `Authorization` without generating a circuit. Use this function when * fast delegated proving is needed. * * @param private_key The private key of the signer. * @param program The program source code containing the function to authorize. * @param function_name The function to authorize. * @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, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise; /** * Create an execution `Authorization` for a given program:function tuple with specified inputs. * * @param private_key The private key of the signer. * @param program The program source code containing the function to authorize. * @param function_name The function to authorize. * @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, imports?: object | null, edition?: number | null, program_imports?: ProgramImports | null): Promise; } /** * 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 */ export class ProvingKey { private constructor(); free(): void; [Symbol.dispose](): void; /** * Construct a new proving key from a byte array * * @param {Uint8Array} bytes Byte array representation of a proving key * @returns {ProvingKey} */ static fromBytes(bytes: Uint8Array): ProvingKey; /** * Create a proving key from string * * @param {string} String representation of the proving key */ static fromString(string: string): ProvingKey; /** * Create a copy of the proving key * * @returns {ProvingKey} A copy of the proving key */ copy(): ProvingKey; /** * Return the checksum of the proving key * * @returns {string} Checksum of the proving key */ checksum(): string; /** * Return the byte representation of a proving key * * @returns {Uint8Array} Byte array representation of a proving key */ toBytes(): Uint8Array; /** * Get a string representation of the proving key * * @returns {string} String representation of the proving key */ toString(): string; /** * Verify if the proving key is for the join function * * @example * const provingKey = ProvingKey.fromBytes("join_proving_key.bin"); * provingKey.isJoinProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the join function, false if otherwise */ isJoinProver(): boolean; /** * Verify if the proving key is for the split function * * @example * const provingKey = ProvingKey.fromBytes("split_proving_key.bin"); * provingKey.isSplitProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the split function, false if otherwise */ isSplitProver(): boolean; /** * Verify if the proving key is for the inclusion function * * @example * const provingKey = ProvingKey.fromBytes("inclusion_proving_key.bin"); * provingKey.isInclusionProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the inclusion function, false if otherwise */ isInclusionProver(): boolean; /** * Verify if the proving key is for the fee_public function * * @example * const provingKey = ProvingKey.fromBytes("fee_public_proving_key.bin"); * provingKey.isFeePublicProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the fee_public function, false if otherwise */ isFeePublicProver(): boolean; /** * Verify if the proving key is for the bond_public function * * @example * const provingKey = ProvingKey.fromBytes("bond_public_proving_key.bin"); * provingKey.isBondPublicProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the bond_public function, false if otherwise */ isBondPublicProver(): boolean; /** * Verify if the proving key is for the fee_private function * * @example * const provingKey = ProvingKey.fromBytes("fee_private_proving_key.bin"); * provingKey.isFeePrivateProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the fee_private function, false if otherwise */ isFeePrivateProver(): boolean; /** * Verify if the proving key is for the unbond_public function * * @example * const provingKey = ProvingKey.fromBytes("unbond_public.bin"); * provingKey.isUnbondPublicProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the unbond_public_prover function, false if otherwise */ isUnbondPublicProver(): boolean; /** * Verify if the proving key is for the bond_validator function * * @example * const provingKey = ProvingKey.fromBytes("bond_validator_proving_key.bin"); * provingKey.isBondPublicProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the bond_validator function, false if otherwise */ isBondValidatorProver(): boolean; /** * Verify if the proving key is for the transfer_public function * * @example * const provingKey = ProvingKey.fromBytes("transfer_public_proving_key.bin"); * provingKey.isTransferPublicProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the transfer_public function, false if otherwise */ isTransferPublicProver(): boolean; /** * Verify if the proving key is for the transfer_private function * * @example * const provingKey = ProvingKey.fromBytes("transfer_private_proving_key.bin"); * provingKey.isTransferPrivateProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the transfer_private function, false if otherwise */ isTransferPrivateProver(): boolean; /** * Verify if the proving key is for the claim_unbond function * * @example * const provingKey = ProvingKey.fromBytes("claim_unbond_proving_key.bin"); * provingKey.isClaimUnbondProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the claim_unbond function, false if otherwise */ isClaimUnbondPublicProver(): boolean; /** * Verify if the proving key is for the set_validator_state function * * @example * const provingKey = ProvingKey.fromBytes("set_validator_set_proving_key.bin"); * provingKey.isSetValidatorStateProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the set_validator_state function, false if otherwise */ isSetValidatorStateProver(): boolean; /** * Verify if the proving key is for the transfer_public_as_signer function * * @example * const provingKey = ProvingKey.fromBytes("transfer_public_as_signer_proving_key.bin"); * provingKey.isTransferPublicAsSignerProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the transfer_public function, false if otherwise */ isTransferPublicAsSignerProver(): boolean; /** * Verify if the proving key is for the transfer_private_to_public function * * @example * const provingKey = ProvingKey.fromBytes("transfer_private_to_public_proving_key.bin"); * provingKey.isTransferPrivateToPublicProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the transfer_private_to_public function, false if otherwise */ isTransferPrivateToPublicProver(): boolean; /** * Verify if the proving key is for the transfer_public_to_private function * * @example * const provingKey = ProvingKey.fromBytes("transfer_public_to_private_proving_key.bin"); * provingKey.isTransferPublicToPrivateProver() ? console.log("Key verified") : throw new Error("Invalid key"); * * @returns {boolean} returns true if the proving key is for the transfer_public_to_private function, false if otherwise */ isTransferPublicToPrivateProver(): boolean; } /** * 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; /** * 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 {string} request JSON string representation of the ProvingRequest. */ static fromString(request: string): 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; /** * 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; /** * 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 an Authorization-variant proving request. */ static fromBytesLe(bytes: Uint8Array): ProvingRequest; /** * Returns the fee Authorization in the ProvingRequest, or `undefined` * when no fee is set or this is a Request variant. */ feeAuthorization(): Authorization | undefined; /** * 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 JSON string representation of the ProvingRequest. * The shape carries enough information to recover the variant via * {@link ProvingRequest.fromString}. */ toString(): string; } /** * A unified query type that wraps either an OfflineQuery (pre-fetched state) * or a CallbackQuery (on-demand JS transport delegation). * * Construct from JavaScript using the static factory methods: * - `QueryOption.offlineQuery(offlineQuery)` for pre-fetched state * - `QueryOption.callbackQuery(callbackQuery)` for on-demand JS callbacks */ export class QueryOption { private constructor(); free(): void; [Symbol.dispose](): void; /** * Create a QueryOption from an OfflineQuery. */ static offlineQuery(query: OfflineQuery): QueryOption; /** * Create a QueryOption from a CallbackQuery. */ static callbackQuery(query: CallbackQuery): QueryOption; } /** * Encrypted Aleo record */ export class RecordCiphertext { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get the left endian boolean array representation of the record ciphertext bits. * * returns {Array} Left endian boolean array representation of the bits of the record ciphertext. */ toBitsLe(): Array; /** * Create a record ciphertext from a string * * @param {string} record String representation of a record ciphertext * @returns {RecordCiphertext} Record ciphertext */ static fromString(record: string): RecordCiphertext; /** * Get the left endian byte array representation of the record ciphertext. * * @returns {Uint8Array} Left endian byte array representation of the record ciphertext. */ toBytesLe(): Uint8Array; /** * Get a record ciphertext object from a series of bytes. * * @param {Uint8Array} bytes A left endian byte array representing the record ciphertext. * * @returns {RecordCiphertext} */ static fromBytesLe(bytes: Uint8Array): RecordCiphertext; /** * Generate the record view key. The record view key can only decrypt record if the * supplied view key belongs to the record owner. * * @param {ViewKey} view_key View key used to generate the record view key * * @returns {Group} record view key */ recordViewKey(view_key: ViewKey): Field; /** * Decrypt the record ciphertext into plaintext using a record view key. * * @param {Field} record_vk Record view key used to decrypt the record. * * @returns {RecordPlaintext} */ decryptWithRecordViewKey(record_vk: Field): RecordPlaintext; /** * Get the tag of the record using the graph key. * * @param {GraphKey} graph key of the account associatd with the record. * @param {Field} commitment of the record. * * @returns {Field} tag of the record. */ static tag(graph_key: GraphKey, commitment: Field): Field; /** * Clone the RecordCiphertext WASM object. * * @returns {RecordCiphertext} A clone of the RecordCiphertext WASM object. */ clone(): RecordCiphertext; /** * Get the record nonce. * * @returns {Group} The record nonce. */ nonce(): Group; /** * Decrypt the record ciphertext into plaintext using the view key. The record will only * decrypt if the record was encrypted by the account corresponding to the view key * * @param {ViewKey} view_key View key used to decrypt the ciphertext * @returns {RecordPlaintext} Record plaintext object */ decrypt(view_key: ViewKey): RecordPlaintext; /** * Determines if the account corresponding to the view key is the owner of the record * * @param {ViewKey} view_key View key used to decrypt the ciphertext * @returns {boolean} */ isOwner(view_key: ViewKey): boolean; /** * Get the field array representation of the record ciphertext. * * @returns {Array} Field array representation of the record ciphertext. */ toFields(): Array; /** * Return the string representation of the record ciphertext * * @returns {string} String representation of the record ciphertext */ toString(): string; } /** * Plaintext representation of an Aleo record */ export class RecordPlaintext { private constructor(); free(): void; [Symbol.dispose](): void; commitment(program_id: string, record_name: string, record_view_key: string): Field; /** * Get the record entry matching a key. * * @param {string} input The key to retrieve the value in the record data field. * * @returns {Plaintext} The plaintext value corresponding to the key. */ getMember(input: string): Plaintext; /** * Returns the left endian boolean array representation of the record plaintext bits. * * @returns {Array} Boolean array representation of the record plaintext bits. */ toBitsLe(): Array; /** * Return a record plaintext from a string. * * @param {string} record String representation of a plaintext representation of an Aleo record. * * @returns {RecordPlaintext} Record plaintext */ static fromString(record: string): RecordPlaintext; /** * Returns the left endian byte array representation of the record plaintext. * * @returns {Uint8Array} Byte array representation of the record plaintext. */ toBytesLe(): Uint8Array; /** * Returns the amount of microcredits in the record * * @returns {u64} Amount of microcredits in the record */ microcredits(): bigint; /** * Get a representation of a record as a javascript object for usage in client side * computations. Note that this is not a reversible operation and exists for the convenience * of discovering and using properties of the record. * * The conversion guide is as follows: * - u8, u16, u32, i8, i16 i32 --> Number * - u64, u128, i64, i128 --> BigInt * - Address, Field, Group, Scalar --> String. * * Address, Field, Group, and Scalar will all be converted to their bech32 string * representation. These string representations can be converted back to their respective wasm * types using the fromString method on the Address, Field, Group, and Scalar objects in this * library. * * @example * # Create a wasm record from a record string. * let record_plaintext_wasm = RecordPlainext.from_string("{ * owner: aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48.private, * metadata: { * player1: aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48.private, * player2: aleo1dreuxnmg9cny8ee9v2u0wr4v4affnwm09u2pytfwz0f2en2shgqsdsfjn6.private, * nonce: 660310649780728486489183263981322848354071976582883879926426319832534836534field.private * }, * id: 1953278585719525811355617404139099418855053112960441725284031425961000152405field.private, * positions: 50794271u64.private, * attempts: 0u64.private, * hits: 0u64.private, * _nonce: 5668100912391182624073500093436664635767788874314097667746354181784048204413group.public * }"); * * let expected_object = { * owner: "aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48", * metadata: { * player1: "aleo1kh5t7m30djl0ecdn4f5vuzp7dx0tcwh7ncquqjkm4matj2p2zqpqm6at48", * player2: "aleo1dreuxnmg9cny8ee9v2u0wr4v4affnwm09u2pytfwz0f2en2shgqsdsfjn6", * nonce: "660310649780728486489183263981322848354071976582883879926426319832534836534field" * }, * id: "1953278585719525811355617404139099418855053112960441725284031425961000152405field", * positions: 50794271, * attempts: 0, * hits: 0, * _nonce: "5668100912391182624073500093436664635767788874314097667746354181784048204413group" * }; * * # Create the expected object * let record_plaintext_object = record_plaintext_wasm.to_js_object(); * assert(JSON.stringify(record_plaintext_object) == JSON.stringify(expected_object)); * * @returns {Object} Javascript object representation of the record */ toJsObject(): object; /** * Get a record plaintext object from a series of bytes. * * @param {Uint8Array} bytes A left endian byte array representing the record plaintext. * * @returns {RecordPlaintext} The record plaintext. */ static fromBytesLe(bytes: Uint8Array): RecordPlaintext; /** * Decrypt the sender ciphertext associated with the record. * * @param {ViewKey} view_key View key associated with the record. * @param {Field} sender_ciphertext Sender ciphertext associated with the record. * * @returns {Address} address of the sender. */ decryptSender(view_key: ViewKey, sender_ciphertext: Field): Address; /** * Generate the record view key. The record view key can only decrypt the record if the * supplied view key belongs to the record owner. * * @param {ViewKey} view_key View key used to generate the record view key * * @returns {Group} record view key */ recordViewKey(view_key: ViewKey): Field; /** * Attempt to get the serial number of a record to determine whether or not is has been spent * * @param {PrivateKey} private_key Private key of the account that owns the record * @param {string} program_id Program ID of the program that the record is associated with * @param {string} record_name Name of the record * @param {string} record_view_key The string representation of the record view key. * * @returns {string} Serial number of the record */ serialNumberString(private_key: PrivateKey, program_id: string, record_name: string, record_view_key: string): string; /** * Get the tag of the record using the graph key. */ tag(graph_key: GraphKey, commitment: Field): Field; /** * Clone the RecordPlaintext WASM object. * * @returns {RecordPlaintext} A clone of the RecordPlaintext WASM object. */ clone(): 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; /** * Returns the nonce of the record. This can be used to uniquely identify a record. * * @returns {string} Nonce of the record */ nonce(): string; /** * Get the owner of the record. * * @returns {Address} Address of the owner of the record. */ owner(): Address; /** * Get the field array representation of the record plaintext. */ toFields(): Array; /** * Returns the record plaintext string * * @returns {string} String representation of the record plaintext */ toString(): string; } /** * Scalar field element. */ export class Scalar { private constructor(); free(): void; [Symbol.dispose](): void; /** * Cast the scalar to an Address (strict, via Field x-coordinate recovery). * Returns an error if the resulting field is not a valid x-coordinate on the curve. */ toAddress(): Address; /** * Get the left endian boolean array representation of the scalar element. */ toBitsLe(): Array; /** * Cast the scalar to a Boolean (strict). * Returns an error if the scalar is not zero or one. */ toBoolean(): Boolean; /** * Creates a scalar object from a string representation of a scalar element. */ static fromString(group: string): Scalar; /** * Encode the scalar element as a Uint8Array of left endian bytes. */ toBytesLe(): Uint8Array; /** * Cast the scalar to an I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast the scalar to a U8 with lossy truncation. */ toU8Lossy(): U8; /** * Reconstruct a scalar element from a boolean array representation. */ static fromBitsLe(bits: Array): Scalar; /** * Cast the scalar to an I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast the scalar to an I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast the scalar to an I64 with lossy truncation. */ toI64Lossy(): I64; /** * Create a plaintext element from a scalar element. */ toPlaintext(): Plaintext; /** * Cast the scalar to a U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast the scalar to a U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast the scalar to a U64 with lossy truncation. */ toU64Lossy(): U64; /** * Create a scalar element from a Uint8Array of left endian bytes. */ static fromBytesLe(bytes: Uint8Array): Scalar; /** * Cast the scalar to an I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast the scalar to a U128 with lossy truncation. */ toU128Lossy(): U128; /** * Cast the scalar to a Group element with lossy conversion (via Field, Elligator-2 fallback). */ toGroupLossy(): Group; /** * Cast the scalar to an Address with lossy conversion (via Group, Elligator-2 fallback). */ toAddressLossy(): Address; /** * Cast the scalar to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Add two scalar elements. */ add(other: Scalar): Scalar; /** * Get the multiplicative identity of the scalar field. */ static one(): Scalar; /** * Power of a scalar element. */ pow(other: Scalar): Scalar; /** * Get the additive identity of the scalar field. */ static zero(): Scalar; /** * Clone the scalar element. */ clone(): Scalar; /** * Divide two scalar elements. */ divide(other: Scalar): Scalar; /** * Double the scalar element. */ double(): Scalar; /** * Check if one scalar element equals another. */ equals(other: Scalar): boolean; /** * Generate a random scalar element. */ static random(): Scalar; /** * Invert the scalar element. */ inverse(): Scalar; /** * Multiply two scalar elements. */ multiply(other: Scalar): Scalar; /** * Subtract two scalar elements. */ subtract(other: Scalar): Scalar; /** * Cast the scalar element to a field element. */ toField(): Field; /** * Cast the scalar to a Group element (strict, via Field x-coordinate recovery). * Returns an error if the resulting field is not a valid x-coordinate on the curve. */ toGroup(): Group; /** * Returns the string representation of the scalar element. */ toString(): string; } /** * Cryptographic signature of a message signed by an Aleo account */ export class Signature { private constructor(); free(): void; [Symbol.dispose](): void; /** * Sign an instance of a valid Aleo data type or record. * * @param {PrivateKey} private_key The private key used to sign the message. * @param {String} message The string representation of the Aleo datatype or record to sign. * @returns {Signature} Signature of the message. */ static signValue(private_key: PrivateKey, message: string): Signature; /** * Get an address from a signature. * * @returns {Address} Address object */ to_address(): Address; /** * Get the left endian boolean array representation of the bits of the signature. */ toBitsLe(): Array; /** * Get a signature from a string representation of a signature * * @param {string} signature String representation of a signature * @returns {Signature} Signature */ static from_string(signature: string): Signature; /** * Get the left endian byte array representation of the signature. */ toBytesLe(): Uint8Array; /** * Get a signature from a series of bits represented as a boolean array. * * @param {Array} bits A left endian boolean array representing the bits of the signature. * * @returns {Signature} The signature object. */ static fromBitsLe(bits: Array): Signature; /** * Get the plaintext representation of the signature. */ toPlaintext(): Plaintext; /** * Get a string representation of a signature * * @returns {string} String representation of a signature */ toString(): string; /** * Verify a signature over an Aleo datatype or record by an address. * * @param {Address} address The address used to verify the signature. * @param {String} message The message to verify, which must be the string representation of a valid Aleo datatype or record. * @returns {boolean} True if the signature is valid, false otherwise. */ verifyValue(address: Address, message: string): boolean; /** * Get a signature from a series of bytes. * * @param {Uint8Array} bytes A left endian byte array representing the signature. * * @returns {Signature} The signature object. */ static fromBytesLe(bytes: Uint8Array): Signature; /** * Sign a message with a private key * * @param {PrivateKey} private_key The private key to sign the message with * @param {Uint8Array} message Byte representation of the message to sign * @returns {Signature} Signature of the message */ static sign(private_key: PrivateKey, message: Uint8Array): Signature; /** * Verify a signature of a message with an address * * @param {Address} address The address to verify the signature with * @param {Uint8Array} message Byte representation of the message to verify * @returns {boolean} True if the signature is valid, false otherwise */ verify(address: Address, message: Uint8Array): boolean; /** * Get the response of a signature. */ response(): Scalar; /** * Get the challenge of a signature. */ challenge(): Scalar; /** * Get the field array representation of the signature. */ toFields(): Array; /** * Get a string representation of a signature * * @returns {string} String representation of a signature */ to_string(): string; } /** * Webassembly Representation of an Aleo transaction * * This object is created when generating an on-chain function deployment or execution and is the * object that should be submitted to the Aleo Network in order to deploy or execute a function. */ export class Transaction { private constructor(); free(): void; [Symbol.dispose](): void; /** * Returns the transaction's total fee. */ feeAmount(): bigint; /** * Returns true if the transaction is an execution transaction. * * @returns {boolean} True if the transaction is an execution transaction */ isExecute(): boolean; /** * Find a record in the transaction by the record's commitment. */ findRecord(commitment: Field): RecordCiphertext | undefined; /** * Create a transaction from a string * * @param {string} transaction String representation of a transaction * @returns {Transaction} */ static fromString(transaction: string): Transaction; /** * Get the transaction as a Uint8Array of left endian bytes. * * @returns {Uint8Array} Uint8Array representation of the transaction */ toBytesLe(): Uint8Array; /** * Get the transitions in a transaction. * * @returns {Array} Array of transition objects */ transitions(): Array; /** * Create a transaction from a Uint8Array of left endian bytes. * * @param {Uint8Array} Uint8Array of left endian bytes encoding a Transaction. * @returns {Transaction} */ static fromBytesLe(bytes: Uint8Array): Transaction; /** * Get the record plaintext present in a transaction owned by a specific view key. * * @param {ViewKey} view_key View key used to decrypt the ciphertext * * @returns {Array} Array of record plaintext objects */ ownedRecords(view_key: ViewKey): Array; /** * Get the verifying keys in a transaction. * * @returns {Array} Array of verifying keys. */ verifyingKeys(): Array; /** * Returns the transaction's base fee. */ baseFeeAmount(): bigint; /** * Returns the program deployed within the transaction if the transaction is a deployment * transaction. * * @returns {Program | undefined} The program deployed within the transaction. */ deployedProgram(): Program | undefined; /** * Get the type of the transaction (will return "deploy" or "execute") * * @returns {string} Transaction type */ transactionType(): string; /** * Returns true if the transaction contains the given commitment. * * @param {boolean} True if the transaction contains the given commitment. */ constainsCommitment(commitment: Field): boolean; /** * Returns the transaction's priority fee. * * returns {bigint} The transaction's priority fee. */ priorityFeeAmount(): bigint; /** * Returns true if the transaction contains the given serial number. * * @param {boolean} True if the transaction contains the given serial number. */ constainsSerialNumber(serial_number: Field): boolean; /** * Get the id of the transaction. This is the merkle root of the transaction's inclusion proof. * * This value can be used to query the status of the transaction on the Aleo Network to see * if it was successful. If successful, the transaction will be included in a block and this * value can be used to lookup the transaction data on-chain. * * @returns {string} TransactionId */ id(): string; /** * Returns true if the transaction is a fee transaction. * * @returns {boolean} True if the transaction is a fee transaction */ isFee(): boolean; /** * Get the records present in a transaction and their commitments. * * @returns {Array<{commitment: Field, record: RecordCiphertext}>} Array of record ciphertext objects */ records(): Array; /** * Get a summary of the transaction within a javascript object. * * If the transaction is an execution transaction, this function will return a list of the * transitions and their inputs and outputs. * * If the transaction is a deployment transaction, this function will return the program id and * a list of the functions and their verifying keys, constraint, and variable counts. * * @param {boolean} convert_to_js If true the inputs and outputs will be converted to JS objects, * if false the inputs and outputs will be in wasm format. * * @returns {Object} Transaction summary */ summary(convert_to_js: boolean): object; /** * Returns the execution within the transaction (if present). * * @returns {Execution | undefined} The execution within the transaction. */ execution(): Execution | undefined; /** * Returns true if the transaction is a deployment transaction. * * @returns {boolean} True if the transaction is a deployment transaction */ isDeploy(): boolean; /** * Get the transaction as a string. If you want to submit this transaction to the Aleo Network * this function will create the string that should be submitted in the `POST` data. * * @returns {string} String representation of the transaction */ toString(): string; } export class Transition { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get the program ID of the transition. */ programId(): string; /** * Find a record in the transition by the record's commitment. */ findRecord(commitment: Field): RecordCiphertext | undefined; /** * Create a transition from a string * * @param {string} transition String representation of a transition * @returns {Transition} */ static fromString(transition: string): Transition; /** * Get the transition as a Uint8Array of left endian bytes. * * @returns {Uint8Array} Uint8Array representation of the transition */ toBytesLe(): Uint8Array; /** * Create a transition from a Uint8Array of left endian bytes. * * @param {Uint8Array} Uint8Array of left endian bytes encoding a Transition. * @returns {Transition} */ static fromBytesLe(bytes: Uint8Array): Transition; /** * Get the function name of the transition. */ functionName(): string; /** * Get the record plaintext present in a transition owned by a specific view key. * * @param {ViewKey} view_key The view key of the record owner. * * @returns {Array} Array of record plaintext objects */ ownedRecords(view_key: ViewKey): Array; /** * Decrypt the transition using the transition view key. * * @param {Field} tvk The transition view key. * * @returns {Transition} The transition with public values for inputs and outputs. */ decryptTransition(tvk: Field): Transition; /** * Returns true if the transition contains the given commitment. * * @param {boolean} True if the transition contains the given commitment. */ containsCommitment(commitment: Field): boolean; /** * Check if the transition contains a serial number. * * @param {Field} serial_number The serial number to check for * * @returns {bool} True if the transition contains a serial number, false otherwise */ containsSerialNumber(serial_number: Field): boolean; /** * Get the transition ID * * @returns {string} The transition ID */ id(): string; /** * Get the transition signer commitment of the transition. * * @returns {Field} Transition signer commitment */ scm(): Field; /** * Get the transition commitment of the transition. * * @returns {Field} Transition commitment */ tcm(): Field; /** * Get the transition public key of the transition. * * @returns {Group} Transition public key */ tpk(): Group; /** * Get the transition view key of the transition. * * @param {ViewKey} view_key The view key of the transition signer. * * @returns {Field} Transition view key */ tvk(view_key: ViewKey): Field; /** * Get the inputs of the transition. * * @param {bool} convert_to_js If true the inputs will be converted to JS objects, if false * the inputs will be in wasm format. * * @returns {Array} Array of inputs */ inputs(convert_to_js: boolean): Array; /** * Get the outputs of the transition. * * @param {bool} convert_to_js If true the outputs will be converted to JS objects, if false * the outputs will be in wasm format. * * @returns {Array} Array of outputs */ outputs(convert_to_js: boolean): Array; /** * Get the records present in a transition and their commitments. * * @returns {Array<{commitment: Field, record: RecordCiphertext}>} Array of record ciphertext objects */ records(): Array; /** * Get the transition as a string. If you want to submit this transition to the Aleo Network * this function will create the string that should be submitted in the `POST` data. * * @returns {string} String representation of the transition */ toString(): string; } export class U128 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): U128; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): U128; /** * Wrapped absolute value. */ absWrapped(): U128; /** * Wrapped addition with another integer. */ addWrapped(other: U128): U128; /** * Wrapped division. */ divWrapped(other: U128): U128; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): U128; /** * Construct an integer from a string representation. */ static fromString(s: string): U128; /** * Wrapped multiplication with another integer. */ mulWrapped(other: U128): U128; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: U128): U128; /** * Wrapped subtraction with another integer. */ subWrapped(other: U128): U128; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): U128; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): U128; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): U128; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): U128; /** * Get the remainder from integer division. */ rem(other: U128): U128; /** * Clone the integer in wasm memory. */ clone(): U128; /** * Check equality with another integer. */ equals(other: U128): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): U128; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): U128; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): U128; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class U16 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): U16; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): U16; /** * Wrapped absolute value. */ absWrapped(): U16; /** * Wrapped addition with another integer. */ addWrapped(other: U16): U16; /** * Wrapped division. */ divWrapped(other: U16): U16; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): U16; /** * Construct an integer from a string representation. */ static fromString(s: string): U16; /** * Wrapped multiplication with another integer. */ mulWrapped(other: U16): U16; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: U16): U16; /** * Wrapped subtraction with another integer. */ subWrapped(other: U16): U16; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): U16; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): U16; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): U16; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): U16; /** * Get the remainder from integer division. */ rem(other: U16): U16; /** * Clone the integer in wasm memory. */ clone(): U16; /** * Check equality with another integer. */ equals(other: U16): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): U16; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): U16; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): U16; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class U32 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): U32; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): U32; /** * Wrapped absolute value. */ absWrapped(): U32; /** * Wrapped addition with another integer. */ addWrapped(other: U32): U32; /** * Wrapped division. */ divWrapped(other: U32): U32; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): U32; /** * Construct an integer from a string representation. */ static fromString(s: string): U32; /** * Wrapped multiplication with another integer. */ mulWrapped(other: U32): U32; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: U32): U32; /** * Wrapped subtraction with another integer. */ subWrapped(other: U32): U32; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): U32; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): U32; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): U32; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): U32; /** * Get the remainder from integer division. */ rem(other: U32): U32; /** * Clone the integer in wasm memory. */ clone(): U32; /** * Check equality with another integer. */ equals(other: U32): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): U32; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): U32; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): U32; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class U64 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): U64; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): U64; /** * Wrapped absolute value. */ absWrapped(): U64; /** * Wrapped addition with another integer. */ addWrapped(other: U64): U64; /** * Wrapped division. */ divWrapped(other: U64): U64; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): U64; /** * Construct an integer from a string representation. */ static fromString(s: string): U64; /** * Wrapped multiplication with another integer. */ mulWrapped(other: U64): U64; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: U64): U64; /** * Wrapped subtraction with another integer. */ subWrapped(other: U64): U64; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): U64; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): U64; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): U64; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): U64; /** * Get the remainder from integer division. */ rem(other: U64): U64; /** * Clone the integer in wasm memory. */ clone(): U64; /** * Check equality with another integer. */ equals(other: U64): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): U64; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): U64; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): U64; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ toString(): string; } export class U8 { private constructor(); free(): void; [Symbol.dispose](): void; /** * Attempt to construct the integer from a field element. */ static fromField(field: Field): U8; /** * Get the boolean array representation of the integer. */ toBitsLe(): Array; /** * Checked absolute value. */ absChecked(): U8; /** * Wrapped absolute value. */ absWrapped(): U8; /** * Wrapped addition with another integer. */ addWrapped(other: U8): U8; /** * Wrapped division. */ divWrapped(other: U8): U8; /** * Atttempt to construct the integer from a list of field elements. */ static fromFields(fields: Array): U8; /** * Construct an integer from a string representation. */ static fromString(s: string): U8; /** * Wrapped multiplication with another integer. */ mulWrapped(other: U8): U8; /** * Get the remainder from an integer division which wraps if there's an overflow. */ remWrapped(other: U8): U8; /** * Wrapped subtraction with another integer. */ subWrapped(other: U8): U8; /** * Construct an integer from a byte array representation. */ toBytesLe(): Uint8Array; /** * Cast to I8 with lossy truncation. */ toI8Lossy(): I8; /** * Cast to U8 with lossy truncation. */ toU8Lossy(): U8; /** * Construct an integer from a boolean array representation. */ static fromBitsLe(bits: Array): U8; /** * Cast to I16 with lossy truncation. */ toI16Lossy(): I16; /** * Cast to I32 with lossy truncation. */ toI32Lossy(): I32; /** * Cast to I64 with lossy truncation. */ toI64Lossy(): I64; /** * Convert the integer to the Plaintext type. This must be done before hashing an integer to ensure it matches hashes with a leo/aleo program. */ toPlaintext(): Plaintext; /** * Cast to U16 with lossy truncation. */ toU16Lossy(): U16; /** * Cast to U32 with lossy truncation. */ toU32Lossy(): U32; /** * Cast to U64 with lossy truncation. */ toU64Lossy(): U64; /** * Get the byte array representation of the integer. */ static fromBytesLe(bytes: Uint8Array): U8; /** * Cast to I128 with lossy truncation. */ toI128Lossy(): I128; /** * Cast to U128 with lossy truncation. */ toU128Lossy(): U128; /** * Construct an integer from a field element with lossy truncation. */ static fromFieldLossy(field: Field): U8; /** * Cast the integer to a Boolean with lossy truncation (extracts least-significant bit). */ toBooleanLossy(): Boolean; /** * Negate the integer (e.g., 5 → -5). */ neg(): U8; /** * Get the remainder from integer division. */ rem(other: U8): U8; /** * Clone the integer in wasm memory. */ clone(): U8; /** * Check equality with another integer. */ equals(other: U8): boolean; /** * Exponentiate the integer with a u8 exponent. */ powU8(exponent: U8): U8; /** * Exponentiate the integer with a u16 exponent. */ powU16(exponent: U16): U8; /** * Exponentiate the integer with a u32 exponent. */ powU32(exponent: U32): U8; /** * Convert the integer to a Field element (lossless). */ toField(): Field; /** * Convert the integer to a Scalar value. */ toScalar(): Scalar; /** * Get the string representation of the integer. */ 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; /** * Returns the little-endian boolean array representation of the bits. * * @returns {Array} Boolean array of bits in little-endian order. */ toBitsLe(): Array; /** * Returns the type of the value variant as a string. * * Possible values: "plaintext", "record", "future", "dynamic_record", or "dynamic_future". * * @returns {string} The variant type name. */ valueType(): string; /** * 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 the little-endian byte array representation of the value. * * @returns {Uint8Array} The little-endian byte array. */ toBytesLe(): Uint8Array; /** * Returns true if the value is a Plaintext variant. * * @returns {boolean} */ isPlaintext(): boolean; /** * 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; /** * 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; /** * Returns the raw field array representation of the value. * * @returns {Array} Array of raw Field elements. */ toFieldsRaw(): Array; /** * 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; /** * Returns the raw big-endian boolean array representation of the bits. * * @returns {Array} Raw boolean array of bits in big-endian order. */ toBitsRawBe(): Array; /** * Returns the raw little-endian boolean array representation of the bits. * * @returns {Array} Raw boolean array of bits in little-endian order. */ toBitsRawLe(): Array; /** * 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; /** * 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; /** * 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 Record variant. * * @returns {boolean} */ isRecord(): boolean; /** * Returns the field array representation of the value. * * @returns {Array} Array of Field elements. */ toFields(): Array; /** * Returns the string representation of the value. * * @returns {string} The string representation of the value. */ toString(): string; } /** * Verifying key for a function within an Aleo program */ export class VerifyingKey { private constructor(); free(): void; [Symbol.dispose](): void; /** * Construct a new verifying key from a byte array * * @param {Uint8Array} bytes Byte representation of a verifying key * @returns {VerifyingKey} */ static fromBytes(bytes: Uint8Array): VerifyingKey; /** * Create a verifying key from string * * @param {String} string String representation of a verifying key * @returns {VerifyingKey} */ static fromString(string: string): VerifyingKey; /** * Get the number of constraints associated with the circuit * * @returns {number} The number of constraints */ numConstraints(): number; /** * Verify a batch SNARK proof against multiple verifying keys and their corresponding public inputs. * * @param {Array} verifying_keys Array of verifying key strings, one per circuit * @param {Array>>} 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, inputs: Array, proof: Proof): boolean; /** * Create a copy of the verifying key * * @returns {VerifyingKey} A copy of the verifying key */ copy(): VerifyingKey; /** * Verify a SNARK proof against this verifying key and public inputs. * * @param {Array} 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, proof: Proof): boolean; /** * Get the checksum of the verifying key * * @returns {string} Checksum of the verifying key */ checksum(): string; /** * Create a byte array from a verifying key * * @returns {Uint8Array} Byte representation of a verifying key */ toBytes(): Uint8Array; /** * Get a string representation of the verifying key * * @returns {String} String representation of the verifying key */ toString(): string; /** * Returns the verifying key for the join function * * @returns {VerifyingKey} Verifying key for the join function */ static joinVerifier(): VerifyingKey; /** * Returns the verifying key for the split function * * @returns {VerifyingKey} Verifying key for the split function */ static splitVerifier(): VerifyingKey; /** * Verifies the verifying key is for the join function * * @returns {bool} */ isJoinVerifier(): boolean; /** * Verifies the verifying key is for the split function * * @returns {bool} */ isSplitVerifier(): boolean; /** * Returns the verifying key for the inclusion function * * @returns {VerifyingKey} Verifying key for the inclusion function */ static inclusionVerifier(): VerifyingKey; /** * Returns the verifying key for the fee_public function * * @returns {VerifyingKey} Verifying key for the fee_public function */ static feePublicVerifier(): VerifyingKey; /** * Returns the verifying key for the bond_public function * * @returns {VerifyingKey} Verifying key for the bond_public function */ static bondPublicVerifier(): VerifyingKey; /** * Returns the verifying key for the fee_private function * * @returns {VerifyingKey} Verifying key for the fee_private function */ static feePrivateVerifier(): VerifyingKey; /** * Verifies the verifying key is for the inclusion function * * @returns {bool} */ isInclusionVerifier(): boolean; /** * Verifies the verifying key is for the fee_public function * * @returns {bool} */ isFeePublicVerifier(): boolean; /** * Returns the verifying key for the unbond_public function * * @returns {VerifyingKey} Verifying key for the unbond_public function */ static unbondPublicVerifier(): VerifyingKey; /** * Returns the verifying key for the bond_validator function * * @returns {VerifyingKey} Verifying key for the bond_validator function */ static bondValidatorVerifier(): VerifyingKey; /** * Returns the verifying key for the bond_public function * * @returns {VerifyingKey} Verifying key for the bond_public function */ isBondPublicVerifier(): boolean; /** * Verifies the verifying key is for the fee_private function * * @returns {bool} */ isFeePrivateVerifier(): boolean; /** * Returns the verifying key for the transfer_public function * * @returns {VerifyingKey} Verifying key for the transfer_public function */ static transferPublicVerifier(): VerifyingKey; /** * Verifies the verifying key is for the unbond_public function * * @returns {bool} */ isUnbondPublicVerifier(): boolean; /** * Returns the verifying key for the transfer_private function * * @returns {VerifyingKey} Verifying key for the transfer_private function */ static transferPrivateVerifier(): VerifyingKey; /** * Returns the verifying key for the bond_validator function * * @returns {VerifyingKey} Verifying key for the bond_validator function */ isBondValidatorVerifier(): boolean; /** * Verifies the verifying key is for the transfer_public function * * @returns {bool} */ isTransferPublicVerifier(): boolean; /** * Returns the verifying key for the claim_delegator function * * @returns {VerifyingKey} Verifying key for the claim_unbond_public function */ static claimUnbondPublicVerifier(): VerifyingKey; /** * Verifies the verifying key is for the transfer_private function * * @returns {bool} */ isTransferPrivateVerifier(): boolean; /** * Returns the verifying key for the set_validator_state function * * @returns {VerifyingKey} Verifying key for the set_validator_state function */ static setValidatorStateVerifier(): VerifyingKey; /** * Verifies the verifying key is for the claim_delegator function * * @returns {bool} */ isClaimUnbondPublicVerifier(): boolean; /** * Verifies the verifying key is for the set_validator_state function * * @returns {bool} */ isSetValidatorStateVerifier(): boolean; /** * Returns the verifying key for the transfer_public_as_signer function * * @returns {VerifyingKey} Verifying key for the transfer_public_as_signer function */ static transferPublicAsSignerVerifier(): VerifyingKey; /** * Returns the verifying key for the transfer_private_to_public function * * @returns {VerifyingKey} Verifying key for the transfer_private_to_public function */ static transferPrivateToPublicVerifier(): VerifyingKey; /** * Returns the verifying key for the transfer_public_to_private function * * @returns {VerifyingKey} Verifying key for the transfer_public_to_private function */ static transferPublicToPrivateVerifier(): VerifyingKey; /** * Verifies the verifying key is for the transfer_public_as_signer function * * @returns {bool} */ isTransferPublicAsSignerVerifier(): boolean; /** * Verifies the verifying key is for the transfer_private_to_public function * * @returns {bool} */ isTransferPrivateToPublicVerifier(): boolean; /** * Verifies the verifying key is for the transfer_public_to_private function * * @returns {bool} */ isTransferPublicToPrivateVerifier(): boolean; } export class ViewKey { private constructor(); free(): void; [Symbol.dispose](): void; /** * Get the address corresponding to a view key * * @returns {Address} Address */ to_address(): Address; /** * Create a new view key from a string representation of a view key * * @param {string} view_key String representation of a view key * @returns {ViewKey} View key */ static from_string(view_key: string): ViewKey; /** * Get the underlying bytes of a view key. * * @returns {Uint8Array} Left endian byte array representation of the view key. */ toBytesLe(): Uint8Array; /** * Get a string representation of a view key * * @returns {string} String representation of a view key */ toString(): string; /** * Get a ViewKey from a series of bytes. * * @param {Uint8Array} bytes A left endian byte array representing the view key. * * @returns {ViewKey} The view key object. */ static fromBytesLe(bytes: Uint8Array): ViewKey; /** * Create a new view key from a private key * * @param {PrivateKey} private_key Private key * @returns {ViewKey} View key */ static from_private_key(private_key: PrivateKey): ViewKey; /** * Decrypt a record ciphertext with a view key * * @param {string} ciphertext String representation of a record ciphertext * @returns {string} String representation of a record plaintext */ decrypt(ciphertext: string): string; /** * Cast the view key to a field. */ toField(): Field; /** * Get the underlying scalar of a view key. */ to_scalar(): Scalar; /** * Get a string representation of a view key * * @returns {string} String representation of a view key */ to_string(): string; }